SUPDrvIOC.h@ 36293

Last change on this file since 36293 was 36262, checked in by vboxsync, 14 years ago
SUPDrv,IPRT,++: Enabled the code for supporting up to 256 host CPUs/cores/threads.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 39.2 KB

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

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

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

Download in other formats: