VBoxGuest.h@ 68813

Last change on this file since 68813 was 68688, checked in by vboxsync, 7 years ago
VBoxGuest.h,VMMDev.h: use assertcompile.h instead of assert.h.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.5 KB

Line
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-2016 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)
196	typedef 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;
230	AssertCompileSize(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))))
233	AssertCompile(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)
247	typedef 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;
264	AssertCompileSize(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)
292	typedef 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;
308	AssertCompileSize(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))))
311	AssertCompile(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. */
324	typedef 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;
336	AssertCompileSize(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)
369	typedef 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_GET_VMMDEV_IO_INFO_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)
394	typedef 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;
414	AssertCompileSize(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)
444	typedef 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;
459	AssertCompileSize(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
497	typedef 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;
514	AssertCompileSize(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)
525	typedef 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;
547	AssertCompileSize(VBGLIOCSETGUESTCAPS, 24 + 8);
548	typedef 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)
559	typedef 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)
587	typedef 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)
616	typedef 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;
634	AssertCompileSize(VBGLIOCCHECKBALLOON, 24 + 8);
635	typedef 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)
651	typedef 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;
668	AssertCompileSize(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)
679	typedef 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;
692	AssertCompileSize(VBGLIOCWRITECOREDUMP, 24 + 4);
693	typedef 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	*/
717	typedef 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. */
775	typedef 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__)
782	typedef void (* __cdecl RT_FAR_CODE PFNVBGLOS2ATTACHDD)(PVBGLOS2ATTACHDD pAttachInfo);
783	# else
784	typedef 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)
801	typedef 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;
842	AssertCompileSize(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))))
845	AssertCompile(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)
862	typedef 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;
879	AssertCompileSize(VBGLIOCIDCDISCONNECT, 24 + (ARCH_BITS == 64 ? 8 : 4));
880	/** @} */
881
882
883	#if !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2)
884	RT_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	*/
894	int VBOXCALL VBoxGuestIDC(void RT_FAR *pvSession, uintptr_t uReq, PVBGLREQHDR pReqHdr, size_t cbReq);
895	RT_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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: