]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - ubuntu/vbox/vboxguest/include/VBox/VBoxGuest.h
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
UBUNTU: ubuntu: vbox -- update to 5.2.0-dfsg-2
[mirror_ubuntu-bionic-kernel.git] / ubuntu / vbox / vboxguest / include / VBox / VBoxGuest.h
CommitLineData
6d209b23
SF		 1/** @file
2 * VBoxGuest - VirtualBox Guest Additions Driver Interface. (ADD,DEV)
3 *
4 * @note This file is used by 16-bit compilers too (OpenWatcom).
5 */
6
7/*
8 * Copyright (C) 2006-2017 Oracle Corporation
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 *
18 * The contents of this file may alternatively be used under the terms
19 * of the Common Development and Distribution License Version 1.0
20 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
21 * VirtualBox OSE distribution, in which case the provisions of the
22 * CDDL are applicable instead of those of the GPL.
23 *
24 * You may elect to license modified versions of this file under the
25 * terms and conditions of either the GPL or the CDDL or both.
26 */
27
28#ifndef ___VBox_VBoxGuest_h
29#define ___VBox_VBoxGuest_h
30
31#include <VBox/types.h>
32#include <iprt/assertcompile.h>
33#include <VBox/VMMDevCoreTypes.h>
34#include <VBox/VBoxGuestCoreTypes.h>
35
36
37
38/** @defgroup grp_vboxguest VirtualBox Guest Additions Device Driver
39 *
40 * Also know as VBoxGuest.
41 *
42 * @{
43 */
44
45/** @defgroup grp_vboxguest_ioc VirtualBox Guest Additions Driver Interface
46 *
47 * @note This is considered internal in ring-3, please use the VbglR3 functions.
48 *
49 * - I/O controls for user and/or kernel mode starts at 0.
50 * - IDC specific requests descends from 127.
51 * - Bits 7 and 6 are currently reserved for future hacks.
52 *
53 * @remarks When creating new IOCtl interfaces keep in mind that not all OSes supports
54 * reporting back the output size. (This got messed up a little bit in VBoxDrv.)
55 *
56 * The request size is also a little bit tricky as it's passed as part of the
57 * request code on unix. The size field is 14 bits on Linux, 12 bits on *BSD,
58 * 13 bits Darwin, and 8-bits on Solaris. All the BSDs and Darwin kernels
59 * will make use of the size field, while Linux and Solaris will not. We're of
60 * course using the size to validate and/or map/lock the request, so it has
61 * to be valid.
62 *
63 * For Solaris we will have to do something special though, 255 isn't
64 * sufficient for all we need. A 4KB restriction (BSD) is probably not
65 * too problematic (yet) as a general one.
66 *
67 * More info can be found in SUPDRVIOC.h and related sources.
68 *
69 * @remarks If adding interfaces that only has input or only has output, some new macros
70 * needs to be created so the most efficient IOCtl data buffering method can be
71 * used.
72 *
73 * @{
74 */
75#if !defined(IN_RC) && !defined(IN_RING0_AGNOSTIC) && !defined(IPRT_NO_CRT)
76
77/** Fictive start address of the hypervisor physical memory for MmMapIoSpace. */
78#define VBOXGUEST_HYPERVISOR_PHYSICAL_START UINT32_C(0xf8000000)
79
80#ifdef RT_OS_DARWIN
81/** Cookie used to fend off some unwanted clients to the IOService. */
82# define VBOXGUEST_DARWIN_IOSERVICE_COOKIE UINT32_C(0x56426f78) /* 'VBox' */
83#endif
84
85
86#if defined(RT_OS_WINDOWS)
87# ifndef CTL_CODE
88# include <iprt/win/windows.h>
89# endif
90 /* Automatic buffering, size not encoded. */
91# define VBGL_IOCTL_CODE_SIZE(Function, Size) CTL_CODE(FILE_DEVICE_UNKNOWN, 2048 + (Function), METHOD_BUFFERED, FILE_WRITE_ACCESS)
92# define VBGL_IOCTL_CODE_BIG(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, 2048 + (Function), METHOD_BUFFERED, FILE_WRITE_ACCESS)
93# define VBGL_IOCTL_CODE_FAST(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, 2048 + (Function), METHOD_NEITHER, FILE_WRITE_ACCESS)
94# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl) (a_uIOCtl)
95# define VBOXGUEST_DEVICE_NAME "\\\\.\\VBoxGuest"
96/** The support service name. */
97# define VBOXGUEST_SERVICE_NAME "VBoxGuest"
98/** Global name for Win2k+ */
99# define VBOXGUEST_DEVICE_NAME_GLOBAL "\\\\.\\Global\\VBoxGuest"
100/** Win32 driver name */
101# define VBOXGUEST_DEVICE_NAME_NT L"\\Device\\VBoxGuest"
102/** Device name. */
103# define VBOXGUEST_DEVICE_NAME_DOS L"\\DosDevices\\VBoxGuest"
104
105#elif defined(RT_OS_OS2)
106 /* No automatic buffering, size not encoded. */
107# define VBGL_IOCTL_CATEGORY 0xc2
108# define VBGL_IOCTL_CODE_SIZE(Function, Size) ((unsigned char)(Function))
109# define VBGL_IOCTL_CODE_BIG(Function) ((unsigned char)(Function))
110# define VBGL_IOCTL_CATEGORY_FAST 0xc3 /**< Also defined in VBoxGuestA-os2.asm. */
111# define VBGL_IOCTL_CODE_FAST(Function) ((unsigned char)(Function))
112# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl) (a_uIOCtl)
113# define VBOXGUEST_DEVICE_NAME "\\Dev\\VBoxGst$"
114/** Short device name for AttachDD.
115 * @note Case sensitive. Must match what VBoxGuestA-os2.asm says! */
116# define VBOXGUEST_DEVICE_NAME_SHORT "vboxgst$"
117
118#elif defined(RT_OS_SOLARIS)
119 /* No automatic buffering, size limited to 255 bytes => use VBGLBIGREQ for everything. */
120# include <sys/ioccom.h>
121# define VBGL_IOCTL_CODE_SIZE(Function, Size) _IOWRN('V', (Function), sizeof(VBGLREQHDR))
122# define VBGL_IOCTL_CODE_BIG(Function) _IOWRN('V', (Function), sizeof(VBGLREQHDR))
123# define VBGL_IOCTL_CODE_FAST(Function) _IO( 'F', (Function))
124# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl) (a_uIOCtl)
125# define VBGL_IOCTL_IS_FAST(a_uIOCtl) ( ((a_uIOCtl) & 0x0000ff00) == ('F' << 8) )
126
127#elif defined(RT_OS_LINUX)
128 /* No automatic buffering, size limited to 16KB. */
129# include <linux/ioctl.h>
130# define VBGL_IOCTL_CODE_SIZE(Function, Size) _IOC(_IOC_READ | _IOC_WRITE, 'V', (Function), (Size))
131# define VBGL_IOCTL_CODE_BIG(Function) _IO('V', (Function))
132# define VBGL_IOCTL_CODE_FAST(Function) _IO('F', (Function))
133# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl) _IOC_NR((a_uIOCtl))
134# define VBOXGUEST_USER_DEVICE_NAME "/dev/vboxuser"
135
136#elif defined(RT_OS_HAIKU)
137 /* No automatic buffering, size not encoded. */
138 /** @todo do something better */
139# define VBGL_IOCTL_CODE_SIZE(Function, Size) (0x56420000 | (Function))
140# define VBGL_IOCTL_CODE_BIG(Function) (0x56420000 | (Function))
141# define VBGL_IOCTL_CODE_FAST(Function) (0x56420000 | (Function))
142# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl) (a_uIOCtl)
143# define VBOXGUEST_DEVICE_NAME "/dev/misc/vboxguest"
144
145#else /* BSD Like */
146 /* Automatic buffering, size limited to 4KB on *BSD and 8KB on Darwin - commands the limit, 4KB. */
147# include <sys/ioccom.h>
148# define VBGL_IOCTL_CODE_SIZE(Function, Size) _IOC(IOC_INOUT, 'V', (Function), (Size))
149# define VBGL_IOCTL_CODE_BIG(Function) _IO('V', (Function))
150# define VBGL_IOCTL_CODE_FAST(Function) _IO('F', (Function))
151# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl) ((a_uIOCtl) & ~(_IOC(0,0,0,IOCPARM_MASK)))
152# define VBGL_IOCTL_IS_FAST(a_uIOCtl) ( IOCGROUP(a_uIOCtl) == 'F' )
153#endif
154
155
156/** @todo It would be nice if we could have two defines without paths. */
157
158/** @def VBOXGUEST_DEVICE_NAME
159 * The support device name. */
160#ifndef VBOXGUEST_DEVICE_NAME /* PORTME */
161# define VBOXGUEST_DEVICE_NAME "/dev/vboxguest"
162#endif
163
164/** @def VBOXGUEST_USER_DEVICE_NAME
165 * The support device name of the user accessible device node. */
166#ifndef VBOXGUEST_USER_DEVICE_NAME
167# define VBOXGUEST_USER_DEVICE_NAME VBOXGUEST_DEVICE_NAME
168#endif
169
170
171/**
172 * The VBoxGuest I/O control version.
173 *
174 * As usual, the high word contains the major version and changes to it
175 * signifies incompatible changes.
176 *
177 * The lower word is the minor version number, it is increased when new
178 * functions are added or existing changed in a backwards compatible manner.
179 */
180#define VBGL_IOC_VERSION UINT32_C(0x00010000)
181
182
183
184/** @name VBGL_IOCTL_DRIVER_INFO
185 * Adjust and get driver information.
186 *
187 * @note May switch the session to a backwards compatible interface version if
188 * uClientVersion indicates older client code.
189 *
190 * @{
191 */
192#define VBGL_IOCTL_DRIVER_VERSION_INFO VBGL_IOCTL_CODE_SIZE(0, VBGL_IOCTL_DRIVER_VERSION_INFO_SIZE)
193#define VBGL_IOCTL_DRIVER_VERSION_INFO_SIZE sizeof(VBGLIOCDRIVERVERSIONINFO)
194#define VBGL_IOCTL_DRIVER_VERSION_INFO_SIZE_IN RT_UOFFSET_AFTER(VBGLIOCDRIVERVERSIONINFO, u.In)
195#define VBGL_IOCTL_DRIVER_VERSION_INFO_SIZE_OUT sizeof(VBGLIOCDRIVERVERSIONINFO)
196typedef struct VBGLIOCDRIVERVERSIONINFO
197{
198 /** The header. */
199 VBGLREQHDR Hdr;
200 union
201 {
202 struct
203 {
204 /** The requested interface version number (VBGL_IOC_VERSION). */
205 uint32_t uReqVersion;
206 /** The minimum interface version number
207 * (typically the major version part of VBGL_IOC_VERSION). */
208 uint32_t uMinVersion;
209 /** Reserved, MBZ. */
210 uint32_t uReserved1;
211 /** Reserved, MBZ. */
212 uint32_t uReserved2;
213 } In;
214 struct
215 {
216 /** Interface version for this session (typically VBGL_IOC_VERSION). */
217 uint32_t uSessionVersion;
218 /** The version of the IDC interface (VBGL_IOC_VERSION). */
219 uint32_t uDriverVersion;
220 /** The SVN revision of the driver.
221 * This will be set to 0 if not compiled into the driver. */
222 uint32_t uDriverRevision;
223 /** Reserved \#1 (will be returned as zero until defined). */
224 uint32_t uReserved1;
225 /** Reserved \#2 (will be returned as zero until defined). */
226 uint32_t uReserved2;
227 } Out;
228 } u;
229} VBGLIOCDRIVERVERSIONINFO, RT_FAR *PVBGLIOCDRIVERVERSIONINFO;
230AssertCompileSize(VBGLIOCDRIVERVERSIONINFO, 24 + 20);
231#if !defined(__GNUC__) /* Some GCC versions can't handle the complicated RT_UOFFSET_AFTER macro, it seems. */ \
232 && (!defined(RT_OS_OS2) || (!defined(__IBMC__) && !defined(__IBMCPP__) && (!defined(__WATCOMC__) || !defined(__cplusplus))))
233AssertCompile(VBGL_IOCTL_DRIVER_VERSION_INFO_SIZE_IN == 24 + 16);
234#endif
235/** @} */
236
237
238/** @name VBGL_IOCTL_GET_PORT_INFO
239 * Query VMMDev I/O port region and MMIO mapping address.
240 * @remarks Ring-0 only.
241 * @{
242 */
243#define VBGL_IOCTL_GET_VMMDEV_IO_INFO VBGL_IOCTL_CODE_SIZE(1, VBGL_IOCTL_GET_VMMDEV_IO_INFO_SIZE)
244#define VBGL_IOCTL_GET_VMMDEV_IO_INFO_SIZE sizeof(VBGLIOCGETVMMDEVIOINFO)
245#define VBGL_IOCTL_GET_VMMDEV_IO_INFO_SIZE_IN sizeof(VBGLREQHDR)
246#define VBGL_IOCTL_GET_VMMDEV_IO_INFO_SIZE_OUT sizeof(VBGLIOCGETVMMDEVIOINFO)
247typedef struct VBGLIOCGETVMMDEVIOINFO
248{
249 /** The header. */
250 VBGLREQHDR Hdr;
251 union
252 {
253 struct
254 {
255 /** The MMIO mapping. NULL if no MMIO region. */
256 struct VMMDevMemory volatile RT_FAR *pvVmmDevMapping;
257 /** The I/O port address. */
258 RTIOPORT IoPort;
259 /** Padding, ignore. */
260 RTIOPORT auPadding[HC_ARCH_BITS == 64 ? 3 : 1];
261 } Out;
262 } u;
263} VBGLIOCGETVMMDEVIOINFO, RT_FAR *PVBGLIOCGETVMMDEVIOINFO;
264AssertCompileSize(VBGLIOCGETVMMDEVIOINFO, 24 + (HC_ARCH_BITS == 64 ? 16 : 8));
265/** @} */
266
267
268/** @name VBGL_IOCTL_VMMDEV_REQUEST
269 * IOCTL to VBoxGuest to perform a VMM Device request less than 1KB in size.
270 * @{
271 */
272#define VBGL_IOCTL_VMMDEV_REQUEST(a_cb) VBGL_IOCTL_CODE_SIZE(2, (a_cb))
273/** @} */
274
275
276/** @name VBGL_IOCTL_VMMDEV_REQUEST_BIG
277 * IOCTL to VBoxGuest to perform a VMM Device request that can 1KB or larger.
278 * @{
279 */
280#define VBGL_IOCTL_VMMDEV_REQUEST_BIG VBGL_IOCTL_CODE_BIG(3)
281/** @} */
282
283
284#ifdef VBOX_WITH_HGCM
285/** @name VBGL_IOCTL_HGCM_CONNECT
286 * Connect to a HGCM service.
287 * @{ */
288# define VBGL_IOCTL_HGCM_CONNECT VBGL_IOCTL_CODE_SIZE(4, VBGL_IOCTL_HGCM_CONNECT_SIZE)
289# define VBGL_IOCTL_HGCM_CONNECT_SIZE sizeof(VBGLIOCHGCMCONNECT)
290# define VBGL_IOCTL_HGCM_CONNECT_SIZE_IN sizeof(VBGLIOCHGCMCONNECT)
291# define VBGL_IOCTL_HGCM_CONNECT_SIZE_OUT RT_UOFFSET_AFTER(VBGLIOCHGCMCONNECT, u.Out)
292typedef struct VBGLIOCHGCMCONNECT
293{
294 /** The header. */
295 VBGLREQHDR Hdr;
296 union
297 {
298 struct
299 {
300 HGCMServiceLocation Loc;
301 } In;
302 struct
303 {
304 uint32_t idClient;
305 } Out;
306 } u;
307} VBGLIOCHGCMCONNECT, RT_FAR *PVBGLIOCHGCMCONNECT;
308AssertCompileSize(VBGLIOCHGCMCONNECT, 24 + 132);
309#if !defined(__GNUC__) /* Some GCC versions can't handle the complicated RT_UOFFSET_AFTER macro, it seems. */ \
310 && (!defined(RT_OS_OS2) || (!defined(__IBMC__) && !defined(__IBMCPP__) && (!defined(__WATCOMC__) || !defined(__cplusplus))))
311AssertCompile(VBGL_IOCTL_HGCM_CONNECT_SIZE_OUT == 24 + 4);
312#endif
313/** @} */
314
315
316/** @name VBGL_IOCTL_HGCM_DISCONNECT
317 * Disconnect from a HGCM service.
318 * @{ */
319# define VBGL_IOCTL_HGCM_DISCONNECT VBGL_IOCTL_CODE_SIZE(5, VBGL_IOCTL_HGCM_DISCONNECT_SIZE)
320# define VBGL_IOCTL_HGCM_DISCONNECT_SIZE sizeof(VBGLIOCHGCMDISCONNECT)
321# define VBGL_IOCTL_HGCM_DISCONNECT_SIZE_IN sizeof(VBGLIOCHGCMDISCONNECT)
322# define VBGL_IOCTL_HGCM_DISCONNECT_SIZE_OUT sizeof(VBGLREQHDR)
323/** @note This is also used by a VbglR0 API. */
324typedef struct VBGLIOCHGCMDISCONNECT
325{
326 /** The header. */
327 VBGLREQHDR Hdr;
328 union
329 {
330 struct
331 {
332 uint32_t idClient;
333 } In;
334 } u;
335} VBGLIOCHGCMDISCONNECT, RT_FAR *PVBGLIOCHGCMDISCONNECT;
336AssertCompileSize(VBGLIOCHGCMDISCONNECT, 24 + 4);
337/** @} */
338
339
340/** @name VBGL_IOCTL_HGCM_CALL, VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA
341 *
342 * Make a call to a HGCM servicesure. There are several variations here.
343 *
344 * The VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA variation is for other drivers (like
345 * the graphics ones) passing on requests from user land that contains user
346 * data. These calls are always interruptible.
347 *
348 * @{ */
349# define VBGL_IOCTL_HGCM_CALL_32(a_cb) VBGL_IOCTL_CODE_SIZE(6, (a_cb))
350# define VBGL_IOCTL_HGCM_CALL_64(a_cb) VBGL_IOCTL_CODE_SIZE(7, (a_cb))
351# if ARCH_BITS == 64
352# define VBGL_IOCTL_HGCM_CALL(a_cb) VBGL_IOCTL_HGCM_CALL_64(a_cb)
353# else
354# define VBGL_IOCTL_HGCM_CALL(a_cb) VBGL_IOCTL_HGCM_CALL_32(a_cb)
355# endif
356# define VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA(a_cb) VBGL_IOCTL_CODE_SIZE(8, (a_cb))
357/** @} */
358#endif /* VBOX_WITH_HGCM */
359
360
361/** @name VBGL_IOCTL_LOG
362 * IOCTL to VBoxGuest to perform backdoor logging.
363 * @{ */
364#define VBOXGUEST_IOCTL_LOG(Size)
365#define VBGL_IOCTL_LOG(a_cchMsg) VBGL_IOCTL_CODE_BIG(9)
366#define VBGL_IOCTL_LOG_SIZE(a_cchMsg) (sizeof(VBGLREQHDR) + (a_cchMsg) + 1)
367#define VBGL_IOCTL_LOG_SIZE_IN(a_cchMsg) (sizeof(VBGLREQHDR) + (a_cchMsg) + 1)
368#define VBGL_IOCTL_LOG_SIZE_OUT sizeof(VBGLREQHDR)
369typedef struct VBGLIOCLOG
370{
371 /** The header. */
372 VBGLREQHDR Hdr;
373 union
374 {
375 struct
376 {
377 /** The log message.
378 * The length is determined from the input size and zero termination. */
379 char szMsg[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
380 } In;
381 } u;
382} VBGLIOCLOG, RT_FAR *PVBGLIOCLOG;
383/** @} */
384
385
386/** @name VBGL_IOCTL_WAIT_FOR_EVENTS
387 * Wait for a VMMDev host event notification.
388 * @{
389 */
390#define VBGL_IOCTL_WAIT_FOR_EVENTS VBGL_IOCTL_CODE_SIZE(10, VBGL_IOCTL_WAIT_FOR_EVENTS_SIZE)
391#define VBGL_IOCTL_WAIT_FOR_EVENTS_SIZE sizeof(VBGLIOCWAITFOREVENTS)
392#define VBGL_IOCTL_WAIT_FOR_EVENTS_SIZE_IN sizeof(VBGLIOCWAITFOREVENTS)
393#define VBGL_IOCTL_WAIT_FOR_EVENTS_SIZE_OUT RT_UOFFSET_AFTER(VBGLIOCWAITFOREVENTS, u.Out)
394typedef struct VBGLIOCWAITFOREVENTS
395{
396 /** The header. */
397 VBGLREQHDR Hdr;
398 union
399 {
400 struct
401 {
402 /** Timeout in milliseconds. */
403 uint32_t cMsTimeOut;
404 /** Events to wait for. */
405 uint32_t fEvents;
406 } In;
407 struct
408 {
409 /** Events that occurred. */
410 uint32_t fEvents;
411 } Out;
412 } u;
413} VBGLIOCWAITFOREVENTS, RT_FAR *PVBGLIOCWAITFOREVENTS;
414AssertCompileSize(VBGLIOCWAITFOREVENTS, 24 + 8);
415/** @} */
416
417
418/** @name VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS
419 * IOCTL to VBoxGuest to interrupt (cancel) any pending
420 * VBGL_IOCTL_WAIT_FOR_EVENTS and return.
421 *
422 * Handled inside the guest additions and not seen by the host at all.
423 * After calling this, VBGL_IOCTL_WAIT_FOR_EVENTS should no longer be called in
424 * the same session. At the time of writing this is not enforced; at the time
425 * of reading it may be.
426 * @see VBGL_IOCTL_WAIT_FOR_EVENTS
427 *
428 * @{
429 */
430#define VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS VBGL_IOCTL_CODE_SIZE(11, VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS_SIZE)
431#define VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS_SIZE sizeof(VBGLREQHDR)
432#define VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS_SIZE_IN sizeof(VBGLREQHDR)
433#define VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS_SIZE_OUT sizeof(VBGLREQHDR)
434/** @} */
435
436
437/** @name VBGL_IOCTL_CHANGE_FILTER_MASK
438 * IOCTL to VBoxGuest to control the event filter mask.
439 * @{ */
440#define VBGL_IOCTL_CHANGE_FILTER_MASK VBGL_IOCTL_CODE_SIZE(12, VBGL_IOCTL_CHANGE_FILTER_MASK_SIZE)
441#define VBGL_IOCTL_CHANGE_FILTER_MASK_SIZE sizeof(VBGLIOCCHANGEFILTERMASK)
442#define VBGL_IOCTL_CHANGE_FILTER_MASK_SIZE_IN sizeof(VBGLIOCCHANGEFILTERMASK)
443#define VBGL_IOCTL_CHANGE_FILTER_MASK_SIZE_OUT sizeof(VBGLREQHDR)
444typedef struct VBGLIOCCHANGEFILTERMASK
445{
446 /** The header. */
447 VBGLREQHDR Hdr;
448 union
449 {
450 struct
451 {
452 /** Flags to set. */
453 uint32_t fOrMask;
454 /** Flags to remove. */
455 uint32_t fNotMask;
456 } In;
457 } u;
458} VBGLIOCCHANGEFILTERMASK, RT_FAR *PVBGLIOCCHANGEFILTERMASK;
459AssertCompileSize(VBGLIOCCHANGEFILTERMASK, 24 + 8);
460/** @} */
461
462
463/** @name VBGL_IOCTL_GUEST_CAPS_ACQUIRE
464 * IOCTL to for acquiring and releasing guest capabilities.
465 *
466 * This is used for multiple purposes:
467 * 1. By doing @a acquire r3 client application (e.g. VBoxTray) claims it will
468 * use the given session for performing operations like @a seamless or
469 * @a auto-resize, thus, if the application terminates, the driver will
470 * automatically cleanup the caps reported to host, so that host knows guest
471 * does not support them anymore
472 * 2. In a multy-user environment this will not allow r3 applications (like
473 * VBoxTray) running in different user sessions simultaneously to interfere
474 * with each other. An r3 client application (like VBoxTray) is responsible
475 * for Acquiring/Releasing caps properly as needed.
476 *
477 *
478 * VERR_RESOURCE_BUSY is returned if any capabilities in the fOrMask are
479 * currently acquired by some other VBoxGuest session.
480 *
481 * @{
482 */
483#define VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES VBGL_IOCTL_CODE_SIZE(13, VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES_SIZE)
484#define VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES_SIZE sizeof(VBGLIOCACQUIREGUESTCAPS)
485#define VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES_SIZE_IN sizeof(VBGLIOCACQUIREGUESTCAPS)
486#define VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES_SIZE_OUT sizeof(VBGLREQHDR)
487
488/** Default operation (full acquire/release). */
489#define VBGL_IOC_AGC_FLAGS_DEFAULT UINT32_C(0x00000000)
490/** Configures VBoxGuest to use the specified caps in Acquire mode, w/o making
491 * any caps acquisition/release. This is only possible to set acquire mode for
492 * caps, but not clear it, so fNotMask is ignored when this flag is set. */
493#define VBGL_IOC_AGC_FLAGS_CONFIG_ACQUIRE_MODE UINT32_C(0x00000001)
494/** Valid flag mask. */
495#define VBGL_IOC_AGC_FLAGS_VALID_MASK UINT32_C(0x00000001)
496
497typedef struct VBGLIOCACQUIREGUESTCAPS
498{
499 /** The header. */
500 VBGLREQHDR Hdr;
501 union
502 {
503 struct
504 {
505 /** Acquire flags (VBGL_IOC_AGC_FLAGS_XXX). */
506 uint32_t fFlags;
507 /** Guest capabilities to acquire (VMMDEV_GUEST_SUPPORTS_XXX). */
508 uint32_t fOrMask;
509 /** Guest capabilities to release (VMMDEV_GUEST_SUPPORTS_XXX). */
510 uint32_t fNotMask;
511 } In;
512 } u;
513} VBGLIOCACQUIREGUESTCAPS, RT_FAR *PVBGLIOCACQUIREGUESTCAPS;
514AssertCompileSize(VBGLIOCACQUIREGUESTCAPS, 24 + 12);
515/** @} */
516
517
518/** @name VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES
519 * IOCTL to VBoxGuest to set guest capabilities.
520 * @{ */
521#define VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES VBGL_IOCTL_CODE_SIZE(14, VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES_SIZE)
522#define VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES_SIZE sizeof(VBGLIOCSETGUESTCAPS)
523#define VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES_SIZE_IN sizeof(VBGLIOCSETGUESTCAPS)
524#define VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES_SIZE_OUT sizeof(VBGLIOCSETGUESTCAPS)
525typedef struct VBGLIOCSETGUESTCAPS
526{
527 /** The header. */
528 VBGLREQHDR Hdr;
529 union
530 {
531 struct
532 {
533 /** The capabilities to set (VMMDEV_GUEST_SUPPORTS_XXX). */
534 uint32_t fOrMask;
535 /** The capabilities to drop (VMMDEV_GUEST_SUPPORTS_XXX). */
536 uint32_t fNotMask;
537 } In;
538 struct
539 {
540 /** The capabilities held by the session after the call (VMMDEV_GUEST_SUPPORTS_XXX). */
541 uint32_t fSessionCaps;
542 /** The capabilities for all the sessions after the call (VMMDEV_GUEST_SUPPORTS_XXX). */
543 uint32_t fGlobalCaps;
544 } Out;
545 } u;
546} VBGLIOCSETGUESTCAPS, RT_FAR *PVBGLIOCSETGUESTCAPS;
547AssertCompileSize(VBGLIOCSETGUESTCAPS, 24 + 8);
548typedef VBGLIOCSETGUESTCAPS VBoxGuestSetCapabilitiesInfo;
549/** @} */
550
551
552/** @name VBGL_IOCTL_SET_MOUSE_STATUS
553 * IOCTL to VBoxGuest to update the mouse status features.
554 * @{ */
555#define VBGL_IOCTL_SET_MOUSE_STATUS VBGL_IOCTL_CODE_SIZE(15, VBGL_IOCTL_SET_MOUSE_STATUS_SIZE)
556#define VBGL_IOCTL_SET_MOUSE_STATUS_SIZE sizeof(VBGLIOCSETMOUSESTATUS)
557#define VBGL_IOCTL_SET_MOUSE_STATUS_SIZE_IN sizeof(VBGLIOCSETMOUSESTATUS)
558#define VBGL_IOCTL_SET_MOUSE_STATUS_SIZE_OUT sizeof(VBGLREQHDR)
559typedef struct VBGLIOCSETMOUSESTATUS
560{
561 /** The header. */
562 VBGLREQHDR Hdr;
563 union
564 {
565 struct
566 {
567 /** Mouse status flags (VMMDEV_MOUSE_XXX). */
568 uint32_t fStatus;
569 } In;
570 } u;
571} VBGLIOCSETMOUSESTATUS, RT_FAR *PVBGLIOCSETMOUSESTATUS;
572/** @} */
573
574
575/** @name VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK
576 *
577 * IOCTL to for setting the mouse driver callback.
578 * @note The callback will be called in interrupt context with the VBoxGuest
579 * device event spinlock held.
580 * @note ring-0 only.
581 *
582 * @{ */
583#define VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK VBGL_IOCTL_CODE_SIZE(16, VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK_SIZE)
584#define VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK_SIZE sizeof(VBGLIOCSETMOUSENOTIFYCALLBACK)
585#define VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK_SIZE_IN sizeof(VBGLIOCSETMOUSENOTIFYCALLBACK)
586#define VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK_SIZE_OUT sizeof(VBGLREQHDR)
587typedef struct VBGLIOCSETMOUSENOTIFYCALLBACK
588{
589 /** The header. */
590 VBGLREQHDR Hdr;
591 union
592 {
593 struct
594 {
595 /** Mouse notification callback function. */
596 PFNVBOXGUESTMOUSENOTIFY pfnNotify;
597 /** The callback argument. */
598 void RT_FAR *pvUser;
599 } In;
600 } u;
601} VBGLIOCSETMOUSENOTIFYCALLBACK, RT_FAR *PVBGLIOCSETMOUSENOTIFYCALLBACK;
602/** @} */
603
604
605/** @name VBGL_IOCTL_CHECK_BALLOON
606 * IOCTL to VBoxGuest to check memory ballooning.
607 *
608 * The guest kernel module / device driver will ask the host for the current size of
609 * the balloon and adjust the size. Or it will set fHandledInR0 = false and R3 is
610 * responsible for allocating memory and calling R0 (VBGL_IOCTL_CHANGE_BALLOON).
611 * @{ */
612#define VBGL_IOCTL_CHECK_BALLOON VBGL_IOCTL_CODE_SIZE(17, VBGL_IOCTL_CHECK_BALLOON_SIZE)
613#define VBGL_IOCTL_CHECK_BALLOON_SIZE sizeof(VBGLIOCCHECKBALLOON)
614#define VBGL_IOCTL_CHECK_BALLOON_SIZE_IN sizeof(VBGLREQHDR)
615#define VBGL_IOCTL_CHECK_BALLOON_SIZE_OUT sizeof(VBGLIOCCHECKBALLOON)
616typedef struct VBGLIOCCHECKBALLOON
617{
618 /** The header. */
619 VBGLREQHDR Hdr;
620 union
621 {
622 struct
623 {
624 /** The size of the balloon in chunks of 1MB. */
625 uint32_t cBalloonChunks;
626 /** false = handled in R0, no further action required.
627 * true = allocate balloon memory in R3. */
628 bool fHandleInR3;
629 /** Explicit padding, please ignore. */
630 bool afPadding[3];
631 } Out;
632 } u;
633} VBGLIOCCHECKBALLOON, RT_FAR *PVBGLIOCCHECKBALLOON;
634AssertCompileSize(VBGLIOCCHECKBALLOON, 24 + 8);
635typedef VBGLIOCCHECKBALLOON VBoxGuestCheckBalloonInfo;
636/** @} */
637
638
639/** @name VBGL_IOCTL_CHANGE_BALLOON
640 * IOCTL to VBoxGuest to supply or revoke one chunk for ballooning.
641 *
642 * The guest kernel module / device driver will lock down supplied memory or
643 * unlock reclaimed memory and then forward the physical addresses of the
644 * changed balloon chunk to the host.
645 *
646 * @{ */
647#define VBGL_IOCTL_CHANGE_BALLOON VBGL_IOCTL_CODE_SIZE(18, VBGL_IOCTL_CHANGE_BALLOON_SIZE)
648#define VBGL_IOCTL_CHANGE_BALLOON_SIZE sizeof(VBGLIOCCHANGEBALLOON)
649#define VBGL_IOCTL_CHANGE_BALLOON_SIZE_IN sizeof(VBGLIOCCHANGEBALLOON)
650#define VBGL_IOCTL_CHANGE_BALLOON_SIZE_OUT sizeof(VBGLREQHDR)
651typedef struct VBGLIOCCHANGEBALLOON
652{
653 /** The header. */
654 VBGLREQHDR Hdr;
655 union
656 {
657 struct
658 {
659 /** Address of the chunk (user space address). */
660 RTR3PTR pvChunk;
661 /** Explicit alignment padding, MBZ. */
662 uint8_t abPadding[ARCH_BITS == 64 ? 0 + 7 : 4 + 7];
663 /** true = inflate, false = deflate. */
664 bool fInflate;
665 } In;
666 } u;
667} VBGLIOCCHANGEBALLOON, RT_FAR *PVBGLIOCCHANGEBALLOON;
668AssertCompileSize(VBGLIOCCHANGEBALLOON, 24+16);
669/** @} */
670
671
672/** @name VBGL_IOCTL_WRITE_CORE_DUMP
673 * IOCTL to VBoxGuest to write guest core.
674 * @{ */
675#define VBGL_IOCTL_WRITE_CORE_DUMP VBGL_IOCTL_CODE_SIZE(19, VBGL_IOCTL_WRITE_CORE_DUMP_SIZE)
676#define VBGL_IOCTL_WRITE_CORE_DUMP_SIZE sizeof(VBGLIOCWRITECOREDUMP)
677#define VBGL_IOCTL_WRITE_CORE_DUMP_SIZE_IN sizeof(VBGLIOCWRITECOREDUMP)
678#define VBGL_IOCTL_WRITE_CORE_DUMP_SIZE_OUT sizeof(VBGLREQHDR)
679typedef struct VBGLIOCWRITECOREDUMP
680{
681 /** The header. */
682 VBGLREQHDR Hdr;
683 union
684 {
685 struct
686 {
687 /** Flags (reserved, MBZ). */
688 uint32_t fFlags;
689 } In;
690 } u;
691} VBGLIOCWRITECOREDUMP, RT_FAR *PVBGLIOCWRITECOREDUMP;
692AssertCompileSize(VBGLIOCWRITECOREDUMP, 24 + 4);
693typedef VBGLIOCWRITECOREDUMP VBoxGuestWriteCoreDump;
694/** @} */
695
696
697#ifdef VBOX_WITH_DPC_LATENCY_CHECKER
698/** @name VBGL_IOCTL_DPC_LATENCY_CHECKER
699 * IOCTL to VBoxGuest to perform DPC latency tests, printing the result in
700 * the release log on the host. Takes no data, returns no data.
701 * @{ */
702# define VBGL_IOCTL_DPC_LATENCY_CHECKER VBGL_IOCTL_CODE_SIZE(20, VBGL_IOCTL_DPC_LATENCY_CHECKER_SIZE)
703# define VBGL_IOCTL_DPC_LATENCY_CHECKER_SIZE sizeof(VBGLREQHDR)
704# define VBGL_IOCTL_DPC_LATENCY_CHECKER_SIZE_IN sizeof(VBGLREQHDR)
705# define VBGL_IOCTL_DPC_LATENCY_CHECKER_SIZE_OUT sizeof(VBGLREQHDR)
706/** @} */
707#endif
708
709
710#ifdef RT_OS_OS2
711/**
712 * The data buffer layout for the IDC entry point (AttachDD).
713 *
714 * @remark This is defined in multiple 16-bit headers / sources.
715 * Some places it's called VBGOS2IDC to short things a bit.
716 */
717typedef struct VBGLOS2ATTACHDD
718{
719 /** VBGL_IOC_VERSION. */
720 uint32_t u32Version;
721 /** Opaque session handle. */
722 uint32_t u32Session;
723
724 /**
725 * The 32-bit service entry point.
726 *
727 * @returns VBox status code.
728 * @param u32Session The session handle (PVBOXGUESTSESSION).
729 * @param iFunction The requested function.
730 * @param pReqHdr The input/output data buffer. The caller
731 * ensures that this cannot be swapped out, or that
732 * it's acceptable to take a page in fault in the
733 * current context. If the request doesn't take
734 * input or produces output, apssing NULL is okay.
735 * @param cbReq The size of the data buffer.
736 */
737# if ARCH_BITS == 32 || defined(DOXYGEN_RUNNING)
738 DECLCALLBACKMEMBER(int, pfnServiceEP)(uint32_t u32Session, unsigned iFunction, PVBGLREQHDR pReqHdr, size_t cbReq);
739# else
740 uint32_t pfnServiceEP;
741#endif
742
743 /** The 16-bit service entry point for C code (cdecl).
744 *
745 * It's the same as the 32-bit entry point, but the types has
746 * changed to 16-bit equivalents.
747 *
748 * @code
749 * int far cdecl
750 * VBoxGuestOs2IDCService16(uint32_t u32Session, uint16_t iFunction,
751 * PVBGLREQHDR fpvData, uint16_t cbData);
752 * @endcode
753 */
754# if ARCH_BITS == 16 || defined(DOXYGEN_RUNNING)
755 DECLCALLBACKMEMBER(int, fpfnServiceEP)(uint32_t u32Session, uint16_t iFunction, PVBGLREQHDR fpvData, uint16_t cbData);
756# else
757 RTFAR16 fpfnServiceEP;
758# endif
759
760 /** The 16-bit service entry point for Assembly code (register).
761 *
762 * This is just a wrapper around fpfnServiceEP to simplify calls
763 * from 16-bit assembly code.
764 *
765 * @returns (e)ax: VBox status code; cx: The amount of data returned.
766 *
767 * @param u32Session eax - The above session handle.
768 * @param iFunction dl - The requested function.
769 * @param pvData es:bx - The input/output data buffer.
770 * @param cbData cx - The size of the data buffer.
771 */
772 RTFAR16 fpfnServiceAsmEP;
773} VBGLOS2ATTACHDD;
774/** Pointer to VBOXGUESTOS2IDCCONNECT buffer. */
775typedef VBGLOS2ATTACHDD RT_FAR *PVBGLOS2ATTACHDD;
776
777/**
778 * Prototype for the 16-bit callback returned by AttachDD on OS/2.
779 * @param pAttachInfo Pointer to structure to fill in.
780 */
781# if defined(__IBMC__) || defined(__IBMCPP__)
782typedef void (* __cdecl RT_FAR_CODE PFNVBGLOS2ATTACHDD)(PVBGLOS2ATTACHDD pAttachInfo);
783# else
784typedef void (__cdecl RT_FAR_CODE *PFNVBGLOS2ATTACHDD)(PVBGLOS2ATTACHDD pAttachInfo);
785# endif
786#endif /* RT_OS_OS2 */
787
788
789/** @name VBGL_IOCL_IDC_CONNECT
790 * IDC client connect request.
791 *
792 * On platforms other than Windows and OS/2, this will also create a kernel
793 * session for the caller.
794 *
795 * @note ring-0 only.
796 */
797#define VBGL_IOCTL_IDC_CONNECT VBGL_IOCTL_CODE_SIZE(63, VBGL_IOCTL_IDC_CONNECT_SIZE)
798#define VBGL_IOCTL_IDC_CONNECT_SIZE sizeof(VBGLIOCIDCCONNECT)
799#define VBGL_IOCTL_IDC_CONNECT_SIZE_IN RT_UOFFSET_AFTER(VBGLIOCIDCCONNECT, u.In)
800#define VBGL_IOCTL_IDC_CONNECT_SIZE_OUT sizeof(VBGLIOCIDCCONNECT)
801typedef struct VBGLIOCIDCCONNECT
802{
803 /** The header. */
804 VBGLREQHDR Hdr;
805 /** The payload union. */
806 union
807 {
808 struct
809 {
810 /** VBGL_IOCTL_IDC_CONNECT_MAGIC_COOKIE. */
811 uint32_t u32MagicCookie;
812 /** The desired version of the I/O control interface (VBGL_IOC_VERSION). */
813 uint32_t uReqVersion;
814 /** The minimum version of the I/O control interface (VBGL_IOC_VERSION). */
815 uint32_t uMinVersion;
816 /** Reserved, MBZ. */
817 uint32_t uReserved;
818 } In;
819 struct
820 {
821 /** The session handle (opaque). */
822#if ARCH_BITS >= 32
823 void RT_FAR *pvSession;
824#else
825 uint32_t pvSession;
826#endif
827 /** The version of the I/O control interface for this session
828 * (typically VBGL_IOC_VERSION). */
829 uint32_t uSessionVersion;
830 /** The I/O control interface version for of the driver (VBGL_IOC_VERSION). */
831 uint32_t uDriverVersion;
832 /** The SVN revision of the driver.
833 * This will be set to 0 if not compiled into the driver. */
834 uint32_t uDriverRevision;
835 /** Reserved \#1 (will be returned as zero until defined). */
836 uint32_t uReserved1;
837 /** Reserved \#2 (will be returned as NULL until defined). */
838 void RT_FAR *pvReserved2;
839 } Out;
840 } u;
841} VBGLIOCIDCCONNECT, RT_FAR *PVBGLIOCIDCCONNECT;
842AssertCompileSize(VBGLIOCIDCCONNECT, 24 + 16 + (ARCH_BITS == 64 ? 8 : 4) * 2);
843#if !defined(__GNUC__) /* Some GCC versions can't handle the complicated RT_UOFFSET_AFTER macro, it seems. */ \
844 && (!defined(RT_OS_OS2) || (!defined(__IBMC__) && !defined(__IBMCPP__) && (!defined(__WATCOMC__) || !defined(__cplusplus))))
845AssertCompile(VBGL_IOCTL_IDC_CONNECT_SIZE_IN == 24 + 16);
846#endif
847#define VBGL_IOCTL_IDC_CONNECT_MAGIC_COOKIE UINT32_C(0x55aa4d5a) /**< Magic value for doing an IDC connect. */
848/** @} */
849
850
851/** @name VBGL_IOCL_IDC_DISCONNECT
852 * IDC client disconnect request.
853 *
854 * This will destroy the kernel session associated with the IDC connection.
855 *
856 * @note ring-0 only.
857 */
858#define VBGL_IOCTL_IDC_DISCONNECT VBGL_IOCTL_CODE_SIZE(62, VBGL_IOCTL_IDC_DISCONNECT_SIZE)
859#define VBGL_IOCTL_IDC_DISCONNECT_SIZE sizeof(VBGLIOCIDCDISCONNECT)
860#define VBGL_IOCTL_IDC_DISCONNECT_SIZE_IN sizeof(VBGLIOCIDCDISCONNECT)
861#define VBGL_IOCTL_IDC_DISCONNECT_SIZE_OUT sizeof(VBGLREQHDR)
862typedef struct VBGLIOCIDCDISCONNECT
863{
864 /** The header. */
865 VBGLREQHDR Hdr;
866 union
867 {
868 struct
869 {
870 /** The session handle for platforms where this is needed. */
871#if ARCH_BITS >= 32
872 void RT_FAR *pvSession;
873#else
874 uint32_t pvSession;
875#endif
876 } In;
877 } u;
878} VBGLIOCIDCDISCONNECT, RT_FAR *PVBGLIOCIDCDISCONNECT;
879AssertCompileSize(VBGLIOCIDCDISCONNECT, 24 + (ARCH_BITS == 64 ? 8 : 4));
880/** @} */
881
882
883#if !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2)
884RT_C_DECLS_BEGIN
885/**
886 * The VBoxGuest IDC entry point.
887 *
888 * @returns VBox status code.
889 * @param pvSession The session.
890 * @param uReq The request code.
891 * @param pReqHdr The request.
892 * @param cbReq The request size.
893 */
894int VBOXCALL VBoxGuestIDC(void RT_FAR *pvSession, uintptr_t uReq, PVBGLREQHDR pReqHdr, size_t cbReq);
895RT_C_DECLS_END
896#endif
897
898
899#if defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)
900
901/* Private IOCtls between user space and the kernel video driver. DRM private
902 * IOCtls always have the type 'd' and a number between 0x40 and 0x99 (0x9F?) */
903
904# define VBOX_DRM_IOCTL(a) (0x40 + DRM_VBOX_ ## a)
905
906/** Stop using HGSMI in the kernel driver until it is re-enabled, so that a
907 * user-space driver can use it. It must be re-enabled before the kernel
908 * driver can be used again in a sensible way. */
909/** @note These IOCtls was removed from the code, but are left here as
910 * templates as we may need similar ones in future. */
911# define DRM_VBOX_DISABLE_HGSMI 0
912# define DRM_IOCTL_VBOX_DISABLE_HGSMI VBOX_DRM_IOCTL(DISABLE_HGSMI)
913# define VBOXVIDEO_IOCTL_DISABLE_HGSMI _IO('d', DRM_IOCTL_VBOX_DISABLE_HGSMI)
914/** Enable HGSMI in the kernel driver after it was previously disabled. */
915# define DRM_VBOX_ENABLE_HGSMI 1
916# define DRM_IOCTL_VBOX_ENABLE_HGSMI VBOX_DRM_IOCTL(ENABLE_HGSMI)
917# define VBOXVIDEO_IOCTL_ENABLE_HGSMI _IO('d', DRM_IOCTL_VBOX_ENABLE_HGSMI)
918
919#endif /* RT_OS_LINUX || RT_OS_SOLARIS || RT_OS_FREEBSD */
920
921#endif /* !defined(IN_RC) && !defined(IN_RING0_AGNOSTIC) && !defined(IPRT_NO_CRT) */
922
923/** @} */
924
925/** @} */
926#endif
927
ubuntu-bionic-kernel mirror