VirtualBox

source: vbox/trunk/include/VBox/VBoxGuest.h@ 14214

Last change on this file since 14214 was 14214, checked in by vboxsync, 16 years ago

Additions/Guest Library: add R3 property wait API
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 56.8 KB
Line 
1/** @file
2 * VBoxGuest - VirtualBox Guest Additions interface
3 */
4
5/*
6 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
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 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
26 * Clara, CA 95054 USA or visit http://www.sun.com if you need
27 * additional information or have any questions.
28 */
29
30#ifndef ___VBox_VBoxGuest_h
31#define ___VBox_VBoxGuest_h
32
33#include <iprt/cdefs.h>
34#include <iprt/types.h>
35#ifdef IN_RING3
36# include <iprt/stdarg.h>
37#endif
38#include <VBox/err.h>
39#include <VBox/ostypes.h>
40
41/*******************************************************************************
42* Defined Constants And Macros *
43*******************************************************************************/
44
45/** @todo The following is a temporary fix for the problem of accessing
46 hypervisor pointers from within guest additions */
47
48/** Hypervisor linear pointer size type */
49typedef RTGCPTR32 VMMDEVHYPPTR32;
50typedef RTGCPTR64 VMMDEVHYPPTR64;
51/** Hypervisor physical pointer size type */
52typedef RTGCPHYS32 VMMDEVHYPPHYS32;
53typedef RTGCPHYS64 VMMDEVHYPPHYS64;
54
55#if defined(VBOX_WITH_64_BITS_GUESTS) && ARCH_BITS == 64
56# define VMMDEVHYPPTR VMMDEVHYPPTR64
57# define VMMDEVHYPPHYS VMMDEVHYPPHYS64
58# else
59# define VMMDEVHYPPTR VMMDEVHYPPTR32
60# define VMMDEVHYPPHYS VMMDEVHYPPHYS32
61#endif
62
63#if defined(RT_OS_LINUX)
64/** The support device name. */
65# define VBOXGUEST_DEVICE_NAME "/dev/vboxadd"
66
67#elif defined(RT_OS_OS2)
68/** The support device name. */
69# define VBOXGUEST_DEVICE_NAME "\\Dev\\VBoxGst$"
70
71#elif defined(RT_OS_SOLARIS)
72/** The support device name. */
73# define VBOXGUEST_DEVICE_NAME "/dev/vboxguest"
74
75#elif defined(RT_OS_WINDOWS)
76/** The support service name. */
77# define VBOXGUEST_SERVICE_NAME "VBoxGuest"
78/** Win32 Device name. */
79# define VBOXGUEST_DEVICE_NAME "\\\\.\\VBoxGuest"
80/** Global name for Win2k+ */
81# define VBOXGUEST_DEVICE_NAME_GLOBAL "\\\\.\\Global\\VBoxGuest"
82/** Win32 driver name */
83# define VBOXGUEST_DEVICE_NAME_NT L"\\Device\\VBoxGuest"
84/** device name */
85# define VBOXGUEST_DEVICE_NAME_DOS L"\\DosDevices\\VBoxGuest"
86
87#elif defined(RT_OS_FREEBSD)
88/** The support device name. */
89# define VBOXGUEST_DEVICE_NAME "/dev/vboxguest"
90
91#else
92/* PORTME */
93#endif
94
95/** VirtualBox vendor ID */
96#define VBOX_PCI_VENDORID (0x80ee)
97
98/** VMMDev PCI card identifiers */
99#define VMMDEV_VENDORID VBOX_PCI_VENDORID
100#define VMMDEV_DEVICEID (0xcafe)
101
102/** VirtualBox graphics card identifiers */
103#define VBOX_VENDORID VBOX_PCI_VENDORID
104#define VBOX_VESA_VENDORID VBOX_PCI_VENDORID
105#define VBOX_DEVICEID (0xbeef)
106#define VBOX_VESA_DEVICEID (0xbeef)
107
108/**
109 * VBoxGuest port definitions
110 * @{
111 */
112
113/** guest can (== wants to) handle absolute coordinates */
114#define VBOXGUEST_MOUSE_GUEST_CAN_ABSOLUTE RT_BIT(0)
115/** host can (== wants to) send absolute coordinates */
116#define VBOXGUEST_MOUSE_HOST_CAN_ABSOLUTE RT_BIT(1)
117/** guest can *NOT* switch to software cursor and therefore depends on the host cursor */
118#define VBOXGUEST_MOUSE_GUEST_NEEDS_HOST_CURSOR RT_BIT(2)
119/** host does NOT provide support for drawing the cursor itself (e.g. L4 console) */
120#define VBOXGUEST_MOUSE_HOST_CANNOT_HWPOINTER RT_BIT(3)
121
122/** fictive start address of the hypervisor physical memory for MmMapIoSpace */
123#define HYPERVISOR_PHYSICAL_START 0xf8000000
124
125/*
126 * VMMDev Generic Request Interface
127 */
128
129/** port for generic request interface */
130#define PORT_VMMDEV_REQUEST_OFFSET 0
131
132/** Current version of the VMMDev interface.
133 *
134 * Additions are allowed to work only if
135 * additions_major == vmmdev_current && additions_minor <= vmmdev_current.
136 * Additions version is reported to host (VMMDev) by VMMDevReq_ReportGuestInfo.
137 *
138 * @remark These defines also live in the 16-bit and assembly versions of this header.
139 */
140#define VMMDEV_VERSION 0x00010004
141#define VMMDEV_VERSION_MAJOR (VMMDEV_VERSION >> 16)
142#define VMMDEV_VERSION_MINOR (VMMDEV_VERSION & 0xffff)
143
144/* Maximum request packet size */
145#define VMMDEV_MAX_VMMDEVREQ_SIZE _1M
146
147/**
148 * VMMDev request types.
149 * @note when updating this, adjust vmmdevGetRequestSize() as well
150 */
151typedef enum
152{
153 VMMDevReq_InvalidRequest = 0,
154 VMMDevReq_GetMouseStatus = 1,
155 VMMDevReq_SetMouseStatus = 2,
156 VMMDevReq_SetPointerShape = 3,
157 /** @todo implement on host side */
158 VMMDevReq_GetHostVersion = 4,
159 VMMDevReq_Idle = 5,
160 VMMDevReq_GetHostTime = 10,
161 VMMDevReq_GetHypervisorInfo = 20,
162 VMMDevReq_SetHypervisorInfo = 21,
163 VMMDevReq_SetPowerStatus = 30,
164 VMMDevReq_AcknowledgeEvents = 41,
165 VMMDevReq_CtlGuestFilterMask = 42,
166 VMMDevReq_ReportGuestInfo = 50,
167 VMMDevReq_GetDisplayChangeRequest = 51,
168 VMMDevReq_VideoModeSupported = 52,
169 VMMDevReq_GetHeightReduction = 53,
170 VMMDevReq_GetDisplayChangeRequest2 = 54,
171 VMMDevReq_ReportGuestCapabilities = 55,
172 VMMDevReq_SetGuestCapabilities = 56,
173#ifdef VBOX_WITH_HGCM
174 VMMDevReq_HGCMConnect = 60,
175 VMMDevReq_HGCMDisconnect = 61,
176#ifdef VBOX_WITH_64_BITS_GUESTS
177 VMMDevReq_HGCMCall32 = 62,
178 VMMDevReq_HGCMCall64 = 63,
179#else
180 VMMDevReq_HGCMCall = 62,
181#endif /* VBOX_WITH_64_BITS_GUESTS */
182 VMMDevReq_HGCMCancel = 64,
183#endif
184 VMMDevReq_VideoAccelEnable = 70,
185 VMMDevReq_VideoAccelFlush = 71,
186 VMMDevReq_VideoSetVisibleRegion = 72,
187 VMMDevReq_GetSeamlessChangeRequest = 73,
188 VMMDevReq_QueryCredentials = 100,
189 VMMDevReq_ReportCredentialsJudgement = 101,
190 VMMDevReq_ReportGuestStats = 110,
191 VMMDevReq_GetMemBalloonChangeRequest = 111,
192 VMMDevReq_GetStatisticsChangeRequest = 112,
193 VMMDevReq_ChangeMemBalloon = 113,
194 VMMDevReq_GetVRDPChangeRequest = 150,
195 VMMDevReq_LogString = 200,
196 VMMDevReq_SizeHack = 0x7fffffff
197} VMMDevRequestType;
198
199#ifdef VBOX_WITH_64_BITS_GUESTS
200/*
201 * Constants and structures are redefined for the guest.
202 *
203 * Host code MUST always use either *32 or *64 variant explicitely.
204 * Host source code will use VBOX_HGCM_HOST_CODE define to catch undefined
205 * data types and constants.
206 *
207 * This redefinition means that the new additions builds will use
208 * the *64 or *32 variants depending on the current architecture bit count (ARCH_BITS).
209 */
210# ifndef VBOX_HGCM_HOST_CODE
211# if ARCH_BITS == 64
212# define VMMDevReq_HGCMCall VMMDevReq_HGCMCall64
213# elif ARCH_BITS == 32
214# define VMMDevReq_HGCMCall VMMDevReq_HGCMCall32
215# else
216# error "Unsupported ARCH_BITS"
217# endif
218# endif /* !VBOX_HGCM_HOST_CODE */
219#endif /* VBOX_WITH_64_BITS_GUESTS */
220
221/** Version of VMMDevRequestHeader structure. */
222#define VMMDEV_REQUEST_HEADER_VERSION (0x10001)
223
224#pragma pack(4)
225/** generic VMMDev request header */
226typedef struct
227{
228 /** size of the structure in bytes (including body). Filled by caller */
229 uint32_t size;
230 /** version of the structure. Filled by caller */
231 uint32_t version;
232 /** type of the request */
233 VMMDevRequestType requestType;
234 /** return code. Filled by VMMDev */
235 int32_t rc;
236 /** reserved fields */
237 uint32_t reserved1;
238 uint32_t reserved2;
239} VMMDevRequestHeader;
240
241/** mouse status request structure */
242typedef struct
243{
244 /** header */
245 VMMDevRequestHeader header;
246 /** mouse feature mask */
247 uint32_t mouseFeatures;
248 /** mouse x position */
249 uint32_t pointerXPos;
250 /** mouse y position */
251 uint32_t pointerYPos;
252} VMMDevReqMouseStatus;
253
254/** Note VBOX_MOUSE_POINTER_* flags are used in guest video driver,
255 * values must be <= 0x8000 and must not be changed.
256 */
257
258/** pointer is visible */
259#define VBOX_MOUSE_POINTER_VISIBLE (0x0001)
260/** pointer has alpha channel */
261#define VBOX_MOUSE_POINTER_ALPHA (0x0002)
262/** pointerData contains new pointer shape */
263#define VBOX_MOUSE_POINTER_SHAPE (0x0004)
264
265/** mouse pointer shape/visibility change request */
266typedef struct
267{
268 /** header */
269 VMMDevRequestHeader header;
270 /** VBOX_MOUSE_POINTER_* bit flags */
271 uint32_t fFlags;
272 /** x coordinate of hot spot */
273 uint32_t xHot;
274 /** y coordinate of hot spot */
275 uint32_t yHot;
276 /** width of the pointer in pixels */
277 uint32_t width;
278 /** height of the pointer in scanlines */
279 uint32_t height;
280 /** Pointer data.
281 *
282 ****
283 * The data consists of 1 bpp AND mask followed by 32 bpp XOR (color) mask.
284 *
285 * For pointers without alpha channel the XOR mask pixels are 32 bit values: (lsb)BGR0(msb).
286 * For pointers with alpha channel the XOR mask consists of (lsb)BGRA(msb) 32 bit values.
287 *
288 * Guest driver must create the AND mask for pointers with alpha channel, so if host does not
289 * support alpha, the pointer could be displayed as a normal color pointer. The AND mask can
290 * be constructed from alpha values. For example alpha value >= 0xf0 means bit 0 in the AND mask.
291 *
292 * The AND mask is 1 bpp bitmap with byte aligned scanlines. Size of AND mask,
293 * therefore, is cbAnd = (width + 7) / 8 * height. The padding bits at the
294 * end of any scanline are undefined.
295 *
296 * The XOR mask follows the AND mask on the next 4 bytes aligned offset:
297 * uint8_t *pXor = pAnd + (cbAnd + 3) & ~3
298 * Bytes in the gap between the AND and the XOR mask are undefined.
299 * XOR mask scanlines have no gap between them and size of XOR mask is:
300 * cXor = width * 4 * height.
301 ****
302 *
303 * Preallocate 4 bytes for accessing actual data as p->pointerData
304 */
305 char pointerData[4];
306} VMMDevReqMousePointer;
307
308/** string log request structure */
309typedef struct
310{
311 /** header */
312 VMMDevRequestHeader header;
313 /** variable length string data */
314 char szString[1];
315} VMMDevReqLogString;
316
317/** host version request structure */
318typedef struct
319{
320 /** header */
321 VMMDevRequestHeader header;
322 /** major version */
323 uint32_t major;
324 /** minor version */
325 uint32_t minor;
326 /** build number */
327 uint32_t build;
328} VMMDevReqHostVersion;
329
330/** guest capabilites structure */
331typedef struct
332{
333 /** header */
334 VMMDevRequestHeader header;
335 /** capabilities (VMMDEV_GUEST_*) */
336 uint32_t caps;
337} VMMDevReqGuestCapabilities;
338
339/** guest capabilites structure */
340typedef struct
341{
342 /** header */
343 VMMDevRequestHeader header;
344 /** mask of capabilities to be added */
345 uint32_t u32OrMask;
346 /** mask of capabilities to be removed */
347 uint32_t u32NotMask;
348} VMMDevReqGuestCapabilities2;
349
350/** idle request structure */
351typedef struct
352{
353 /** header */
354 VMMDevRequestHeader header;
355} VMMDevReqIdle;
356
357/** host time request structure */
358typedef struct
359{
360 /** header */
361 VMMDevRequestHeader header;
362 /** time in milliseconds since unix epoch. Filled by VMMDev. */
363 uint64_t time;
364} VMMDevReqHostTime;
365
366/** hypervisor info structure */
367typedef struct
368{
369 /** header */
370 VMMDevRequestHeader header;
371 /** guest virtual address of proposed hypervisor start */
372 /** TODO: Make this 64-bit compatible */
373 VMMDEVHYPPTR32 hypervisorStart;
374 /** hypervisor size in bytes */
375 uint32_t hypervisorSize;
376} VMMDevReqHypervisorInfo;
377
378/** system power requests */
379typedef enum
380{
381 VMMDevPowerState_Invalid = 0,
382 VMMDevPowerState_Pause = 1,
383 VMMDevPowerState_PowerOff = 2,
384 VMMDevPowerState_SaveState = 3,
385 VMMDevPowerState_SizeHack = 0x7fffffff
386} VMMDevPowerState;
387
388/** system power status structure */
389typedef struct
390{
391 /** header */
392 VMMDevRequestHeader header;
393 /** power state request */
394 VMMDevPowerState powerState;
395} VMMDevPowerStateRequest;
396
397/** pending events structure */
398typedef struct
399{
400 /** header */
401 VMMDevRequestHeader header;
402 /** pending event bitmap */
403 uint32_t events;
404} VMMDevEvents;
405
406/** guest filter mask control */
407typedef struct
408{
409 /** header */
410 VMMDevRequestHeader header;
411 /** mask of events to be added to filter */
412 uint32_t u32OrMask;
413 /** mask of events to be removed from filter */
414 uint32_t u32NotMask;
415} VMMDevCtlGuestFilterMask;
416
417/** guest information structure */
418typedef struct VBoxGuestInfo
419{
420 /** The VMMDev interface version expected by additions. */
421 uint32_t additionsVersion;
422 /** guest OS type */
423 VBOXOSTYPE osType;
424 /** @todo */
425} VBoxGuestInfo;
426
427/** guest information structure */
428typedef struct
429{
430 /** header */
431 VMMDevRequestHeader header;
432 /** Guest information. */
433 VBoxGuestInfo guestInfo;
434} VMMDevReportGuestInfo;
435
436/** guest statistics values */
437#define VBOX_GUEST_STAT_CPU_LOAD_IDLE RT_BIT(0)
438#define VBOX_GUEST_STAT_CPU_LOAD_KERNEL RT_BIT(1)
439#define VBOX_GUEST_STAT_CPU_LOAD_USER RT_BIT(2)
440#define VBOX_GUEST_STAT_THREADS RT_BIT(3)
441#define VBOX_GUEST_STAT_PROCESSES RT_BIT(4)
442#define VBOX_GUEST_STAT_HANDLES RT_BIT(5)
443#define VBOX_GUEST_STAT_MEMORY_LOAD RT_BIT(6)
444#define VBOX_GUEST_STAT_PHYS_MEM_TOTAL RT_BIT(7)
445#define VBOX_GUEST_STAT_PHYS_MEM_AVAIL RT_BIT(8)
446#define VBOX_GUEST_STAT_PHYS_MEM_BALLOON RT_BIT(9)
447#define VBOX_GUEST_STAT_MEM_COMMIT_TOTAL RT_BIT(10)
448#define VBOX_GUEST_STAT_MEM_KERNEL_TOTAL RT_BIT(11)
449#define VBOX_GUEST_STAT_MEM_KERNEL_PAGED RT_BIT(12)
450#define VBOX_GUEST_STAT_MEM_KERNEL_NONPAGED RT_BIT(13)
451#define VBOX_GUEST_STAT_MEM_SYSTEM_CACHE RT_BIT(14)
452#define VBOX_GUEST_STAT_PAGE_FILE_SIZE RT_BIT(15)
453
454
455/** guest statistics structure */
456typedef struct VBoxGuestStatistics
457{
458 /** Virtual CPU id */
459 uint32_t u32CpuId;
460 /** Reported statistics */
461 uint32_t u32StatCaps;
462 /** Idle CPU load (0-100) for last interval */
463 uint32_t u32CpuLoad_Idle;
464 /** Kernel CPU load (0-100) for last interval */
465 uint32_t u32CpuLoad_Kernel;
466 /** User CPU load (0-100) for last interval */
467 uint32_t u32CpuLoad_User;
468 /** Nr of threads */
469 uint32_t u32Threads;
470 /** Nr of processes */
471 uint32_t u32Processes;
472 /** Nr of handles */
473 uint32_t u32Handles;
474 /** Memory load (0-100) */
475 uint32_t u32MemoryLoad;
476 /** Page size of guest system */
477 uint32_t u32PageSize;
478 /** Total physical memory (in 4kb pages) */
479 uint32_t u32PhysMemTotal;
480 /** Available physical memory (in 4kb pages) */
481 uint32_t u32PhysMemAvail;
482 /** Ballooned physical memory (in 4kb pages) */
483 uint32_t u32PhysMemBalloon;
484 /** Total number of committed memory (which is not necessarily in-use) (in 4kb pages) */
485 uint32_t u32MemCommitTotal;
486 /** Total amount of memory used by the kernel (in 4kb pages) */
487 uint32_t u32MemKernelTotal;
488 /** Total amount of paged memory used by the kernel (in 4kb pages) */
489 uint32_t u32MemKernelPaged;
490 /** Total amount of nonpaged memory used by the kernel (in 4kb pages) */
491 uint32_t u32MemKernelNonPaged;
492 /** Total amount of memory used for the system cache (in 4kb pages) */
493 uint32_t u32MemSystemCache;
494 /** Pagefile size (in 4kb pages) */
495 uint32_t u32PageFileSize;
496} VBoxGuestStatistics;
497
498/** guest statistics command structure */
499typedef struct
500{
501 /** header */
502 VMMDevRequestHeader header;
503 /** Guest information. */
504 VBoxGuestStatistics guestStats;
505} VMMDevReportGuestStats;
506
507/** memory balloon change request structure */
508#define VMMDEV_MAX_MEMORY_BALLOON(PhysMemTotal) ((90*PhysMemTotal)/100)
509
510typedef struct
511{
512 /** header */
513 VMMDevRequestHeader header;
514 uint32_t u32BalloonSize; /* balloon size in megabytes */
515 uint32_t u32PhysMemSize; /* guest ram size in megabytes */
516 uint32_t eventAck;
517} VMMDevGetMemBalloonChangeRequest;
518
519/** inflate/deflate memory balloon structure */
520#define VMMDEV_MEMORY_BALLOON_CHUNK_PAGES (_1M/4096)
521#define VMMDEV_MEMORY_BALLOON_CHUNK_SIZE (VMMDEV_MEMORY_BALLOON_CHUNK_PAGES*4096)
522
523typedef struct
524{
525 /** header */
526 VMMDevRequestHeader header;
527 uint32_t cPages;
528 uint32_t fInflate; /* true = inflate, false = defalte */
529 /** Physical address (RTGCPHYS) of each page, variable size. */
530 RTGCPHYS aPhysPage[1];
531} VMMDevChangeMemBalloon;
532
533/** guest statistics interval change request structure */
534typedef struct
535{
536 /** header */
537 VMMDevRequestHeader header;
538 uint32_t u32StatInterval; /* interval in seconds */
539 uint32_t eventAck;
540} VMMDevGetStatisticsChangeRequest;
541
542/** display change request structure */
543typedef struct
544{
545 /** header */
546 VMMDevRequestHeader header;
547 /** horizontal pixel resolution (0 = do not change) */
548 uint32_t xres;
549 /** vertical pixel resolution (0 = do not change) */
550 uint32_t yres;
551 /** bits per pixel (0 = do not change) */
552 uint32_t bpp;
553 /** Flag that the request is an acknowlegement for the VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST.
554 * Values: 0 - just querying, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST - event acknowledged.
555 */
556 uint32_t eventAck;
557} VMMDevDisplayChangeRequest;
558
559typedef struct
560{
561 /** header */
562 VMMDevRequestHeader header;
563 /** horizontal pixel resolution (0 = do not change) */
564 uint32_t xres;
565 /** vertical pixel resolution (0 = do not change) */
566 uint32_t yres;
567 /** bits per pixel (0 = do not change) */
568 uint32_t bpp;
569 /** Flag that the request is an acknowlegement for the VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST.
570 * Values: 0 - just querying, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST - event acknowledged.
571 */
572 uint32_t eventAck;
573 /** 0 for primary display, 1 for the first secondary, etc. */
574 uint32_t display;
575} VMMDevDisplayChangeRequest2;
576
577/** video mode supported request structure */
578typedef struct
579{
580 /** header */
581 VMMDevRequestHeader header;
582 /** horizontal pixel resolution (input) */
583 uint32_t width;
584 /** vertical pixel resolution (input) */
585 uint32_t height;
586 /** bits per pixel (input) */
587 uint32_t bpp;
588 /** supported flag (output) */
589 bool fSupported;
590} VMMDevVideoModeSupportedRequest;
591
592/** video modes height reduction request structure */
593typedef struct
594{
595 /** header */
596 VMMDevRequestHeader header;
597 /** height reduction in pixels (output) */
598 uint32_t heightReduction;
599} VMMDevGetHeightReductionRequest;
600
601#define VRDP_EXPERIENCE_LEVEL_ZERO 0 /* Theming disabled. */
602#define VRDP_EXPERIENCE_LEVEL_LOW 1 /* Full window dragging and desktop wallpaper disabled. */
603#define VRDP_EXPERIENCE_LEVEL_MEDIUM 2 /* Font smoothing, gradients. */
604#define VRDP_EXPERIENCE_LEVEL_HIGH 3 /* Animation effects disabled. */
605#define VRDP_EXPERIENCE_LEVEL_FULL 4 /* Everything enabled. */
606
607typedef struct
608{
609 /** header */
610 VMMDevRequestHeader header;
611 /** Whether VRDP is active or not */
612 uint8_t u8VRDPActive;
613 /** The configured experience level for active VRDP. */
614 uint32_t u32VRDPExperienceLevel;
615} VMMDevVRDPChangeRequest;
616
617
618
619#pragma pack()
620
621#ifdef VBOX_WITH_HGCM
622
623/** HGCM flags.
624 * @{
625 */
626#define VBOX_HGCM_REQ_DONE (0x1)
627#define VBOX_HGCM_REQ_CANCELLED (0x2)
628/** @} */
629
630#pragma pack(4)
631typedef struct _VMMDevHGCMRequestHeader
632{
633 /** Request header. */
634 VMMDevRequestHeader header;
635
636 /** HGCM flags. */
637 uint32_t fu32Flags;
638
639 /** Result code. */
640 int32_t result;
641} VMMDevHGCMRequestHeader;
642
643/** HGCM service location types. */
644typedef enum
645{
646 VMMDevHGCMLoc_Invalid = 0,
647 VMMDevHGCMLoc_LocalHost = 1,
648 VMMDevHGCMLoc_LocalHost_Existing = 2,
649 VMMDevHGCMLoc_SizeHack = 0x7fffffff
650} HGCMServiceLocationType;
651
652typedef struct
653{
654 char achName[128]; /**< This is really szName. */
655} HGCMServiceLocationHost;
656
657typedef struct HGCMSERVICELOCATION
658{
659 /** Type of the location. */
660 HGCMServiceLocationType type;
661
662 union
663 {
664 HGCMServiceLocationHost host;
665 } u;
666} HGCMServiceLocation;
667
668typedef struct
669{
670 /* request header */
671 VMMDevHGCMRequestHeader header;
672
673 /** IN: Description of service to connect to. */
674 HGCMServiceLocation loc;
675
676 /** OUT: Client identifier assigned by local instance of HGCM. */
677 uint32_t u32ClientID;
678} VMMDevHGCMConnect;
679
680typedef struct
681{
682 /* request header */
683 VMMDevHGCMRequestHeader header;
684
685 /** IN: Client identifier. */
686 uint32_t u32ClientID;
687} VMMDevHGCMDisconnect;
688
689typedef enum
690{
691 VMMDevHGCMParmType_Invalid = 0,
692 VMMDevHGCMParmType_32bit = 1,
693 VMMDevHGCMParmType_64bit = 2,
694 VMMDevHGCMParmType_PhysAddr = 3,
695 VMMDevHGCMParmType_LinAddr = 4, /**< In and Out */
696 VMMDevHGCMParmType_LinAddr_In = 5, /**< In (read; host<-guest) */
697 VMMDevHGCMParmType_LinAddr_Out = 6, /**< Out (write; host->guest) */
698 VMMDevHGCMParmType_LinAddr_Locked = 7, /**< Locked In and Out */
699 VMMDevHGCMParmType_LinAddr_Locked_In = 8, /**< Locked In (read; host<-guest) */
700 VMMDevHGCMParmType_LinAddr_Locked_Out = 9, /**< Locked Out (write; host->guest) */
701 VMMDevHGCMParmType_SizeHack = 0x7fffffff
702} HGCMFunctionParameterType;
703
704#ifdef VBOX_WITH_64_BITS_GUESTS
705typedef struct _HGCMFUNCTIONPARAMETER32
706{
707 HGCMFunctionParameterType type;
708 union
709 {
710 uint32_t value32;
711 uint64_t value64;
712 struct
713 {
714 uint32_t size;
715
716 union
717 {
718 VMMDEVHYPPHYS32 physAddr;
719 VMMDEVHYPPTR32 linearAddr;
720 } u;
721 } Pointer;
722 } u;
723#ifdef __cplusplus
724 void SetUInt32(uint32_t u32)
725 {
726 type = VMMDevHGCMParmType_32bit;
727 u.value64 = 0; /* init unused bits to 0 */
728 u.value32 = u32;
729 }
730
731 int GetUInt32(uint32_t *pu32)
732 {
733 if (type == VMMDevHGCMParmType_32bit)
734 {
735 *pu32 = u.value32;
736 return VINF_SUCCESS;
737 }
738 return VERR_INVALID_PARAMETER;
739 }
740
741 void SetUInt64(uint64_t u64)
742 {
743 type = VMMDevHGCMParmType_64bit;
744 u.value64 = u64;
745 }
746
747 int GetUInt64(uint64_t *pu64)
748 {
749 if (type == VMMDevHGCMParmType_64bit)
750 {
751 *pu64 = u.value64;
752 return VINF_SUCCESS;
753 }
754 return VERR_INVALID_PARAMETER;
755 }
756
757 void SetPtr(void *pv, uint32_t cb)
758 {
759 type = VMMDevHGCMParmType_LinAddr;
760 u.Pointer.size = cb;
761 u.Pointer.u.linearAddr = (VMMDEVHYPPTR32)(uintptr_t)pv;
762 }
763#endif
764} HGCMFunctionParameter32;
765
766typedef struct _HGCMFUNCTIONPARAMETER64
767{
768 HGCMFunctionParameterType type;
769 union
770 {
771 uint32_t value32;
772 uint64_t value64;
773 struct
774 {
775 uint32_t size;
776
777 union
778 {
779 VMMDEVHYPPHYS64 physAddr;
780 VMMDEVHYPPTR64 linearAddr;
781 } u;
782 } Pointer;
783 } u;
784#ifdef __cplusplus
785 void SetUInt32(uint32_t u32)
786 {
787 type = VMMDevHGCMParmType_32bit;
788 u.value64 = 0; /* init unused bits to 0 */
789 u.value32 = u32;
790 }
791
792 int GetUInt32(uint32_t *pu32)
793 {
794 if (type == VMMDevHGCMParmType_32bit)
795 {
796 *pu32 = u.value32;
797 return VINF_SUCCESS;
798 }
799 return VERR_INVALID_PARAMETER;
800 }
801
802 void SetUInt64(uint64_t u64)
803 {
804 type = VMMDevHGCMParmType_64bit;
805 u.value64 = u64;
806 }
807
808 int GetUInt64(uint64_t *pu64)
809 {
810 if (type == VMMDevHGCMParmType_64bit)
811 {
812 *pu64 = u.value64;
813 return VINF_SUCCESS;
814 }
815 return VERR_INVALID_PARAMETER;
816 }
817
818 void SetPtr(void *pv, uint32_t cb)
819 {
820 type = VMMDevHGCMParmType_LinAddr;
821 u.Pointer.size = cb;
822 u.Pointer.u.linearAddr = (uintptr_t)pv;
823 }
824#endif
825} HGCMFunctionParameter64;
826#else /* !VBOX_WITH_64_BITS_GUESTS */
827typedef struct _HGCMFUNCTIONPARAMETER
828{
829 HGCMFunctionParameterType type;
830 union
831 {
832 uint32_t value32;
833 uint64_t value64;
834 struct
835 {
836 uint32_t size;
837
838 union
839 {
840 VMMDEVHYPPHYS32 physAddr;
841 VMMDEVHYPPTR32 linearAddr;
842 } u;
843 } Pointer;
844 } u;
845#ifdef __cplusplus
846 void SetUInt32(uint32_t u32)
847 {
848 type = VMMDevHGCMParmType_32bit;
849 u.value64 = 0; /* init unused bits to 0 */
850 u.value32 = u32;
851 }
852
853 int GetUInt32(uint32_t *pu32)
854 {
855 if (type == VMMDevHGCMParmType_32bit)
856 {
857 *pu32 = u.value32;
858 return VINF_SUCCESS;
859 }
860 return VERR_INVALID_PARAMETER;
861 }
862
863 void SetUInt64(uint64_t u64)
864 {
865 type = VMMDevHGCMParmType_64bit;
866 u.value64 = u64;
867 }
868
869 int GetUInt64(uint64_t *pu64)
870 {
871 if (type == VMMDevHGCMParmType_64bit)
872 {
873 *pu64 = u.value64;
874 return VINF_SUCCESS;
875 }
876 return VERR_INVALID_PARAMETER;
877 }
878
879 void SetPtr(void *pv, uint32_t cb)
880 {
881 type = VMMDevHGCMParmType_LinAddr;
882 u.Pointer.size = cb;
883 u.Pointer.u.linearAddr = (uintptr_t)pv;
884 }
885#endif
886} HGCMFunctionParameter;
887#endif /* !VBOX_WITH_64_BITS_GUESTS */
888
889
890#ifdef VBOX_WITH_64_BITS_GUESTS
891/* Redefine the structure type for the guest code. */
892# ifndef VBOX_HGCM_HOST_CODE
893# if ARCH_BITS == 64
894# define HGCMFunctionParameter HGCMFunctionParameter64
895# elif ARCH_BITS == 32
896# define HGCMFunctionParameter HGCMFunctionParameter32
897# else
898# error "Unsupported sizeof (void *)"
899# endif
900# endif /* !VBOX_HGCM_HOST_CODE */
901#endif /* VBOX_WITH_64_BITS_GUESTS */
902
903typedef struct
904{
905 /* request header */
906 VMMDevHGCMRequestHeader header;
907
908 /** IN: Client identifier. */
909 uint32_t u32ClientID;
910 /** IN: Service function number. */
911 uint32_t u32Function;
912 /** IN: Number of parameters. */
913 uint32_t cParms;
914 /** Parameters follow in form: HGCMFunctionParameter aParms[X]; */
915} VMMDevHGCMCall;
916#pragma pack()
917
918#define VMMDEV_HGCM_CALL_PARMS(a) ((HGCMFunctionParameter *)((uint8_t *)a + sizeof (VMMDevHGCMCall)))
919
920#ifdef VBOX_WITH_64_BITS_GUESTS
921/* Explicit defines for the host code. */
922# ifdef VBOX_HGCM_HOST_CODE
923# define VMMDEV_HGCM_CALL_PARMS32(a) ((HGCMFunctionParameter32 *)((uint8_t *)a + sizeof (VMMDevHGCMCall)))
924# define VMMDEV_HGCM_CALL_PARMS64(a) ((HGCMFunctionParameter64 *)((uint8_t *)a + sizeof (VMMDevHGCMCall)))
925# endif /* VBOX_HGCM_HOST_CODE */
926#endif /* VBOX_WITH_64_BITS_GUESTS */
927
928#define VBOX_HGCM_MAX_PARMS 32
929
930/* The Cancel request is issued using the same physical memory address
931 * as was used for the corresponding initial HGCMCall.
932 */
933typedef struct
934{
935 /* request header */
936 VMMDevHGCMRequestHeader header;
937} VMMDevHGCMCancel;
938
939#endif /* VBOX_WITH_HGCM */
940
941
942#define VBVA_F_STATUS_ACCEPTED (0x01)
943#define VBVA_F_STATUS_ENABLED (0x02)
944
945#pragma pack(4)
946
947typedef struct _VMMDevVideoAccelEnable
948{
949 /* request header */
950 VMMDevRequestHeader header;
951
952 /** 0 - disable, !0 - enable. */
953 uint32_t u32Enable;
954
955 /** The size of VBVAMEMORY::au8RingBuffer expected by driver.
956 * The host will refuse to enable VBVA if the size is not equal to
957 * VBVA_RING_BUFFER_SIZE.
958 */
959 uint32_t cbRingBuffer;
960
961 /** Guest initializes the status to 0. Host sets appropriate VBVA_F_STATUS_ flags. */
962 uint32_t fu32Status;
963
964} VMMDevVideoAccelEnable;
965
966typedef struct _VMMDevVideoAccelFlush
967{
968 /* request header */
969 VMMDevRequestHeader header;
970
971} VMMDevVideoAccelFlush;
972
973
974typedef struct _VMMDevVideoSetVisibleRegion
975{
976 /* request header */
977 VMMDevRequestHeader header;
978
979 /** Number of rectangles */
980 uint32_t cRect;
981
982 /** Rectangle array */
983 RTRECT Rect;
984} VMMDevVideoSetVisibleRegion;
985
986
987/** Seamless mode */
988typedef enum
989{
990 VMMDev_Seamless_Disabled = 0, /* normal mode; entire guest desktop displayed */
991 VMMDev_Seamless_Visible_Region = 1, /* visible region mode; only top-level guest windows displayed */
992 VMMDev_Seamless_Host_Window = 2 /* windowed mode; each top-level guest window is represented in a host window */
993} VMMDevSeamlessMode;
994
995typedef struct
996{
997 /** header */
998 VMMDevRequestHeader header;
999
1000 /** New seamless mode */
1001 VMMDevSeamlessMode mode;
1002 /** Flag that the request is an acknowlegement for the VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST.
1003 * Values: 0 - just querying, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST - event acknowledged.
1004 */
1005 uint32_t eventAck;
1006} VMMDevSeamlessChangeRequest;
1007
1008#pragma pack()
1009
1010#pragma pack(1)
1011/** VBVA command header. */
1012typedef struct _VBVACMDHDR
1013{
1014 /** Coordinates of affected rectangle. */
1015 int16_t x;
1016 int16_t y;
1017 uint16_t w;
1018 uint16_t h;
1019} VBVACMDHDR;
1020#pragma pack()
1021
1022/* The VBVA ring buffer is suitable for transferring large (< 2gb) amount of data.
1023 * For example big bitmaps which do not fit to the buffer.
1024 *
1025 * Guest starts writing to the buffer by initializing a record entry in the
1026 * aRecords queue. VBVA_F_RECORD_PARTIAL indicates that the record is being
1027 * written. As data is written to the ring buffer, the guest increases off32End
1028 * for the record.
1029 *
1030 * The host reads the aRecords on flushes and processes all completed records.
1031 * When host encounters situation when only a partial record presents and
1032 * cbRecord & ~VBVA_F_RECORD_PARTIAL >= VBVA_RING_BUFFER_SIZE - VBVA_RING_BUFFER_THRESHOLD,
1033 * the host fetched all record data and updates off32Head. After that on each flush
1034 * the host continues fetching the data until the record is completed.
1035 *
1036 */
1037
1038#define VBVA_RING_BUFFER_SIZE (_4M - _1K)
1039#define VBVA_RING_BUFFER_THRESHOLD (4 * _1K)
1040
1041#define VBVA_MAX_RECORDS (64)
1042
1043#define VBVA_F_MODE_ENABLED (0x00000001)
1044#define VBVA_F_MODE_VRDP (0x00000002)
1045#define VBVA_F_MODE_VRDP_RESET (0x00000004)
1046#define VBVA_F_MODE_VRDP_ORDER_MASK (0x00000008)
1047
1048#define VBVA_F_RECORD_PARTIAL (0x80000000)
1049
1050#pragma pack(1)
1051typedef struct _VBVARECORD
1052{
1053 /** The length of the record. Changed by guest. */
1054 uint32_t cbRecord;
1055} VBVARECORD;
1056
1057typedef struct _VBVAMEMORY
1058{
1059 /** VBVA_F_MODE_* */
1060 uint32_t fu32ModeFlags;
1061
1062 /** The offset where the data start in the buffer. */
1063 uint32_t off32Data;
1064 /** The offset where next data must be placed in the buffer. */
1065 uint32_t off32Free;
1066
1067 /** The ring buffer for data. */
1068 uint8_t au8RingBuffer[VBVA_RING_BUFFER_SIZE];
1069
1070 /** The queue of record descriptions. */
1071 VBVARECORD aRecords[VBVA_MAX_RECORDS];
1072 uint32_t indexRecordFirst;
1073 uint32_t indexRecordFree;
1074
1075 /* RDP orders supported by the client. The guest reports only them
1076 * and falls back to DIRTY rects for not supported ones.
1077 *
1078 * (1 << VBVA_VRDP_*)
1079 */
1080 uint32_t fu32SupportedOrders;
1081
1082} VBVAMEMORY;
1083#pragma pack()
1084
1085/** @} */
1086
1087
1088/**
1089 * VMMDev RAM
1090 * @{
1091 */
1092
1093#pragma pack(1)
1094/** Layout of VMMDEV RAM region that contains information for guest */
1095typedef struct
1096{
1097 /** size */
1098 uint32_t u32Size;
1099 /** version */
1100 uint32_t u32Version;
1101
1102 union {
1103 /** Flag telling that VMMDev set the IRQ and acknowlegment is required */
1104 struct {
1105 bool fHaveEvents;
1106 } V1_04;
1107
1108 struct {
1109 /** Pending events flags, set by host. */
1110 uint32_t u32HostEvents;
1111 /** Mask of events the guest wants to see, set by guest. */
1112 uint32_t u32GuestEventMask;
1113 } V1_03;
1114 } V;
1115
1116 VBVAMEMORY vbvaMemory;
1117
1118} VMMDevMemory;
1119#pragma pack()
1120
1121/** Version of VMMDevMemory structure. */
1122#define VMMDEV_MEMORY_VERSION (1)
1123
1124/** @} */
1125
1126
1127/**
1128 * VMMDev events.
1129 * @{
1130 */
1131
1132/** Host mouse capabilities has been changed. */
1133#define VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED RT_BIT(0)
1134/** HGCM event. */
1135#define VMMDEV_EVENT_HGCM RT_BIT(1)
1136/** A display change request has been issued. */
1137#define VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST RT_BIT(2)
1138/** Credentials are available for judgement. */
1139#define VMMDEV_EVENT_JUDGE_CREDENTIALS RT_BIT(3)
1140/** The guest has been restored. */
1141#define VMMDEV_EVENT_RESTORED RT_BIT(4)
1142/** Seamless mode state changed */
1143#define VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST RT_BIT(5)
1144/** Memory balloon size changed */
1145#define VMMDEV_EVENT_BALLOON_CHANGE_REQUEST RT_BIT(6)
1146/** Statistics interval changed */
1147#define VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST RT_BIT(7)
1148/** VRDP status changed. */
1149#define VMMDEV_EVENT_VRDP RT_BIT(8)
1150/** New mouse position data available */
1151#define VMMDEV_EVENT_MOUSE_POSITION_CHANGED RT_BIT(9)
1152
1153/** @} */
1154
1155
1156#if !defined(IN_RC) && !defined(IN_RING0_AGNOSTIC) && !defined(IPRT_NO_CRT)
1157/** @name VBoxGuest IOCTL codes and structures.
1158 *
1159 * The range 0..15 is for basic driver communication.
1160 * The range 16..31 is for HGCM communcation.
1161 * The range 32..47 is reserved for future use.
1162 * The range 48..63 is for OS specific communcation.
1163 * The 7th bit is reserved for future hacks.
1164 * The 8th bit is reserved for distinguishing between 32-bit and 64-bit
1165 * processes in future 64-bit guest additions.
1166 *
1167 * While windows IOCTL function number has to start at 2048 and stop at 4096 there
1168 * never was any need to do this for everyone. A simple ((Function) | 0x800) would
1169 * have sufficed. On Linux we're now intruding upon the type field. Fortunately
1170 * this hasn't caused any trouble because the FILE_DEVICE_UNKNOWN value was set
1171 * to 0x22 (if it were 0x2C it would not have worked soo smoothly). The situation
1172 * would've been the same for *BSD and Darwin since they seems to share common
1173 * _IOC() heritage.
1174 *
1175 * However, on good old OS/2 we only have 8-bit handy for the function number. The
1176 * result from using the old IOCTL function numbers her would've been overlapping
1177 * between the two ranges.
1178 *
1179 * To fix this problem and get rid of all the unnecessary windowsy crap that I
1180 * bet was copied from my SUPDRVIOC.h once upon a time (although the concept of
1181 * prefixing macros with the purpose of avoid clashes with system stuff and
1182 * to indicate exactly how owns them seems to have been lost somewhere along
1183 * the way), I've introduced a VBOXGUEST_IOCTL_CODE for defining generic IN/OUT
1184 * IOCtls on new ports of the additions.
1185 *
1186 * @remarks When creating new IOCtl interfaces keep in mind that not all OSes supports
1187 * reporting back the output size. (This got messed up a little bit in VBoxDrv.)
1188 *
1189 * The request size is also a little bit tricky as it's passed as part of the
1190 * request code on unix. The size field is 14 bits on Linux, 12 bits on *BSD,
1191 * 13 bits Darwin, and 8-bits on Solaris. All the BSDs and Darwin kernels
1192 * will make use of the size field, while Linux and Solaris will not. We're of
1193 * course using the size to validate and/or map/lock the request, so it has
1194 * to be valid.
1195 *
1196 * For Solaris we will have to do something special though, 255 isn't
1197 * sufficent for all we need. A 4KB restriction (BSD) is probably not
1198 * too problematic (yet) as a general one.
1199 *
1200 * More info can be found in SUPDRVIOC.h and related sources.
1201 *
1202 * @remarks If adding interfaces that only has input or only has output, some new macros
1203 * needs to be created so the most efficient IOCtl data buffering method can be
1204 * used.
1205 * @{
1206 */
1207#ifdef RT_ARCH_AMD64
1208# define VBOXGUEST_IOCTL_FLAG 128
1209#elif defined(RT_ARCH_X86)
1210# define VBOXGUEST_IOCTL_FLAG 0
1211#else
1212# error "dunno which arch this is!"
1213#endif
1214
1215/** Ring-3 request wrapper for big requests.
1216 *
1217 * This is necessary because the ioctl number scheme on many Unixy OSes (esp. Solaris)
1218 * only allows a relatively small size to be encoded into the request. So, for big
1219 * request this generic form is used instead. */
1220typedef struct VBGLBIGREQ
1221{
1222 /** Magic value (VBGLBIGREQ_MAGIC). */
1223 uint32_t u32Magic;
1224 /** The size of the data buffer. */
1225 uint32_t cbData;
1226 /** The user address of the data buffer. */
1227 RTR3PTR pvDataR3;
1228} VBGLBIGREQ;
1229/** Pointer to a request wrapper for solaris guests. */
1230typedef VBGLBIGREQ *PVBGLBIGREQ;
1231/** Pointer to a const request wrapper for solaris guests. */
1232typedef const VBGLBIGREQ *PCVBGLBIGREQ;
1233
1234/** The VBGLBIGREQ::u32Magic value (Ryuu Murakami). */
1235#define VBGLBIGREQ_MAGIC 0x19520219
1236
1237
1238#if defined(RT_OS_WINDOWS)
1239/* @todo Remove IOCTL_CODE later! Integrate it in VBOXGUEST_IOCTL_CODE below. */
1240/** @todo r=bird: IOCTL_CODE is supposedly defined in some header included by Windows.h or ntddk.h, which is why it wasn't in the #if 0 earlier. See HostDrivers/Support/SUPDrvIOC.h... */
1241# define IOCTL_CODE(DeviceType, Function, Method, Access, DataSize_ignored) \
1242 ( ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
1243# define VBOXGUEST_IOCTL_CODE(Function, Size) IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2048 + (Function), METHOD_BUFFERED, FILE_WRITE_ACCESS, 0)
1244# define VBOXGUEST_IOCTL_STRIP_SIZE(Code) (Code)
1245
1246#elif defined(RT_OS_OS2)
1247 /* No automatic buffering, size not encoded. */
1248# define VBOXGUEST_IOCTL_CATEGORY 0xc2
1249# define VBOXGUEST_IOCTL_CODE(Function, Size) ((unsigned char)(Function))
1250# define VBOXGUEST_IOCTL_CATEGORY_FAST 0xc3 /**< Also defined in VBoxGuestA-os2.asm. */
1251# define VBOXGUEST_IOCTL_CODE_FAST(Function) ((unsigned char)(Function))
1252# define VBOXGUEST_IOCTL_STRIP_SIZE(Code) (Code)
1253
1254#elif defined(RT_OS_SOLARIS)
1255 /* No automatic buffering, size limited to 255 bytes => use VBGLBIGREQ for everything. */
1256# include <sys/ioccom.h>
1257# define VBOXGUEST_IOCTL_CODE(Function, Size) _IOWRN('V', (Function) | VBOXGUEST_IOCTL_FLAG, sizeof(VBGLBIGREQ))
1258# define VBOXGUEST_IOCTL_CODE_FAST(Function) _IO( 'V', (Function) | VBOXGUEST_IOCTL_FLAG)
1259# define VBOXGUEST_IOCTL_STRIP_SIZE(Code) (Code)
1260
1261#elif defined(RT_OS_LINUX)
1262 /* No automatic buffering, size limited to 16KB. */
1263# include <linux/ioctl.h>
1264# define VBOXGUEST_IOCTL_CODE(Function, Size) _IOC(_IOC_READ|_IOC_WRITE, 'V', (Function) | VBOXGUEST_IOCTL_FLAG, (Size))
1265# define VBOXGUEST_IOCTL_CODE_FAST(Function) _IO( 'V', (Function) | VBOXGUEST_IOCTL_FLAG)
1266# define VBOXGUEST_IOCTL_STRIP_SIZE(Code) VBOXGUEST_IOCTL_CODE(_IOC_NR((Code)), 0)
1267
1268#elif defined(RT_OS_FREEBSD) /** @todo r=bird: Please do it like SUPDRVIOC to keep it as similar as possible. */
1269# include <sys/ioccom.h>
1270
1271# define VBOXGUEST_IOCTL_CODE(Function, Size) _IOWR('V', (Function) | VBOXGUEST_IOCTL_FLAG, VBGLBIGREQ)
1272# define VBOXGUEST_IOCTL_CODE_FAST(Function) _IO( 'V', (Function) | VBOXGUEST_IOCTL_FLAG)
1273# define VBOXGUEST_IOCTL_STRIP_SIZE(Code) IOCBASECMD(Code)
1274
1275#else
1276/* PORTME */
1277#endif
1278
1279/** IOCTL to VBoxGuest to query the VMMDev IO port region start. */
1280#define VBOXGUEST_IOCTL_GETVMMDEVPORT VBOXGUEST_IOCTL_CODE(1, sizeof(VBoxGuestPortInfo))
1281
1282#pragma pack(4)
1283typedef struct _VBoxGuestPortInfo
1284{
1285 uint32_t portAddress;
1286 VMMDevMemory *pVMMDevMemory;
1287} VBoxGuestPortInfo;
1288
1289/** IOCTL to VBoxGuest to wait for a VMMDev host notification */
1290#define VBOXGUEST_IOCTL_WAITEVENT VBOXGUEST_IOCTL_CODE(2, sizeof(VBoxGuestWaitEventInfo))
1291
1292/** IOCTL to VBoxGuest to interrupt (cancel) any pending WAITEVENTs and return.
1293 * Handled inside the guest additions and not seen by the host at all.
1294 * @see VBOXGUEST_IOCTL_WAITEVENT */
1295#define VBOXGUEST_IOCTL_CANCEL_ALL_WAITEVENTS VBOXGUEST_IOCTL_CODE(5, 0)
1296
1297/** @name Result codes for VBoxGuestWaitEventInfo::u32Result
1298 * @{
1299 */
1300/** Successful completion, an event occured. */
1301#define VBOXGUEST_WAITEVENT_OK (0)
1302/** Successful completion, timed out. */
1303#define VBOXGUEST_WAITEVENT_TIMEOUT (1)
1304/** Wait was interrupted. */
1305#define VBOXGUEST_WAITEVENT_INTERRUPTED (2)
1306/** An error occured while processing the request. */
1307#define VBOXGUEST_WAITEVENT_ERROR (3)
1308/** @} */
1309
1310/** Input and output buffers layout of the IOCTL_VBOXGUEST_WAITEVENT */
1311typedef struct _VBoxGuestWaitEventInfo
1312{
1313 /** timeout in milliseconds */
1314 uint32_t u32TimeoutIn;
1315 /** events to wait for */
1316 uint32_t u32EventMaskIn;
1317 /** result code */
1318 uint32_t u32Result;
1319 /** events occured */
1320 uint32_t u32EventFlagsOut;
1321} VBoxGuestWaitEventInfo;
1322
1323/** IOCTL to VBoxGuest to perform a VMM request
1324 * @remark The data buffer for this IOCtl has an variable size, keep this in mind
1325 * on systems where this matters. */
1326#define VBOXGUEST_IOCTL_VMMREQUEST(Size) VBOXGUEST_IOCTL_CODE(3, (Size))
1327
1328/** Input and output buffer layout of the IOCTL_VBOXGUEST_CTL_FILTER_MASK. */
1329typedef struct _VBoxGuestFilterMaskInfo
1330{
1331 uint32_t u32OrMask;
1332 uint32_t u32NotMask;
1333} VBoxGuestFilterMaskInfo;
1334#pragma pack()
1335
1336/** IOCTL to VBoxGuest to control event filter mask. */
1337#define VBOXGUEST_IOCTL_CTL_FILTER_MASK VBOXGUEST_IOCTL_CODE(4, sizeof(VBoxGuestFilterMaskInfo))
1338
1339/** IOCTL to VBoxGuest to check memory ballooning. */
1340#define VBOXGUEST_IOCTL_CTL_CHECK_BALLOON_MASK VBOXGUEST_IOCTL_CODE(7, 100)
1341
1342/** IOCTL to VBoxGuest to perform backdoor logging. */
1343#define VBOXGUEST_IOCTL_LOG(Size) VBOXGUEST_IOCTL_CODE(6, (Size))
1344
1345
1346#ifdef VBOX_WITH_HGCM
1347/* These structures are shared between the driver and other binaries,
1348 * therefore packing must be defined explicitely.
1349 */
1350# pragma pack(1)
1351typedef struct _VBoxGuestHGCMConnectInfo
1352{
1353 uint32_t result; /**< OUT */
1354 HGCMServiceLocation Loc; /**< IN */
1355 uint32_t u32ClientID; /**< OUT */
1356} VBoxGuestHGCMConnectInfo;
1357
1358typedef struct _VBoxGuestHGCMDisconnectInfo
1359{
1360 uint32_t result; /**< OUT */
1361 uint32_t u32ClientID; /**< IN */
1362} VBoxGuestHGCMDisconnectInfo;
1363
1364typedef struct _VBoxGuestHGCMCallInfo
1365{
1366 uint32_t result; /**< OUT Host HGCM return code.*/
1367 uint32_t u32ClientID; /**< IN The id of the caller. */
1368 uint32_t u32Function; /**< IN Function number. */
1369 uint32_t cParms; /**< IN How many parms. */
1370 /* Parameters follow in form HGCMFunctionParameter aParms[cParms] */
1371} VBoxGuestHGCMCallInfo;
1372
1373typedef struct _VBoxGuestHGCMCallInfoTimeout
1374{
1375 uint32_t u32Timeout; /**< IN How long to wait for completion before cancelling the call */
1376 VBoxGuestHGCMCallInfo info; /** The rest of the call information. Placed after the timeout
1377 * so that the parameters follow as they would for a normal call. */
1378 /* Parameters follow in form HGCMFunctionParameter aParms[cParms] */
1379} VBoxGuestHGCMCallInfoTimeout;
1380# pragma pack()
1381
1382# define VBOXGUEST_IOCTL_HGCM_CONNECT VBOXGUEST_IOCTL_CODE(16, sizeof(VBoxGuestHGCMConnectInfo))
1383# define VBOXGUEST_IOCTL_HGCM_DISCONNECT VBOXGUEST_IOCTL_CODE(17, sizeof(VBoxGuestHGCMDisconnectInfo))
1384# define VBOXGUEST_IOCTL_HGCM_CALL(Size) VBOXGUEST_IOCTL_CODE(18, (Size))
1385# define VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT(Size) VBOXGUEST_IOCTL_CODE(20, (Size))
1386# define VBOXGUEST_IOCTL_CLIPBOARD_CONNECT VBOXGUEST_IOCTL_CODE(19, sizeof(uint32_t))
1387
1388# define VBOXGUEST_HGCM_CALL_PARMS(a) ((HGCMFunctionParameter *)((uint8_t *)(a) + sizeof (VBoxGuestHGCMCallInfo)))
1389
1390#endif /* VBOX_WITH_HGCM */
1391
1392/*
1393 * Credentials request flags and structure
1394 */
1395
1396#define VMMDEV_CREDENTIALS_STRLEN 128
1397
1398/** query from host whether credentials are present */
1399#define VMMDEV_CREDENTIALS_QUERYPRESENCE RT_BIT(1)
1400/** read credentials from host (can be combined with clear) */
1401#define VMMDEV_CREDENTIALS_READ RT_BIT(2)
1402/** clear credentials on host (can be combined with read) */
1403#define VMMDEV_CREDENTIALS_CLEAR RT_BIT(3)
1404/** read credentials for judgement in the guest */
1405#define VMMDEV_CREDENTIALS_READJUDGE RT_BIT(8)
1406/** clear credentials for judegement on the host */
1407#define VMMDEV_CREDENTIALS_CLEARJUDGE RT_BIT(9)
1408/** report credentials acceptance by guest */
1409#define VMMDEV_CREDENTIALS_JUDGE_OK RT_BIT(10)
1410/** report credentials denial by guest */
1411#define VMMDEV_CREDENTIALS_JUDGE_DENY RT_BIT(11)
1412/** report that no judgement could be made by guest */
1413#define VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT RT_BIT(12)
1414
1415/** flag telling the guest that credentials are present */
1416#define VMMDEV_CREDENTIALS_PRESENT RT_BIT(16)
1417/** flag telling guest that local logons should be prohibited */
1418#define VMMDEV_CREDENTIALS_NOLOCALLOGON RT_BIT(17)
1419
1420/** credentials request structure */
1421#pragma pack(4)
1422typedef struct _VMMDevCredentials
1423{
1424 /* request header */
1425 VMMDevRequestHeader header;
1426 /* request flags (in/out) */
1427 uint32_t u32Flags;
1428 /* user name (UTF-8) (out) */
1429 char szUserName[VMMDEV_CREDENTIALS_STRLEN];
1430 /* password (UTF-8) (out) */
1431 char szPassword[VMMDEV_CREDENTIALS_STRLEN];
1432 /* domain name (UTF-8) (out) */
1433 char szDomain[VMMDEV_CREDENTIALS_STRLEN];
1434} VMMDevCredentials;
1435#pragma pack()
1436
1437/** inline helper to determine the request size for the given operation */
1438DECLINLINE(size_t) vmmdevGetRequestSize(VMMDevRequestType requestType)
1439{
1440 switch (requestType)
1441 {
1442 case VMMDevReq_GetMouseStatus:
1443 case VMMDevReq_SetMouseStatus:
1444 return sizeof(VMMDevReqMouseStatus);
1445 case VMMDevReq_SetPointerShape:
1446 return sizeof(VMMDevReqMousePointer);
1447 case VMMDevReq_GetHostVersion:
1448 return sizeof(VMMDevReqHostVersion);
1449 case VMMDevReq_Idle:
1450 return sizeof(VMMDevReqIdle);
1451 case VMMDevReq_GetHostTime:
1452 return sizeof(VMMDevReqHostTime);
1453 case VMMDevReq_GetHypervisorInfo:
1454 case VMMDevReq_SetHypervisorInfo:
1455 return sizeof(VMMDevReqHypervisorInfo);
1456 case VMMDevReq_SetPowerStatus:
1457 return sizeof(VMMDevPowerStateRequest);
1458 case VMMDevReq_AcknowledgeEvents:
1459 return sizeof(VMMDevEvents);
1460 case VMMDevReq_ReportGuestInfo:
1461 return sizeof(VMMDevReportGuestInfo);
1462 case VMMDevReq_GetDisplayChangeRequest:
1463 return sizeof(VMMDevDisplayChangeRequest);
1464 case VMMDevReq_GetDisplayChangeRequest2:
1465 return sizeof(VMMDevDisplayChangeRequest2);
1466 case VMMDevReq_VideoModeSupported:
1467 return sizeof(VMMDevVideoModeSupportedRequest);
1468 case VMMDevReq_GetHeightReduction:
1469 return sizeof(VMMDevGetHeightReductionRequest);
1470 case VMMDevReq_ReportGuestCapabilities:
1471 return sizeof(VMMDevReqGuestCapabilities);
1472 case VMMDevReq_SetGuestCapabilities:
1473 return sizeof(VMMDevReqGuestCapabilities2);
1474#ifdef VBOX_WITH_HGCM
1475 case VMMDevReq_HGCMConnect:
1476 return sizeof(VMMDevHGCMConnect);
1477 case VMMDevReq_HGCMDisconnect:
1478 return sizeof(VMMDevHGCMDisconnect);
1479#ifdef VBOX_WITH_64_BITS_GUESTS
1480 case VMMDevReq_HGCMCall32:
1481 return sizeof(VMMDevHGCMCall);
1482 case VMMDevReq_HGCMCall64:
1483 return sizeof(VMMDevHGCMCall);
1484#else
1485 case VMMDevReq_HGCMCall:
1486 return sizeof(VMMDevHGCMCall);
1487#endif /* VBOX_WITH_64_BITS_GUESTS */
1488 case VMMDevReq_HGCMCancel:
1489 return sizeof(VMMDevHGCMCancel);
1490#endif /* VBOX_WITH_HGCM */
1491 case VMMDevReq_VideoAccelEnable:
1492 return sizeof(VMMDevVideoAccelEnable);
1493 case VMMDevReq_VideoAccelFlush:
1494 return sizeof(VMMDevVideoAccelFlush);
1495 case VMMDevReq_VideoSetVisibleRegion:
1496 return sizeof(VMMDevVideoSetVisibleRegion);
1497 case VMMDevReq_GetSeamlessChangeRequest:
1498 return sizeof(VMMDevSeamlessChangeRequest);
1499 case VMMDevReq_QueryCredentials:
1500 return sizeof(VMMDevCredentials);
1501 case VMMDevReq_ReportGuestStats:
1502 return sizeof(VMMDevReportGuestStats);
1503 case VMMDevReq_GetMemBalloonChangeRequest:
1504 return sizeof(VMMDevGetMemBalloonChangeRequest);
1505 case VMMDevReq_GetStatisticsChangeRequest:
1506 return sizeof(VMMDevGetStatisticsChangeRequest);
1507 case VMMDevReq_ChangeMemBalloon:
1508 return sizeof(VMMDevChangeMemBalloon);
1509 case VMMDevReq_GetVRDPChangeRequest:
1510 return sizeof(VMMDevVRDPChangeRequest);
1511 case VMMDevReq_LogString:
1512 return sizeof(VMMDevReqLogString);
1513 default:
1514 return 0;
1515 }
1516}
1517
1518/**
1519 * Initializes a request structure.
1520 *
1521 */
1522DECLINLINE(int) vmmdevInitRequest(VMMDevRequestHeader *req, VMMDevRequestType type)
1523{
1524 uint32_t requestSize;
1525 if (!req)
1526 return VERR_INVALID_PARAMETER;
1527 requestSize = (uint32_t)vmmdevGetRequestSize(type);
1528 if (!requestSize)
1529 return VERR_INVALID_PARAMETER;
1530 req->size = requestSize;
1531 req->version = VMMDEV_REQUEST_HEADER_VERSION;
1532 req->requestType = type;
1533 req->rc = VERR_GENERAL_FAILURE;
1534 req->reserved1 = 0;
1535 req->reserved2 = 0;
1536 return VINF_SUCCESS;
1537}
1538
1539
1540#ifdef RT_OS_OS2
1541
1542/**
1543 * The data buffer layout for the IDC entry point (AttachDD).
1544 *
1545 * @remark This is defined in multiple 16-bit headers / sources.
1546 * Some places it's called VBGOS2IDC to short things a bit.
1547 */
1548typedef struct VBOXGUESTOS2IDCCONNECT
1549{
1550 /** VMMDEV_VERSION. */
1551 uint32_t u32Version;
1552 /** Opaque session handle. */
1553 uint32_t u32Session;
1554
1555 /**
1556 * The 32-bit service entry point.
1557 *
1558 * @returns VBox status code.
1559 * @param u32Session The above session handle.
1560 * @param iFunction The requested function.
1561 * @param pvData The input/output data buffer. The caller ensures that this
1562 * cannot be swapped out, or that it's acceptable to take a
1563 * page in fault in the current context. If the request doesn't
1564 * take input or produces output, apssing NULL is okay.
1565 * @param cbData The size of the data buffer.
1566 * @param pcbDataReturned Where to store the amount of data that's returned.
1567 * This can be NULL if pvData is NULL.
1568 */
1569 DECLCALLBACKMEMBER(int, pfnServiceEP)(uint32_t u32Session, unsigned iFunction, void *pvData, size_t cbData, size_t *pcbDataReturned);
1570
1571 /** The 16-bit service entry point for C code (cdecl).
1572 *
1573 * It's the same as the 32-bit entry point, but the types has
1574 * changed to 16-bit equivalents.
1575 *
1576 * @code
1577 * int far cdecl
1578 * VBoxGuestOs2IDCService16(uint32_t u32Session, uint16_t iFunction,
1579 * void far *fpvData, uint16_t cbData, uint16_t far *pcbDataReturned);
1580 * @endcode
1581 */
1582 RTFAR16 fpfnServiceEP;
1583
1584 /** The 16-bit service entry point for Assembly code (register).
1585 *
1586 * This is just a wrapper around fpfnServiceEP to simplify calls
1587 * from 16-bit assembly code.
1588 *
1589 * @returns (e)ax: VBox status code; cx: The amount of data returned.
1590 *
1591 * @param u32Session eax - The above session handle.
1592 * @param iFunction dl - The requested function.
1593 * @param pvData es:bx - The input/output data buffer.
1594 * @param cbData cx - The size of the data buffer.
1595 */
1596 RTFAR16 fpfnServiceAsmEP;
1597} VBOXGUESTOS2IDCCONNECT;
1598/** Pointer to VBOXGUESTOS2IDCCONNECT buffer. */
1599typedef VBOXGUESTOS2IDCCONNECT *PVBOXGUESTOS2IDCCONNECT;
1600
1601/** OS/2 specific: IDC client disconnect request.
1602 *
1603 * This takes no input and it doesn't return anything. Obviously this
1604 * is only recognized if it arrives thru the IDC service EP.
1605 */
1606#define VBOXGUEST_IOCTL_OS2_IDC_DISCONNECT VBOXGUEST_IOCTL_CODE(48, sizeof(uint32_t))
1607
1608#endif /* RT_OS_OS2 */
1609
1610/** @} */
1611#endif /* !defined(IN_RC) && !defined(IN_RING0_AGNOSTIC) && !defined(IPRT_NO_CRT) */
1612
1613
1614#ifdef IN_RING3
1615
1616/** @def VBGLR3DECL
1617 * Ring 3 VBGL declaration.
1618 * @param type The return type of the function declaration.
1619 */
1620#define VBGLR3DECL(type) type VBOXCALL
1621
1622/* General-purpose functions */
1623
1624__BEGIN_DECLS
1625VBGLR3DECL(int) VbglR3Init(void);
1626VBGLR3DECL(void) VbglR3Term(void);
1627# ifdef ___iprt_time_h
1628VBGLR3DECL(int) VbglR3GetHostTime(PRTTIMESPEC pTime);
1629# endif
1630VBGLR3DECL(int) VbglR3InterruptEventWaits(void);
1631VBGLR3DECL(int) VbglR3WriteLog(const char *pch, size_t cb);
1632VBGLR3DECL(int) VbglR3CtlFilterMask(uint32_t fOr, uint32_t fNot);
1633VBGLR3DECL(int) VbglR3Daemonize(bool fNoChDir, bool fNoClose, char const *pszPidfile);
1634VBGLR3DECL(int) VbglR3SetGuestCaps(uint32_t fOr, uint32_t fNot);
1635
1636/** @name Shared clipboard
1637 * @{ */
1638VBGLR3DECL(int) VbglR3ClipboardConnect(uint32_t *pu32ClientId);
1639VBGLR3DECL(int) VbglR3ClipboardDisconnect(uint32_t u32ClientId);
1640VBGLR3DECL(int) VbglR3ClipboardGetHostMsg(uint32_t u32ClientId, uint32_t *pMsg, uint32_t *pfFormats);
1641VBGLR3DECL(int) VbglR3ClipboardReadData(uint32_t u32ClientId, uint32_t fFormat, void *pv, uint32_t cb, uint32_t *pcb);
1642VBGLR3DECL(int) VbglR3ClipboardReportFormats(uint32_t u32ClientId, uint32_t fFormats);
1643VBGLR3DECL(int) VbglR3ClipboardWriteData(uint32_t u32ClientId, uint32_t fFormat, void *pv, uint32_t cb);
1644/** @} */
1645
1646/** @name Seamless mode
1647 * @{ */
1648VBGLR3DECL(int) VbglR3SeamlessSetCap(bool fState);
1649VBGLR3DECL(int) VbglR3SeamlessWaitEvent(VMMDevSeamlessMode *pMode);
1650VBGLR3DECL(int) VbglR3SeamlessSendRects(uint32_t cRects, PRTRECT pRects);
1651/** @} */
1652
1653/** @name Mouse
1654 * @{ */
1655VBGLR3DECL(int) VbglR3GetMouseStatus(uint32_t *pfFeatures, uint32_t *px, uint32_t *py);
1656VBGLR3DECL(int) VbglR3SetMouseStatus(uint32_t fFeatures);
1657/** @} */
1658
1659/** @name Video
1660 * @{ */
1661VBGLR3DECL(int) VbglR3VideoAccelEnable(bool fEnable);
1662VBGLR3DECL(int) VbglR3VideoAccelFlush(void);
1663VBGLR3DECL(int) VbglR3SetPointerShape(uint32_t fFlags, uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy, const void *pvImg, size_t cbImg);
1664VBGLR3DECL(int) VbglR3SetPointerShapeReq(VMMDevReqMousePointer *pReq);
1665/** @} */
1666
1667/** @name Display
1668 * @{ */
1669VBGLR3DECL(int) VbglR3GetLastDisplayChangeRequest(uint32_t *pcx, uint32_t *pcy, uint32_t *pcBits, uint32_t *piDisplay);
1670VBGLR3DECL(int) VbglR3DisplayChangeWaitEvent(uint32_t *pcx, uint32_t *pcy, uint32_t *pcBits, uint32_t *piDisplay);
1671VBGLR3DECL(bool) VbglR3HostLikesVideoMode(uint32_t cx, uint32_t cy, uint32_t cBits);
1672VBGLR3DECL(int) VbglR3SaveVideoMode(const char *pszName, uint32_t cx, uint32_t cy, uint32_t cBits);
1673VBGLR3DECL(int) VbglR3RetrieveVideoMode(const char *pszName, uint32_t *pcx, uint32_t *pcy, uint32_t *pcBits);
1674/** @} */
1675
1676#ifdef VBOX_WITH_GUEST_PROPS
1677/** @name Guest properties
1678 * @{ */
1679typedef struct VBGLR3GUESTPROPENUM VBGLR3GUESTPROPENUM, *PVBGLR3GUESTPROPENUM;
1680VBGLR3DECL(int) VbglR3GuestPropConnect(uint32_t *pu32ClientId);
1681VBGLR3DECL(int) VbglR3GuestPropDisconnect(uint32_t u32ClientId);
1682VBGLR3DECL(int) VbglR3GuestPropWrite(uint32_t u32ClientId, const char *pszName, const char *pszValue, const char *pszFlags);
1683VBGLR3DECL(int) VbglR3GuestPropWriteValue(uint32_t u32ClientId, const char *pszName, const char *pszValue);
1684VBGLR3DECL(int) VbglR3GuestPropWriteValueV(uint32_t u32ClientId, const char *pszName, const char *pszValueFormat, va_list va);
1685VBGLR3DECL(int) VbglR3GuestPropWriteValueF(uint32_t u32ClientId, const char *pszName, const char *pszValueFormat, ...);
1686VBGLR3DECL(int) VbglR3GuestPropRead(uint32_t u32ClientId, const char *pszName, void *pvBuf, uint32_t cbBuf, char **ppszValue, uint64_t *pu64Timestamp, char **ppszFlags, uint32_t *pcbBufActual);
1687VBGLR3DECL(int) VbglR3GuestPropReadValue(uint32_t ClientId, const char *pszName, char *pszValue, uint32_t cchValue, uint32_t *pcchValueActual);
1688VBGLR3DECL(int) VbglR3GuestPropReadValueAlloc(uint32_t u32ClientId, const char *pszName, char **ppszValue);
1689VBGLR3DECL(void) VbglR3GuestPropReadValueFree(char *pszValue);
1690VBGLR3DECL(int) VbglR3GuestPropEnumRaw(uint32_t u32ClientId, const char *paszPatterns, char *pcBuf, uint32_t cbBuf, uint32_t *pcbBufActual);
1691VBGLR3DECL(int) VbglR3GuestPropEnum(uint32_t u32ClientId, char const * const *ppaszPatterns, uint32_t cPatterns, PVBGLR3GUESTPROPENUM *ppHandle,
1692 char const **ppszName, char const **ppszValue, uint64_t *pu64Timestamp, char const **ppszFlags);
1693VBGLR3DECL(int) VbglR3GuestPropEnumNext(PVBGLR3GUESTPROPENUM pHandle, char const **ppszName, char const **ppszValue, uint64_t *pu64Timestamp,
1694 char const **ppszFlags);
1695VBGLR3DECL(void) VbglR3GuestPropEnumFree(PVBGLR3GUESTPROPENUM pHandle);
1696VBGLR3DECL(int) VbglR3GuestPropDelSet(uint32_t u32ClientId, char const * const *papszPatterns, uint32_t cPatterns);
1697VBGLR3DECL(int) VbglR3GuestPropWait(uint32_t u32ClientId, const char *pszPatterns, void *pvBuf, uint32_t cbBuf, uint64_t u64Timestamp, uint32_t u32Timeout, char ** ppszName, char **ppszValue, uint64_t *pu64Timestamp, char **ppszFlags, uint32_t *pcbBufActual);
1698/** @} */
1699#endif /* VBOX_WITH_GUEST_PROPS defined */
1700
1701
1702__END_DECLS
1703
1704#endif /* IN_RING3 */
1705
1706#endif
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