SUPDrvIOC.h@ 37591

Last change on this file since 37591 was 37591, checked in by vboxsync, 13 years ago
RTLog,VMM,Main,SUPDrv: Restrict VM release logging by group - major support driver version change.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 39.4 KB

Line
1	/* $Revision: 37591 $ */
2	/** @file
3	* VirtualBox Support Driver - IOCtl definitions.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27	#ifndef ___SUPDrvIOC_h___
28	#define ___SUPDrvIOC_h___
29
30	/*
31	* Basic types.
32	*/
33	#include <iprt/types.h>
34
35	/*
36	* IOCtl numbers.
37	* We're using the Win32 type of numbers here, thus the macros below.
38	* The SUP_IOCTL_FLAG macro is used to separate requests from 32-bit
39	* and 64-bit processes.
40	*/
41	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_SPARC64)
42	# define SUP_IOCTL_FLAG 128
43	#elif defined(RT_ARCH_X86) \|\| defined(RT_ARCH_SPARC)
44	# define SUP_IOCTL_FLAG 0
45	#else
46	# error "dunno which arch this is!"
47	#endif
48
49	#ifdef RT_OS_WINDOWS
50	# ifndef CTL_CODE
51	# include <Windows.h>
52	# endif
53	/* Automatic buffering, size not encoded. */
54	# define SUP_CTL_CODE_SIZE(Function, Size) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) \| SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
55	# define SUP_CTL_CODE_BIG(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) \| SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
56	# define SUP_CTL_CODE_FAST(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) \| SUP_IOCTL_FLAG, METHOD_NEITHER, FILE_WRITE_ACCESS)
57	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
58
59	#elif defined(RT_OS_SOLARIS)
60	/* No automatic buffering, size limited to 255 bytes. */
61	# include <sys/ioccom.h>
62	# define SUP_CTL_CODE_SIZE(Function, Size) _IOWRN('V', (Function) \| SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
63	# define SUP_CTL_CODE_BIG(Function) _IOWRN('V', (Function) \| SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
64	# define SUP_CTL_CODE_FAST(Function) _IO( 'V', (Function) \| SUP_IOCTL_FLAG)
65	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
66
67	#elif defined(RT_OS_OS2)
68	/* No automatic buffering, size not encoded. */
69	# define SUP_CTL_CATEGORY 0xc0
70	# define SUP_CTL_CODE_SIZE(Function, Size) ((unsigned char)(Function))
71	# define SUP_CTL_CODE_BIG(Function) ((unsigned char)(Function))
72	# define SUP_CTL_CATEGORY_FAST 0xc1
73	# define SUP_CTL_CODE_FAST(Function) ((unsigned char)(Function))
74	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
75
76	#elif defined(RT_OS_LINUX)
77	/* No automatic buffering, size limited to 16KB. */
78	# include <linux/ioctl.h>
79	# define SUP_CTL_CODE_SIZE(Function, Size) _IOC(_IOC_READ \| _IOC_WRITE, 'V', (Function) \| SUP_IOCTL_FLAG, (Size))
80	# define SUP_CTL_CODE_BIG(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
81	# define SUP_CTL_CODE_FAST(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
82	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) ((uIOCtl) & ~IOCSIZE_MASK)
83
84	#elif defined(RT_OS_L4)
85	/* Implemented in suplib, no worries. */
86	# define SUP_CTL_CODE_SIZE(Function, Size) (Function)
87	# define SUP_CTL_CODE_BIG(Function) (Function)
88	# define SUP_CTL_CODE_FAST(Function) (Function)
89	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
90
91	#else /* BSD Like */
92	/* Automatic buffering, size limited to 4KB on BSD and 8KB on Darwin - commands the limit, 4KB. /
93	# include <sys/ioccom.h>
94	# define SUP_CTL_CODE_SIZE(Function, Size) _IOC(IOC_INOUT, 'V', (Function) \| SUP_IOCTL_FLAG, (Size))
95	# define SUP_CTL_CODE_BIG(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
96	# define SUP_CTL_CODE_FAST(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
97	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) ( (uIOCtl) & ~_IOC(0,0,0,IOCPARM_MASK) )
98	#endif
99
100	/** Fast path IOCtl: VMMR0_DO_RAW_RUN */
101	#define SUP_IOCTL_FAST_DO_RAW_RUN SUP_CTL_CODE_FAST(64)
102	/** Fast path IOCtl: VMMR0_DO_HWACC_RUN */
103	#define SUP_IOCTL_FAST_DO_HWACC_RUN SUP_CTL_CODE_FAST(65)
104	/** Just a NOP call for profiling the latency of a fast ioctl call to VMMR0. */
105	#define SUP_IOCTL_FAST_DO_NOP SUP_CTL_CODE_FAST(66)
106
107
108
109	/*******************************************************************************
110	* Structures and Typedefs *
111	*******************************************************************************/
112	#ifdef RT_ARCH_AMD64
113	# pragma pack(8) /* paranoia. */
114	#else
115	# pragma pack(4) /* paranoia. */
116	#endif
117
118
119	/**
120	* Common In/Out header.
121	*/
122	typedef struct SUPREQHDR
123	{
124	/** Cookie. */
125	uint32_t u32Cookie;
126	/** Session cookie. */
127	uint32_t u32SessionCookie;
128	/** The size of the input. */
129	uint32_t cbIn;
130	/** The size of the output. */
131	uint32_t cbOut;
132	/** Flags. See SUPREQHDR_FLAGS_* for details and values. */
133	uint32_t fFlags;
134	/** The VBox status code of the operation, out direction only. */
135	int32_t rc;
136	} SUPREQHDR;
137	/** Pointer to a IOC header. */
138	typedef SUPREQHDR *PSUPREQHDR;
139
140	/** @name SUPREQHDR::fFlags values
141	* @{ */
142	/** Masks out the magic value. */
143	#define SUPREQHDR_FLAGS_MAGIC_MASK UINT32_C(0xff0000ff)
144	/** The generic mask. */
145	#define SUPREQHDR_FLAGS_GEN_MASK UINT32_C(0x0000ff00)
146	/** The request specific mask. */
147	#define SUPREQHDR_FLAGS_REQ_MASK UINT32_C(0x00ff0000)
148
149	/** There is extra input that needs copying on some platforms. */
150	#define SUPREQHDR_FLAGS_EXTRA_IN UINT32_C(0x00000100)
151	/** There is extra output that needs copying on some platforms. */
152	#define SUPREQHDR_FLAGS_EXTRA_OUT UINT32_C(0x00000200)
153
154	/** The magic value. */
155	#define SUPREQHDR_FLAGS_MAGIC UINT32_C(0x42000042)
156	/** The default value. Use this when no special stuff is requested. */
157	#define SUPREQHDR_FLAGS_DEFAULT SUPREQHDR_FLAGS_MAGIC
158	/** @} */
159
160
161	/** @name SUP_IOCTL_COOKIE
162	* @{
163	*/
164	/** Negotiate cookie. */
165	#define SUP_IOCTL_COOKIE SUP_CTL_CODE_SIZE(1, SUP_IOCTL_COOKIE_SIZE)
166	/** The request size. */
167	#define SUP_IOCTL_COOKIE_SIZE sizeof(SUPCOOKIE)
168	/** The SUPREQHDR::cbIn value. */
169	#define SUP_IOCTL_COOKIE_SIZE_IN sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.In)
170	/** The SUPREQHDR::cbOut value. */
171	#define SUP_IOCTL_COOKIE_SIZE_OUT sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.Out)
172	/** SUPCOOKIE_IN magic word. */
173	#define SUPCOOKIE_MAGIC "The Magic Word!"
174	/** The initial cookie. */
175	#define SUPCOOKIE_INITIAL_COOKIE 0x69726f74 /* 'tori' */
176
177	/** Current interface version.
178	* The upper 16-bit is the major version, the the lower the minor version.
179	* When incompatible changes are made, the upper major number has to be changed.
180	*
181	* Update rules:
182	* -# Only update the major number when incompatible changes have been made to
183	* the IOC interface or the ABI provided via the functions returned by
184	* SUPQUERYFUNCS.
185	* -# When adding new features (new IOC number, new flags, new exports, ++)
186	* only update the minor number and change SUPLib.cpp to require the
187	* new IOC version.
188	* -# When incrementing the major number, clear the minor part and reset
189	* any IOC version requirements in SUPLib.cpp.
190	* -# When increment the major number, execute all pending work.
191	*
192	* @todo Pending work on next major version change:
193	* - None.
194	*/
195	#define SUPDRV_IOC_VERSION 0x00190000
196
197	/** SUP_IOCTL_COOKIE. */
198	typedef struct SUPCOOKIE
199	{
200	/** The header.
201	* u32Cookie must be set to SUPCOOKIE_INITIAL_COOKIE.
202	* u32SessionCookie should be set to some random value. */
203	SUPREQHDR Hdr;
204	union
205	{
206	struct
207	{
208	/** Magic word. */
209	char szMagic[16];
210	/** The requested interface version number. */
211	uint32_t u32ReqVersion;
212	/** The minimum interface version number. */
213	uint32_t u32MinVersion;
214	} In;
215	struct
216	{
217	/** Cookie. */
218	uint32_t u32Cookie;
219	/** Session cookie. */
220	uint32_t u32SessionCookie;
221	/** Interface version for this session. */
222	uint32_t u32SessionVersion;
223	/** The actual interface version in the driver. */
224	uint32_t u32DriverVersion;
225	/** Number of functions available for the SUP_IOCTL_QUERY_FUNCS request. */
226	uint32_t cFunctions;
227	/** Session handle. */
228	R0PTRTYPE(PSUPDRVSESSION) pSession;
229	} Out;
230	} u;
231	} SUPCOOKIE, *PSUPCOOKIE;
232	/** @} */
233
234
235	/** @name SUP_IOCTL_QUERY_FUNCS
236	* Query SUPR0 functions.
237	* @{
238	*/
239	#define SUP_IOCTL_QUERY_FUNCS(cFuncs) SUP_CTL_CODE_BIG(2)
240	#define SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs) RT_UOFFSETOF(SUPQUERYFUNCS, u.Out.aFunctions[(cFuncs)])
241	#define SUP_IOCTL_QUERY_FUNCS_SIZE_IN sizeof(SUPREQHDR)
242	#define SUP_IOCTL_QUERY_FUNCS_SIZE_OUT(cFuncs) SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs)
243
244	/** A function. */
245	typedef struct SUPFUNC
246	{
247	/** Name - mangled. */
248	char szName[32];
249	/** Address. */
250	RTR0PTR pfn;
251	} SUPFUNC, *PSUPFUNC;
252
253	typedef struct SUPQUERYFUNCS
254	{
255	/** The header. */
256	SUPREQHDR Hdr;
257	union
258	{
259	struct
260	{
261	/** Number of functions returned. */
262	uint32_t cFunctions;
263	/** Array of functions. */
264	SUPFUNC aFunctions[1];
265	} Out;
266	} u;
267	} SUPQUERYFUNCS, *PSUPQUERYFUNCS;
268	/** @} */
269
270
271	/** @name SUP_IOCTL_LDR_OPEN
272	* Open an image.
273	* @{
274	*/
275	#define SUP_IOCTL_LDR_OPEN SUP_CTL_CODE_SIZE(3, SUP_IOCTL_LDR_OPEN_SIZE)
276	#define SUP_IOCTL_LDR_OPEN_SIZE sizeof(SUPLDROPEN)
277	#define SUP_IOCTL_LDR_OPEN_SIZE_IN sizeof(SUPLDROPEN)
278	#define SUP_IOCTL_LDR_OPEN_SIZE_OUT (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDROPEN, u.Out))
279	typedef struct SUPLDROPEN
280	{
281	/** The header. */
282	SUPREQHDR Hdr;
283	union
284	{
285	struct
286	{
287	/** Size of the image we'll be loading (including tables). */
288	uint32_t cbImageWithTabs;
289	/** The size of the image bits. (Less or equal to cbImageWithTabs.) */
290	uint32_t cbImageBits;
291	/** Image name.
292	* This is the NAME of the image, not the file name. It is used
293	* to share code with other processes. (Max len is 32 chars!) */
294	char szName[32];
295	/** Image file name.
296	* This can be used to load the image using a native loader. */
297	char szFilename[260];
298	} In;
299	struct
300	{
301	/** The base address of the image. */
302	RTR0PTR pvImageBase;
303	/** Indicate whether or not the image requires loading. */
304	bool fNeedsLoading;
305	/** Indicates that we're using the native ring-0 loader. */
306	bool fNativeLoader;
307	} Out;
308	} u;
309	} SUPLDROPEN, *PSUPLDROPEN;
310	/** @} */
311
312
313	/** @name SUP_IOCTL_LDR_LOAD
314	* Upload the image bits.
315	* @{
316	*/
317	#define SUP_IOCTL_LDR_LOAD SUP_CTL_CODE_BIG(4)
318	#define SUP_IOCTL_LDR_LOAD_SIZE(cbImage) RT_UOFFSETOF(SUPLDRLOAD, u.In.abImage[cbImage])
319	#define SUP_IOCTL_LDR_LOAD_SIZE_IN(cbImage) RT_UOFFSETOF(SUPLDRLOAD, u.In.abImage[cbImage])
320	#define SUP_IOCTL_LDR_LOAD_SIZE_OUT sizeof(SUPREQHDR)
321
322	/**
323	* Module initialization callback function.
324	* This is called once after the module has been loaded.
325	*
326	* @returns 0 on success.
327	* @returns Appropriate error code on failure.
328	*/
329	typedef DECLCALLBACK(int) FNR0MODULEINIT(void);
330	/** Pointer to a FNR0MODULEINIT(). */
331	typedef R0PTRTYPE(FNR0MODULEINIT *) PFNR0MODULEINIT;
332
333	/**
334	* Module termination callback function.
335	* This is called once right before the module is being unloaded.
336	*/
337	typedef DECLCALLBACK(void) FNR0MODULETERM(void);
338	/** Pointer to a FNR0MODULETERM(). */
339	typedef R0PTRTYPE(FNR0MODULETERM *) PFNR0MODULETERM;
340
341	/**
342	* Symbol table entry.
343	*/
344	typedef struct SUPLDRSYM
345	{
346	/** Offset into of the string table. */
347	uint32_t offName;
348	/** Offset of the symbol relative to the image load address.
349	* @remarks When used inside the SUPDrv to calculate real addresses, it
350	* must be cast to int32_t for the sake of native loader support
351	* on Solaris. (The loader puts the and data in different
352	* memory areans, and the text one is generally higher.) */
353	uint32_t offSymbol;
354	} SUPLDRSYM;
355	/** Pointer to a symbol table entry. */
356	typedef SUPLDRSYM *PSUPLDRSYM;
357	/** Pointer to a const symbol table entry. */
358	typedef SUPLDRSYM const *PCSUPLDRSYM;
359
360	/**
361	* SUPLDRLOAD::u::In::EP type.
362	*/
363	typedef enum SUPLDRLOADEP
364	{
365	SUPLDRLOADEP_NOTHING = 0,
366	SUPLDRLOADEP_VMMR0,
367	SUPLDRLOADEP_SERVICE,
368	SUPLDRLOADEP_32BIT_HACK = 0x7fffffff
369	} SUPLDRLOADEP;
370
371	typedef struct SUPLDRLOAD
372	{
373	/** The header. */
374	SUPREQHDR Hdr;
375	union
376	{
377	struct
378	{
379	/** The address of module initialization function. Similar to _DLL_InitTerm(hmod, 0). */
380	PFNR0MODULEINIT pfnModuleInit;
381	/** The address of module termination function. Similar to _DLL_InitTerm(hmod, 1). */
382	PFNR0MODULETERM pfnModuleTerm;
383	/** Special entry points. */
384	union
385	{
386	/** SUPLDRLOADEP_VMMR0. */
387	struct
388	{
389	/** The module handle (i.e. address). */
390	RTR0PTR pvVMMR0;
391	/** Address of VMMR0EntryInt function. */
392	RTR0PTR pvVMMR0EntryInt;
393	/** Address of VMMR0EntryFast function. */
394	RTR0PTR pvVMMR0EntryFast;
395	/** Address of VMMR0EntryEx function. */
396	RTR0PTR pvVMMR0EntryEx;
397	} VMMR0;
398	/** SUPLDRLOADEP_SERVICE. */
399	struct
400	{
401	/** The service request handler.
402	* (PFNR0SERVICEREQHANDLER isn't defined yet.) */
403	RTR0PTR pfnServiceReq;
404	/** Reserved, must be NIL. */
405	RTR0PTR apvReserved[3];
406	} Service;
407	} EP;
408	/** Address. */
409	RTR0PTR pvImageBase;
410	/** Entry point type. */
411	SUPLDRLOADEP eEPType;
412	/** The size of the image bits (starting at offset 0 and
413	* approaching offSymbols). */
414	uint32_t cbImageBits;
415	/** The offset of the symbol table. */
416	uint32_t offSymbols;
417	/** The number of entries in the symbol table. */
418	uint32_t cSymbols;
419	/** The offset of the string table. */
420	uint32_t offStrTab;
421	/** Size of the string table. */
422	uint32_t cbStrTab;
423	/** Size of image data in achImage. */
424	uint32_t cbImageWithTabs;
425	/** The image data. */
426	uint8_t abImage[1];
427	} In;
428	} u;
429	} SUPLDRLOAD, *PSUPLDRLOAD;
430	/** @} */
431
432
433	/** @name SUP_IOCTL_LDR_FREE
434	* Free an image.
435	* @{
436	*/
437	#define SUP_IOCTL_LDR_FREE SUP_CTL_CODE_SIZE(5, SUP_IOCTL_LDR_FREE_SIZE)
438	#define SUP_IOCTL_LDR_FREE_SIZE sizeof(SUPLDRFREE)
439	#define SUP_IOCTL_LDR_FREE_SIZE_IN sizeof(SUPLDRFREE)
440	#define SUP_IOCTL_LDR_FREE_SIZE_OUT sizeof(SUPREQHDR)
441	typedef struct SUPLDRFREE
442	{
443	/** The header. */
444	SUPREQHDR Hdr;
445	union
446	{
447	struct
448	{
449	/** Address. */
450	RTR0PTR pvImageBase;
451	} In;
452	} u;
453	} SUPLDRFREE, *PSUPLDRFREE;
454	/** @} */
455
456
457	/** @name SUP_IOCTL_LDR_GET_SYMBOL
458	* Get address of a symbol within an image.
459	* @{
460	*/
461	#define SUP_IOCTL_LDR_GET_SYMBOL SUP_CTL_CODE_SIZE(6, SUP_IOCTL_LDR_GET_SYMBOL_SIZE)
462	#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE sizeof(SUPLDRGETSYMBOL)
463	#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_IN sizeof(SUPLDRGETSYMBOL)
464	#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_OUT (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDRGETSYMBOL, u.Out))
465	typedef struct SUPLDRGETSYMBOL
466	{
467	/** The header. */
468	SUPREQHDR Hdr;
469	union
470	{
471	struct
472	{
473	/** Address. */
474	RTR0PTR pvImageBase;
475	/** The symbol name. */
476	char szSymbol[64];
477	} In;
478	struct
479	{
480	/** The symbol address. */
481	RTR0PTR pvSymbol;
482	} Out;
483	} u;
484	} SUPLDRGETSYMBOL, *PSUPLDRGETSYMBOL;
485	/** @} */
486
487
488	/** @name SUP_IOCTL_CALL_VMMR0
489	* Call the R0 VMM Entry point.
490	* @{
491	*/
492	#define SUP_IOCTL_CALL_VMMR0(cbReq) SUP_CTL_CODE_SIZE(7, SUP_IOCTL_CALL_VMMR0_SIZE(cbReq))
493	#define SUP_IOCTL_CALL_VMMR0_SIZE(cbReq) RT_UOFFSETOF(SUPCALLVMMR0, abReqPkt[cbReq])
494	#define SUP_IOCTL_CALL_VMMR0_SIZE_IN(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
495	#define SUP_IOCTL_CALL_VMMR0_SIZE_OUT(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
496	typedef struct SUPCALLVMMR0
497	{
498	/** The header. */
499	SUPREQHDR Hdr;
500	union
501	{
502	struct
503	{
504	/** The VM handle. */
505	PVMR0 pVMR0;
506	/** VCPU id. */
507	uint32_t idCpu;
508	/** Which operation to execute. */
509	uint32_t uOperation;
510	/** Argument to use when no request packet is supplied. */
511	uint64_t u64Arg;
512	} In;
513	} u;
514	/** The VMMR0Entry request packet. */
515	uint8_t abReqPkt[1];
516	} SUPCALLVMMR0, *PSUPCALLVMMR0;
517	/** @} */
518
519
520	/** @name SUP_IOCTL_CALL_VMMR0_BIG
521	* Version of SUP_IOCTL_CALL_VMMR0 for dealing with large requests.
522	* @{
523	*/
524	#define SUP_IOCTL_CALL_VMMR0_BIG SUP_CTL_CODE_BIG(27)
525	#define SUP_IOCTL_CALL_VMMR0_BIG_SIZE(cbReq) RT_UOFFSETOF(SUPCALLVMMR0, abReqPkt[cbReq])
526	#define SUP_IOCTL_CALL_VMMR0_BIG_SIZE_IN(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
527	#define SUP_IOCTL_CALL_VMMR0_BIG_SIZE_OUT(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
528	/** @} */
529
530
531	/** @name SUP_IOCTL_LOW_ALLOC
532	* Allocate memory below 4GB (physically).
533	* @{
534	*/
535	#define SUP_IOCTL_LOW_ALLOC SUP_CTL_CODE_BIG(8)
536	#define SUP_IOCTL_LOW_ALLOC_SIZE(cPages) ((uint32_t)RT_UOFFSETOF(SUPLOWALLOC, u.Out.aPages[cPages]))
537	#define SUP_IOCTL_LOW_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLOWALLOC, u.In))
538	#define SUP_IOCTL_LOW_ALLOC_SIZE_OUT(cPages) SUP_IOCTL_LOW_ALLOC_SIZE(cPages)
539	typedef struct SUPLOWALLOC
540	{
541	/** The header. */
542	SUPREQHDR Hdr;
543	union
544	{
545	struct
546	{
547	/** Number of pages to allocate. */
548	uint32_t cPages;
549	} In;
550	struct
551	{
552	/** The ring-3 address of the allocated memory. */
553	RTR3PTR pvR3;
554	/** The ring-0 address of the allocated memory. */
555	RTR0PTR pvR0;
556	/** Array of pages. */
557	RTHCPHYS aPages[1];
558	} Out;
559	} u;
560	} SUPLOWALLOC, *PSUPLOWALLOC;
561	/** @} */
562
563
564	/** @name SUP_IOCTL_LOW_FREE
565	* Free low memory.
566	* @{
567	*/
568	#define SUP_IOCTL_LOW_FREE SUP_CTL_CODE_SIZE(9, SUP_IOCTL_LOW_FREE_SIZE)
569	#define SUP_IOCTL_LOW_FREE_SIZE sizeof(SUPLOWFREE)
570	#define SUP_IOCTL_LOW_FREE_SIZE_IN sizeof(SUPLOWFREE)
571	#define SUP_IOCTL_LOW_FREE_SIZE_OUT sizeof(SUPREQHDR)
572	typedef struct SUPLOWFREE
573	{
574	/** The header. */
575	SUPREQHDR Hdr;
576	union
577	{
578	struct
579	{
580	/** The ring-3 address of the memory to free. */
581	RTR3PTR pvR3;
582	} In;
583	} u;
584	} SUPLOWFREE, *PSUPLOWFREE;
585	/** @} */
586
587
588	/** @name SUP_IOCTL_PAGE_ALLOC_EX
589	* Allocate memory and map it into kernel and/or user space. The memory is of
590	* course locked. The result should be freed using SUP_IOCTL_PAGE_FREE.
591	*
592	* @remarks Allocations without a kernel mapping may fail with
593	* VERR_NOT_SUPPORTED on some platforms.
594	*
595	* @{
596	*/
597	#define SUP_IOCTL_PAGE_ALLOC_EX SUP_CTL_CODE_BIG(10)
598	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages) RT_UOFFSETOF(SUPPAGEALLOCEX, u.Out.aPages[cPages])
599	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGEALLOCEX, u.In))
600	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_OUT(cPages) SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages)
601	typedef struct SUPPAGEALLOCEX
602	{
603	/** The header. */
604	SUPREQHDR Hdr;
605	union
606	{
607	struct
608	{
609	/** Number of pages to allocate */
610	uint32_t cPages;
611	/** Whether it should have kernel mapping. */
612	bool fKernelMapping;
613	/** Whether it should have a user mapping. */
614	bool fUserMapping;
615	/** Reserved. Must be false. */
616	bool fReserved0;
617	/** Reserved. Must be false. */
618	bool fReserved1;
619	} In;
620	struct
621	{
622	/** Returned ring-3 address. */
623	RTR3PTR pvR3;
624	/** Returned ring-0 address. */
625	RTR0PTR pvR0;
626	/** The physical addresses of the allocated pages. */
627	RTHCPHYS aPages[1];
628	} Out;
629	} u;
630	} SUPPAGEALLOCEX, *PSUPPAGEALLOCEX;
631	/** @} */
632
633
634	/** @name SUP_IOCTL_PAGE_MAP_KERNEL
635	* Maps a portion of memory allocated by SUP_IOCTL_PAGE_ALLOC_EX /
636	* SUPR0PageAllocEx into kernel space for use by a device or similar.
637	*
638	* The mapping will be freed together with the ring-3 mapping when
639	* SUP_IOCTL_PAGE_FREE or SUPR0PageFree is called.
640	*
641	* @remarks Not necessarily supported on all platforms.
642	*
643	* @{
644	*/
645	#define SUP_IOCTL_PAGE_MAP_KERNEL SUP_CTL_CODE_SIZE(11, SUP_IOCTL_PAGE_MAP_KERNEL_SIZE)
646	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE sizeof(SUPPAGEMAPKERNEL)
647	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_IN sizeof(SUPPAGEMAPKERNEL)
648	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_OUT sizeof(SUPPAGEMAPKERNEL)
649	typedef struct SUPPAGEMAPKERNEL
650	{
651	/** The header. */
652	SUPREQHDR Hdr;
653	union
654	{
655	struct
656	{
657	/** The pointer of to the previously allocated memory. */
658	RTR3PTR pvR3;
659	/** The offset to start mapping from. */
660	uint32_t offSub;
661	/** Size of the section to map. */
662	uint32_t cbSub;
663	/** Flags reserved for future fun. */
664	uint32_t fFlags;
665	} In;
666	struct
667	{
668	/** The ring-0 address corresponding to pvR3 + offSub. */
669	RTR0PTR pvR0;
670	} Out;
671	} u;
672	} SUPPAGEMAPKERNEL, *PSUPPAGEMAPKERNEL;
673	/** @} */
674
675
676	/** @name SUP_IOCTL_PAGE_PROTECT
677	* Changes the page level protection of the user and/or kernel mappings of
678	* memory previously allocated by SUPR0PageAllocEx.
679	*
680	* @remarks Not necessarily supported on all platforms.
681	*
682	* @{
683	*/
684	#define SUP_IOCTL_PAGE_PROTECT SUP_CTL_CODE_SIZE(12, SUP_IOCTL_PAGE_PROTECT_SIZE)
685	#define SUP_IOCTL_PAGE_PROTECT_SIZE sizeof(SUPPAGEPROTECT)
686	#define SUP_IOCTL_PAGE_PROTECT_SIZE_IN sizeof(SUPPAGEPROTECT)
687	#define SUP_IOCTL_PAGE_PROTECT_SIZE_OUT sizeof(SUPPAGEPROTECT)
688	typedef struct SUPPAGEPROTECT
689	{
690	/** The header. */
691	SUPREQHDR Hdr;
692	union
693	{
694	struct
695	{
696	/** The pointer of to the previously allocated memory.
697	* Pass NIL_RTR3PTR if the ring-0 mapping should remain unaffected. */
698	RTR3PTR pvR3;
699	/** The pointer of to the previously allocated memory.
700	* Pass NIL_RTR0PTR if the ring-0 mapping should remain unaffected. */
701	RTR0PTR pvR0;
702	/** The offset to start changing protection at. */
703	uint32_t offSub;
704	/** Size of the portion that should be changed. */
705	uint32_t cbSub;
706	/** Protection flags, RTMEM_PROT_. /
707	uint32_t fProt;
708	} In;
709	} u;
710	} SUPPAGEPROTECT, *PSUPPAGEPROTECT;
711	/** @} */
712
713
714	/** @name SUP_IOCTL_PAGE_FREE
715	* Free memory allocated with SUP_IOCTL_PAGE_ALLOC_EX.
716	* @{
717	*/
718	#define SUP_IOCTL_PAGE_FREE SUP_CTL_CODE_SIZE(13, SUP_IOCTL_PAGE_FREE_SIZE_IN)
719	#define SUP_IOCTL_PAGE_FREE_SIZE sizeof(SUPPAGEFREE)
720	#define SUP_IOCTL_PAGE_FREE_SIZE_IN sizeof(SUPPAGEFREE)
721	#define SUP_IOCTL_PAGE_FREE_SIZE_OUT sizeof(SUPREQHDR)
722	typedef struct SUPPAGEFREE
723	{
724	/** The header. */
725	SUPREQHDR Hdr;
726	union
727	{
728	struct
729	{
730	/** Address of memory range to free. */
731	RTR3PTR pvR3;
732	} In;
733	} u;
734	} SUPPAGEFREE, *PSUPPAGEFREE;
735	/** @} */
736
737
738
739
740	/** @name SUP_IOCTL_PAGE_LOCK
741	* Pin down physical pages.
742	* @{
743	*/
744	#define SUP_IOCTL_PAGE_LOCK SUP_CTL_CODE_BIG(14)
745	#define SUP_IOCTL_PAGE_LOCK_SIZE(cPages) (RT_MAX((size_t)SUP_IOCTL_PAGE_LOCK_SIZE_IN, (size_t)SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages)))
746	#define SUP_IOCTL_PAGE_LOCK_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGELOCK, u.In))
747	#define SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages) RT_UOFFSETOF(SUPPAGELOCK, u.Out.aPages[cPages])
748	typedef struct SUPPAGELOCK
749	{
750	/** The header. */
751	SUPREQHDR Hdr;
752	union
753	{
754	struct
755	{
756	/** Start of page range. Must be PAGE aligned. */
757	RTR3PTR pvR3;
758	/** The range size given as a page count. */
759	uint32_t cPages;
760	} In;
761
762	struct
763	{
764	/** Array of pages. */
765	RTHCPHYS aPages[1];
766	} Out;
767	} u;
768	} SUPPAGELOCK, *PSUPPAGELOCK;
769	/** @} */
770
771
772	/** @name SUP_IOCTL_PAGE_UNLOCK
773	* Unpin physical pages.
774	* @{ */
775	#define SUP_IOCTL_PAGE_UNLOCK SUP_CTL_CODE_SIZE(15, SUP_IOCTL_PAGE_UNLOCK_SIZE)
776	#define SUP_IOCTL_PAGE_UNLOCK_SIZE sizeof(SUPPAGEUNLOCK)
777	#define SUP_IOCTL_PAGE_UNLOCK_SIZE_IN sizeof(SUPPAGEUNLOCK)
778	#define SUP_IOCTL_PAGE_UNLOCK_SIZE_OUT sizeof(SUPREQHDR)
779	typedef struct SUPPAGEUNLOCK
780	{
781	/** The header. */
782	SUPREQHDR Hdr;
783	union
784	{
785	struct
786	{
787	/** Start of page range of a range previously pinned. */
788	RTR3PTR pvR3;
789	} In;
790	} u;
791	} SUPPAGEUNLOCK, *PSUPPAGEUNLOCK;
792	/** @} */
793
794
795	/** @name SUP_IOCTL_CONT_ALLOC
796	* Allocate continuous memory.
797	* @{
798	*/
799	#define SUP_IOCTL_CONT_ALLOC SUP_CTL_CODE_SIZE(16, SUP_IOCTL_CONT_ALLOC_SIZE)
800	#define SUP_IOCTL_CONT_ALLOC_SIZE sizeof(SUPCONTALLOC)
801	#define SUP_IOCTL_CONT_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCONTALLOC, u.In))
802	#define SUP_IOCTL_CONT_ALLOC_SIZE_OUT sizeof(SUPCONTALLOC)
803	typedef struct SUPCONTALLOC
804	{
805	/** The header. */
806	SUPREQHDR Hdr;
807	union
808	{
809	struct
810	{
811	/** The allocation size given as a page count. */
812	uint32_t cPages;
813	} In;
814
815	struct
816	{
817	/** The address of the ring-0 mapping of the allocated memory. */
818	RTR0PTR pvR0;
819	/** The address of the ring-3 mapping of the allocated memory. */
820	RTR3PTR pvR3;
821	/** The physical address of the allocation. */
822	RTHCPHYS HCPhys;
823	} Out;
824	} u;
825	} SUPCONTALLOC, *PSUPCONTALLOC;
826	/** @} */
827
828
829	/** @name SUP_IOCTL_CONT_FREE Input.
830	* @{
831	*/
832	/** Free continuous memory. */
833	#define SUP_IOCTL_CONT_FREE SUP_CTL_CODE_SIZE(17, SUP_IOCTL_CONT_FREE_SIZE)
834	#define SUP_IOCTL_CONT_FREE_SIZE sizeof(SUPCONTFREE)
835	#define SUP_IOCTL_CONT_FREE_SIZE_IN sizeof(SUPCONTFREE)
836	#define SUP_IOCTL_CONT_FREE_SIZE_OUT sizeof(SUPREQHDR)
837	typedef struct SUPCONTFREE
838	{
839	/** The header. */
840	SUPREQHDR Hdr;
841	union
842	{
843	struct
844	{
845	/** The ring-3 address of the memory to free. */
846	RTR3PTR pvR3;
847	} In;
848	} u;
849	} SUPCONTFREE, *PSUPCONTFREE;
850	/** @} */
851
852
853	/** @name SUP_IOCTL_GET_PAGING_MODE
854	* Get the host paging mode.
855	* @{
856	*/
857	#define SUP_IOCTL_GET_PAGING_MODE SUP_CTL_CODE_SIZE(18, SUP_IOCTL_GET_PAGING_MODE_SIZE)
858	#define SUP_IOCTL_GET_PAGING_MODE_SIZE sizeof(SUPGETPAGINGMODE)
859	#define SUP_IOCTL_GET_PAGING_MODE_SIZE_IN sizeof(SUPREQHDR)
860	#define SUP_IOCTL_GET_PAGING_MODE_SIZE_OUT sizeof(SUPGETPAGINGMODE)
861	typedef struct SUPGETPAGINGMODE
862	{
863	/** The header. */
864	SUPREQHDR Hdr;
865	union
866	{
867	struct
868	{
869	/** The paging mode. */
870	SUPPAGINGMODE enmMode;
871	} Out;
872	} u;
873	} SUPGETPAGINGMODE, *PSUPGETPAGINGMODE;
874	/** @} */
875
876
877	/** @name SUP_IOCTL_SET_VM_FOR_FAST
878	* Set the VM handle for doing fast call ioctl calls.
879	* @{
880	*/
881	#define SUP_IOCTL_SET_VM_FOR_FAST SUP_CTL_CODE_SIZE(19, SUP_IOCTL_SET_VM_FOR_FAST_SIZE)
882	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE sizeof(SUPSETVMFORFAST)
883	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_IN sizeof(SUPSETVMFORFAST)
884	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_OUT sizeof(SUPREQHDR)
885	typedef struct SUPSETVMFORFAST
886	{
887	/** The header. */
888	SUPREQHDR Hdr;
889	union
890	{
891	struct
892	{
893	/** The ring-0 VM handle (pointer). */
894	PVMR0 pVMR0;
895	} In;
896	} u;
897	} SUPSETVMFORFAST, *PSUPSETVMFORFAST;
898	/** @} */
899
900
901	/** @name SUP_IOCTL_GIP_MAP
902	* Map the GIP into user space.
903	* @{
904	*/
905	#define SUP_IOCTL_GIP_MAP SUP_CTL_CODE_SIZE(20, SUP_IOCTL_GIP_MAP_SIZE)
906	#define SUP_IOCTL_GIP_MAP_SIZE sizeof(SUPGIPMAP)
907	#define SUP_IOCTL_GIP_MAP_SIZE_IN sizeof(SUPREQHDR)
908	#define SUP_IOCTL_GIP_MAP_SIZE_OUT sizeof(SUPGIPMAP)
909	typedef struct SUPGIPMAP
910	{
911	/** The header. */
912	SUPREQHDR Hdr;
913	union
914	{
915	struct
916	{
917	/** The physical address of the GIP. */
918	RTHCPHYS HCPhysGip;
919	/** Pointer to the read-only usermode GIP mapping for this session. */
920	R3PTRTYPE(PSUPGLOBALINFOPAGE) pGipR3;
921	/** Pointer to the supervisor mode GIP mapping. */
922	R0PTRTYPE(PSUPGLOBALINFOPAGE) pGipR0;
923	} Out;
924	} u;
925	} SUPGIPMAP, *PSUPGIPMAP;
926	/** @} */
927
928
929	/** @name SUP_IOCTL_GIP_UNMAP
930	* Unmap the GIP.
931	* @{
932	*/
933	#define SUP_IOCTL_GIP_UNMAP SUP_CTL_CODE_SIZE(21, SUP_IOCTL_GIP_UNMAP_SIZE)
934	#define SUP_IOCTL_GIP_UNMAP_SIZE sizeof(SUPGIPUNMAP)
935	#define SUP_IOCTL_GIP_UNMAP_SIZE_IN sizeof(SUPGIPUNMAP)
936	#define SUP_IOCTL_GIP_UNMAP_SIZE_OUT sizeof(SUPGIPUNMAP)
937	typedef struct SUPGIPUNMAP
938	{
939	/** The header. */
940	SUPREQHDR Hdr;
941	} SUPGIPUNMAP, *PSUPGIPUNMAP;
942	/** @} */
943
944
945	/** @name SUP_IOCTL_CALL_SERVICE
946	* Call the a ring-0 service.
947	*
948	* @todo Might have to convert this to a big request, just like
949	* SUP_IOCTL_CALL_VMMR0
950	* @{
951	*/
952	#define SUP_IOCTL_CALL_SERVICE(cbReq) SUP_CTL_CODE_SIZE(22, SUP_IOCTL_CALL_SERVICE_SIZE(cbReq))
953	#define SUP_IOCTL_CALL_SERVICE_SIZE(cbReq) RT_UOFFSETOF(SUPCALLSERVICE, abReqPkt[cbReq])
954	#define SUP_IOCTL_CALL_SERVICE_SIZE_IN(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
955	#define SUP_IOCTL_CALL_SERVICE_SIZE_OUT(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
956	typedef struct SUPCALLSERVICE
957	{
958	/** The header. */
959	SUPREQHDR Hdr;
960	union
961	{
962	struct
963	{
964	/** The service name. */
965	char szName[28];
966	/** Which operation to execute. */
967	uint32_t uOperation;
968	/** Argument to use when no request packet is supplied. */
969	uint64_t u64Arg;
970	} In;
971	} u;
972	/** The request packet passed to SUP. */
973	uint8_t abReqPkt[1];
974	} SUPCALLSERVICE, *PSUPCALLSERVICE;
975	/** @} */
976
977
978	/** @name SUP_IOCTL_LOGGER_SETTINGS
979	* Changes the ring-0 release or debug logger settings.
980	* @{
981	*/
982	#define SUP_IOCTL_LOGGER_SETTINGS(cbStrTab) SUP_CTL_CODE_SIZE(23, SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab))
983	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab) RT_UOFFSETOF(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
984	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE_IN(cbStrTab) RT_UOFFSETOF(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
985	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE_OUT sizeof(SUPREQHDR)
986	typedef struct SUPLOGGERSETTINGS
987	{
988	/** The header. */
989	SUPREQHDR Hdr;
990	union
991	{
992	struct
993	{
994	/** Which logger. */
995	uint32_t fWhich;
996	/** What to do with it. */
997	uint32_t fWhat;
998	/** Offset of the flags setting string. */
999	uint32_t offFlags;
1000	/** Offset of the groups setting string. */
1001	uint32_t offGroups;
1002	/** Offset of the destination setting string. */
1003	uint32_t offDestination;
1004	/** The string table. */
1005	char szStrings[1];
1006	} In;
1007	} u;
1008	} SUPLOGGERSETTINGS, *PSUPLOGGERSETTINGS;
1009
1010	/** Debug logger. */
1011	#define SUPLOGGERSETTINGS_WHICH_DEBUG 0
1012	/** Release logger. */
1013	#define SUPLOGGERSETTINGS_WHICH_RELEASE 1
1014
1015	/** Change the settings. */
1016	#define SUPLOGGERSETTINGS_WHAT_SETTINGS 0
1017	/** Create the logger instance. */
1018	#define SUPLOGGERSETTINGS_WHAT_CREATE 1
1019	/** Destroy the logger instance. */
1020	#define SUPLOGGERSETTINGS_WHAT_DESTROY 2
1021
1022	/** @} */
1023
1024
1025	/** @name Semaphore Types
1026	* @{ */
1027	#define SUP_SEM_TYPE_EVENT 0
1028	#define SUP_SEM_TYPE_EVENT_MULTI 1
1029	/** @} */
1030
1031
1032	/** @name SUP_IOCTL_SEM_OP2
1033	* Semaphore operations.
1034	* @remarks This replaces the old SUP_IOCTL_SEM_OP interface.
1035	* @{
1036	*/
1037	#define SUP_IOCTL_SEM_OP2 SUP_CTL_CODE_SIZE(24, SUP_IOCTL_SEM_OP2_SIZE)
1038	#define SUP_IOCTL_SEM_OP2_SIZE sizeof(SUPSEMOP2)
1039	#define SUP_IOCTL_SEM_OP2_SIZE_IN sizeof(SUPSEMOP2)
1040	#define SUP_IOCTL_SEM_OP2_SIZE_OUT sizeof(SUPREQHDR)
1041	typedef struct SUPSEMOP2
1042	{
1043	/** The header. */
1044	SUPREQHDR Hdr;
1045	union
1046	{
1047	struct
1048	{
1049	/** The semaphore type. */
1050	uint32_t uType;
1051	/** The semaphore handle. */
1052	uint32_t hSem;
1053	/** The operation. */
1054	uint32_t uOp;
1055	/** Reserved, must be zero. */
1056	uint32_t uReserved;
1057	/** The number of milliseconds to wait if it's a wait operation. */
1058	union
1059	{
1060	/** Absolute timeout (RTTime[System]NanoTS).
1061	* Used by SUPSEMOP2_WAIT_NS_ABS. */
1062	uint64_t uAbsNsTimeout;
1063	/** Relative nanosecond timeout.
1064	* Used by SUPSEMOP2_WAIT_NS_REL. */
1065	uint64_t cRelNsTimeout;
1066	/** Relative millisecond timeout.
1067	* Used by SUPSEMOP2_WAIT_MS_REL. */
1068	uint32_t cRelMsTimeout;
1069	/** Generic 64-bit accessor.
1070	* ASSUMES little endian! */
1071	uint64_t u64;
1072	} uArg;
1073	} In;
1074	} u;
1075	} SUPSEMOP2, *PSUPSEMOP2;
1076
1077	/** Wait for a number of milliseconds. */
1078	#define SUPSEMOP2_WAIT_MS_REL 0
1079	/** Wait until the specified deadline is reached. */
1080	#define SUPSEMOP2_WAIT_NS_ABS 1
1081	/** Wait for a number of nanoseconds. */
1082	#define SUPSEMOP2_WAIT_NS_REL 2
1083	/** Signal the semaphore. */
1084	#define SUPSEMOP2_SIGNAL 3
1085	/** Reset the semaphore (only applicable to SUP_SEM_TYPE_EVENT_MULTI). */
1086	#define SUPSEMOP2_RESET 4
1087	/** Close the semaphore handle. */
1088	#define SUPSEMOP2_CLOSE 5
1089	/** @} */
1090
1091	/** @name SUP_IOCTL_SEM_OP3
1092	* Semaphore operations.
1093	* @{
1094	*/
1095	#define SUP_IOCTL_SEM_OP3 SUP_CTL_CODE_SIZE(25, SUP_IOCTL_SEM_OP3_SIZE)
1096	#define SUP_IOCTL_SEM_OP3_SIZE sizeof(SUPSEMOP3)
1097	#define SUP_IOCTL_SEM_OP3_SIZE_IN sizeof(SUPSEMOP3)
1098	#define SUP_IOCTL_SEM_OP3_SIZE_OUT sizeof(SUPSEMOP3)
1099	typedef struct SUPSEMOP3
1100	{
1101	/** The header. */
1102	SUPREQHDR Hdr;
1103	union
1104	{
1105	struct
1106	{
1107	/** The semaphore type. */
1108	uint32_t uType;
1109	/** The semaphore handle. */
1110	uint32_t hSem;
1111	/** The operation. */
1112	uint32_t uOp;
1113	/** Reserved, must be zero. */
1114	uint32_t u32Reserved;
1115	/** Reserved for future use. */
1116	uint64_t u64Reserved;
1117	} In;
1118	union
1119	{
1120	/** The handle of the created semaphore.
1121	* Used by SUPSEMOP3_CREATE. */
1122	uint32_t hSem;
1123	/** The semaphore resolution in nano seconds.
1124	* Used by SUPSEMOP3_GET_RESOLUTION. */
1125	uint32_t cNsResolution;
1126	/** The 32-bit view. */
1127	uint32_t u32;
1128	/** Reserved some space for later expansion. */
1129	uint64_t u64Reserved;
1130	} Out;
1131	} u;
1132	} SUPSEMOP3, *PSUPSEMOP3;
1133
1134	/** Get the wait resolution. */
1135	#define SUPSEMOP3_CREATE 0
1136	/** Get the wait resolution. */
1137	#define SUPSEMOP3_GET_RESOLUTION 1
1138	/** @} */
1139
1140	/** @name SUP_IOCTL_VT_CAPS
1141	* Get the VT-x/AMD-V capabilities.
1142	*
1143	* @todo Intended for main, which means we need to relax the privilege requires
1144	* when accessing certain vboxdrv functions.
1145	*
1146	* @{
1147	*/
1148	#define SUP_IOCTL_VT_CAPS SUP_CTL_CODE_SIZE(26, SUP_IOCTL_VT_CAPS_SIZE)
1149	#define SUP_IOCTL_VT_CAPS_SIZE sizeof(SUPVTCAPS)
1150	#define SUP_IOCTL_VT_CAPS_SIZE_IN sizeof(SUPREQHDR)
1151	#define SUP_IOCTL_VT_CAPS_SIZE_OUT sizeof(SUPVTCAPS)
1152	typedef struct SUPVTCAPS
1153	{
1154	/** The header. */
1155	SUPREQHDR Hdr;
1156	union
1157	{
1158	struct
1159	{
1160	/** The VT capability dword. */
1161	uint32_t Caps;
1162	} Out;
1163	} u;
1164	} SUPVTCAPS, *PSUPVTCAPS;
1165	/** @} */
1166
1167	#pragma pack() /* paranoia */
1168
1169	#endif
1170

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

source: vbox/trunk/src/VBox/HostDrivers/Support/SUPDrvIOC.h@ 37591

Download in other formats: