SUPDrvIOC.h@ 62490

Last change on this file since 62490 was 62490, checked in by vboxsync, 8 years ago
(C) 2016
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 54.3 KB

Line
1	/* $Id: SUPDrvIOC.h 62490 2016-07-22 18:41:49Z vboxsync $ */
2	/** @file
3	* VirtualBox Support Driver - IOCtl definitions.
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 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	#include <VBox/sup.h>
35
36	/*
37	* IOCtl numbers.
38	* We're using the Win32 type of numbers here, thus the macros below.
39	* The SUP_IOCTL_FLAG macro is used to separate requests from 32-bit
40	* and 64-bit processes.
41	*/
42	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_SPARC64)
43	# define SUP_IOCTL_FLAG 128
44	#elif defined(RT_ARCH_X86) \|\| defined(RT_ARCH_SPARC)
45	# define SUP_IOCTL_FLAG 0
46	#else
47	# error "dunno which arch this is!"
48	#endif
49
50	#ifdef RT_OS_WINDOWS
51	# ifndef CTL_CODE
52	# include <Windows.h>
53	# endif
54	/* Automatic buffering, size not encoded. */
55	# define SUP_CTL_CODE_SIZE(Function, Size) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) \| SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
56	# define SUP_CTL_CODE_BIG(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) \| SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
57	# define SUP_CTL_CODE_FAST(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) \| SUP_IOCTL_FLAG, METHOD_NEITHER, FILE_WRITE_ACCESS)
58	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
59
60	# define SUP_NT_STATUS_BASE UINT32_C(0xe9860000) /*< STATUS_SEVERITY_ERROR + C-bit + facility 0x986. /
61	# define SUP_NT_STATUS_IS_VBOX(a_rcNt) ( ((uint32_t)(a_rcNt) & 0xffff0000) == SUP_NT_STATUS_BASE )
62	# define SUP_NT_STATUS_TO_VBOX(a_rcNt) ( (int)((uint32_t)(a_rcNt) \| UINT32_C(0xffff0000)) )
63
64	/** NT device name for system access. */
65	# define SUPDRV_NT_DEVICE_NAME_SYS L"\\Device\\VBoxDrv"
66	/** NT device name for user access. */
67	# define SUPDRV_NT_DEVICE_NAME_USR L"\\Device\\VBoxDrvU"
68	# ifdef VBOX_WITH_HARDENING
69	/** NT device name for hardened stub access. */
70	# define SUPDRV_NT_DEVICE_NAME_STUB L"\\Device\\VBoxDrvStub"
71	/** NT device name for getting error information for failed VBoxDrv or
72	* VBoxDrvStub open. */
73	# define SUPDRV_NT_DEVICE_NAME_ERROR_INFO L"\\Device\\VBoxDrvErrorInfo"
74	# endif
75
76
77	#elif defined(RT_OS_SOLARIS)
78	/* No automatic buffering, size limited to 255 bytes. */
79	# include <sys/ioccom.h>
80	# define SUP_CTL_CODE_SIZE(Function, Size) _IOWRN('V', (Function) \| SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
81	# define SUP_CTL_CODE_BIG(Function) _IOWRN('V', (Function) \| SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
82	# define SUP_CTL_CODE_FAST(Function) _IO( 'V', (Function) \| SUP_IOCTL_FLAG)
83	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
84
85	#elif defined(RT_OS_OS2)
86	/* No automatic buffering, size not encoded. */
87	# define SUP_CTL_CATEGORY 0xc0
88	# define SUP_CTL_CODE_SIZE(Function, Size) ((unsigned char)(Function))
89	# define SUP_CTL_CODE_BIG(Function) ((unsigned char)(Function))
90	# define SUP_CTL_CATEGORY_FAST 0xc1
91	# define SUP_CTL_CODE_FAST(Function) ((unsigned char)(Function))
92	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
93
94	#elif defined(RT_OS_LINUX)
95	/* No automatic buffering, size limited to 16KB. */
96	# include <linux/ioctl.h>
97	# define SUP_CTL_CODE_SIZE(Function, Size) _IOC(_IOC_READ \| _IOC_WRITE, 'V', (Function) \| SUP_IOCTL_FLAG, (Size))
98	# define SUP_CTL_CODE_BIG(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
99	# define SUP_CTL_CODE_FAST(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
100	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) ((uIOCtl) & ~IOCSIZE_MASK)
101
102	#elif defined(RT_OS_L4)
103	/* Implemented in suplib, no worries. */
104	# define SUP_CTL_CODE_SIZE(Function, Size) (Function)
105	# define SUP_CTL_CODE_BIG(Function) (Function)
106	# define SUP_CTL_CODE_FAST(Function) (Function)
107	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
108
109	#else /* BSD Like */
110	/* Automatic buffering, size limited to 4KB on BSD and 8KB on Darwin - commands the limit, 4KB. /
111	# include <sys/ioccom.h>
112	# define SUP_CTL_CODE_SIZE(Function, Size) _IOC(IOC_INOUT, 'V', (Function) \| SUP_IOCTL_FLAG, (Size))
113	# define SUP_CTL_CODE_BIG(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
114	# define SUP_CTL_CODE_FAST(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
115	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) ( (uIOCtl) & ~_IOC(0,0,0,IOCPARM_MASK) )
116	#endif
117
118	/** Fast path IOCtl: VMMR0_DO_RAW_RUN */
119	#define SUP_IOCTL_FAST_DO_RAW_RUN SUP_CTL_CODE_FAST(64)
120	/** Fast path IOCtl: VMMR0_DO_HM_RUN */
121	#define SUP_IOCTL_FAST_DO_HM_RUN SUP_CTL_CODE_FAST(65)
122	/** Just a NOP call for profiling the latency of a fast ioctl call to VMMR0. */
123	#define SUP_IOCTL_FAST_DO_NOP SUP_CTL_CODE_FAST(66)
124
125	#ifdef RT_OS_DARWIN
126	/** Cookie used to fend off some unwanted clients to the IOService. */
127	# define SUP_DARWIN_IOSERVICE_COOKIE 0x64726962 /* 'bird' */
128	#endif
129
130
131	/*******************************************************************************
132	* Structures and Typedefs *
133	*******************************************************************************/
134	#ifdef RT_ARCH_AMD64
135	# pragma pack(8) /* paranoia. */
136	#else
137	# pragma pack(4) /* paranoia. */
138	#endif
139
140
141	/**
142	* Common In/Out header.
143	*/
144	typedef struct SUPREQHDR
145	{
146	/** Cookie. */
147	uint32_t u32Cookie;
148	/** Session cookie. */
149	uint32_t u32SessionCookie;
150	/** The size of the input. */
151	uint32_t cbIn;
152	/** The size of the output. */
153	uint32_t cbOut;
154	/** Flags. See SUPREQHDR_FLAGS_* for details and values. */
155	uint32_t fFlags;
156	/** The VBox status code of the operation, out direction only. */
157	int32_t rc;
158	} SUPREQHDR;
159	/** Pointer to a IOC header. */
160	typedef SUPREQHDR *PSUPREQHDR;
161
162	/** @name SUPREQHDR::fFlags values
163	* @{ */
164	/** Masks out the magic value. */
165	#define SUPREQHDR_FLAGS_MAGIC_MASK UINT32_C(0xff0000ff)
166	/** The generic mask. */
167	#define SUPREQHDR_FLAGS_GEN_MASK UINT32_C(0x0000ff00)
168	/** The request specific mask. */
169	#define SUPREQHDR_FLAGS_REQ_MASK UINT32_C(0x00ff0000)
170
171	/** There is extra input that needs copying on some platforms. */
172	#define SUPREQHDR_FLAGS_EXTRA_IN UINT32_C(0x00000100)
173	/** There is extra output that needs copying on some platforms. */
174	#define SUPREQHDR_FLAGS_EXTRA_OUT UINT32_C(0x00000200)
175
176	/** The magic value. */
177	#define SUPREQHDR_FLAGS_MAGIC UINT32_C(0x42000042)
178	/** The default value. Use this when no special stuff is requested. */
179	#define SUPREQHDR_FLAGS_DEFAULT SUPREQHDR_FLAGS_MAGIC
180	/** @} */
181
182
183	/** @name SUP_IOCTL_COOKIE
184	* @{
185	*/
186	/** Negotiate cookie. */
187	#define SUP_IOCTL_COOKIE SUP_CTL_CODE_SIZE(1, SUP_IOCTL_COOKIE_SIZE)
188	/** The request size. */
189	#define SUP_IOCTL_COOKIE_SIZE sizeof(SUPCOOKIE)
190	/** The SUPREQHDR::cbIn value. */
191	#define SUP_IOCTL_COOKIE_SIZE_IN sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.In)
192	/** The SUPREQHDR::cbOut value. */
193	#define SUP_IOCTL_COOKIE_SIZE_OUT sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.Out)
194	/** SUPCOOKIE_IN magic word. */
195	#define SUPCOOKIE_MAGIC "The Magic Word!"
196	/** The initial cookie. */
197	#define SUPCOOKIE_INITIAL_COOKIE 0x69726f74 /* 'tori' */
198
199	/** Current interface version.
200	* The upper 16-bit is the major version, the lower the minor version.
201	* When incompatible changes are made, the upper major number has to be changed.
202	*
203	* Update rules:
204	* -# Only update the major number when incompatible changes have been made to
205	* the IOC interface or the ABI provided via the functions returned by
206	* SUPQUERYFUNCS.
207	* -# When adding new features (new IOC number, new flags, new exports, ++)
208	* only update the minor number and change SUPLib.cpp to require the
209	* new IOC version.
210	* -# When incrementing the major number, clear the minor part and reset
211	* any IOC version requirements in SUPLib.cpp.
212	* -# When increment the major number, execute all pending work.
213	*
214	* @todo Pending work on next major version change:
215	* - nothing.
216	*/
217	#define SUPDRV_IOC_VERSION 0x00260000
218
219	/** SUP_IOCTL_COOKIE. */
220	typedef struct SUPCOOKIE
221	{
222	/** The header.
223	* u32Cookie must be set to SUPCOOKIE_INITIAL_COOKIE.
224	* u32SessionCookie should be set to some random value. */
225	SUPREQHDR Hdr;
226	union
227	{
228	struct
229	{
230	/** Magic word. */
231	char szMagic[16];
232	/** The requested interface version number. */
233	uint32_t u32ReqVersion;
234	/** The minimum interface version number. */
235	uint32_t u32MinVersion;
236	} In;
237	struct
238	{
239	/** Cookie. */
240	uint32_t u32Cookie;
241	/** Session cookie. */
242	uint32_t u32SessionCookie;
243	/** Interface version for this session. */
244	uint32_t u32SessionVersion;
245	/** The actual interface version in the driver. */
246	uint32_t u32DriverVersion;
247	/** Number of functions available for the SUP_IOCTL_QUERY_FUNCS request. */
248	uint32_t cFunctions;
249	/** Session handle. */
250	R0PTRTYPE(PSUPDRVSESSION) pSession;
251	} Out;
252	} u;
253	} SUPCOOKIE, *PSUPCOOKIE;
254	/** @} */
255
256
257	/** @name SUP_IOCTL_QUERY_FUNCS
258	* Query SUPR0 functions.
259	* @{
260	*/
261	#define SUP_IOCTL_QUERY_FUNCS(cFuncs) SUP_CTL_CODE_BIG(2)
262	#define SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs) RT_UOFFSETOF(SUPQUERYFUNCS, u.Out.aFunctions[(cFuncs)])
263	#define SUP_IOCTL_QUERY_FUNCS_SIZE_IN sizeof(SUPREQHDR)
264	#define SUP_IOCTL_QUERY_FUNCS_SIZE_OUT(cFuncs) SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs)
265
266	/** A function. */
267	typedef struct SUPFUNC
268	{
269	/** Name - mangled. */
270	char szName[32];
271	/** Address. */
272	RTR0PTR pfn;
273	} SUPFUNC, *PSUPFUNC;
274
275	typedef struct SUPQUERYFUNCS
276	{
277	/** The header. */
278	SUPREQHDR Hdr;
279	union
280	{
281	struct
282	{
283	/** Number of functions returned. */
284	uint32_t cFunctions;
285	/** Array of functions. */
286	SUPFUNC aFunctions[1];
287	} Out;
288	} u;
289	} SUPQUERYFUNCS, *PSUPQUERYFUNCS;
290	/** @} */
291
292
293	/** @name SUP_IOCTL_LDR_OPEN
294	* Open an image.
295	* @{
296	*/
297	#define SUP_IOCTL_LDR_OPEN SUP_CTL_CODE_SIZE(3, SUP_IOCTL_LDR_OPEN_SIZE)
298	#define SUP_IOCTL_LDR_OPEN_SIZE sizeof(SUPLDROPEN)
299	#define SUP_IOCTL_LDR_OPEN_SIZE_IN sizeof(SUPLDROPEN)
300	#define SUP_IOCTL_LDR_OPEN_SIZE_OUT (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDROPEN, u.Out))
301	typedef struct SUPLDROPEN
302	{
303	/** The header. */
304	SUPREQHDR Hdr;
305	union
306	{
307	struct
308	{
309	/** Size of the image we'll be loading (including tables). */
310	uint32_t cbImageWithTabs;
311	/** The size of the image bits. (Less or equal to cbImageWithTabs.) */
312	uint32_t cbImageBits;
313	/** Image name.
314	* This is the NAME of the image, not the file name. It is used
315	* to share code with other processes. (Max len is 32 chars!) */
316	char szName[32];
317	/** Image file name.
318	* This can be used to load the image using a native loader. */
319	char szFilename[260];
320	} In;
321	struct
322	{
323	/** The base address of the image. */
324	RTR0PTR pvImageBase;
325	/** Indicate whether or not the image requires loading. */
326	bool fNeedsLoading;
327	/** Indicates that we're using the native ring-0 loader. */
328	bool fNativeLoader;
329	} Out;
330	} u;
331	} SUPLDROPEN, *PSUPLDROPEN;
332	/** @} */
333
334
335	/** @name SUP_IOCTL_LDR_LOAD
336	* Upload the image bits.
337	* @{
338	*/
339	#define SUP_IOCTL_LDR_LOAD SUP_CTL_CODE_BIG(4)
340	#define SUP_IOCTL_LDR_LOAD_SIZE(cbImage) RT_MAX(RT_UOFFSETOF(SUPLDRLOAD, u.In.abImage[cbImage]), SUP_IOCTL_LDR_LOAD_SIZE_OUT)
341	#define SUP_IOCTL_LDR_LOAD_SIZE_IN(cbImage) RT_UOFFSETOF(SUPLDRLOAD, u.In.abImage[cbImage])
342	#define SUP_IOCTL_LDR_LOAD_SIZE_OUT (RT_UOFFSETOF(SUPLDRLOAD, u.Out.szError) + RT_SIZEOFMEMB(SUPLDRLOAD, u.Out.szError))
343
344	/**
345	* Module initialization callback function.
346	* This is called once after the module has been loaded.
347	*
348	* @returns 0 on success.
349	* @returns Appropriate error code on failure.
350	* @param hMod Image handle for use in APIs.
351	*/
352	typedef DECLCALLBACK(int) FNR0MODULEINIT(void *hMod);
353	/** Pointer to a FNR0MODULEINIT(). */
354	typedef R0PTRTYPE(FNR0MODULEINIT *) PFNR0MODULEINIT;
355
356	/**
357	* Module termination callback function.
358	* This is called once right before the module is being unloaded.
359	*
360	* @param hMod Image handle for use in APIs.
361	*/
362	typedef DECLCALLBACK(void) FNR0MODULETERM(void *hMod);
363	/** Pointer to a FNR0MODULETERM(). */
364	typedef R0PTRTYPE(FNR0MODULETERM *) PFNR0MODULETERM;
365
366	/**
367	* Symbol table entry.
368	*/
369	typedef struct SUPLDRSYM
370	{
371	/** Offset into of the string table. */
372	uint32_t offName;
373	/** Offset of the symbol relative to the image load address.
374	* @remarks When used inside the SUPDrv to calculate real addresses, it
375	* must be cast to int32_t for the sake of native loader support
376	* on Solaris. (The loader puts the and data in different
377	* memory areans, and the text one is generally higher.) */
378	uint32_t offSymbol;
379	} SUPLDRSYM;
380	/** Pointer to a symbol table entry. */
381	typedef SUPLDRSYM *PSUPLDRSYM;
382	/** Pointer to a const symbol table entry. */
383	typedef SUPLDRSYM const *PCSUPLDRSYM;
384
385	/**
386	* SUPLDRLOAD::u::In::EP type.
387	*/
388	typedef enum SUPLDRLOADEP
389	{
390	SUPLDRLOADEP_NOTHING = 0,
391	SUPLDRLOADEP_VMMR0,
392	SUPLDRLOADEP_SERVICE,
393	SUPLDRLOADEP_32BIT_HACK = 0x7fffffff
394	} SUPLDRLOADEP;
395
396	typedef struct SUPLDRLOAD
397	{
398	/** The header. */
399	SUPREQHDR Hdr;
400	union
401	{
402	struct
403	{
404	/** The address of module initialization function. Similar to _DLL_InitTerm(hmod, 0). */
405	RTR0PTR pfnModuleInit;
406	/** The address of module termination function. Similar to _DLL_InitTerm(hmod, 1). */
407	RTR0PTR pfnModuleTerm;
408	/** Special entry points. */
409	union
410	{
411	/** SUPLDRLOADEP_VMMR0. */
412	struct
413	{
414	/** The module handle (i.e. address). */
415	RTR0PTR pvVMMR0;
416	/** Address of VMMR0EntryFast function. */
417	RTR0PTR pvVMMR0EntryFast;
418	/** Address of VMMR0EntryEx function. */
419	RTR0PTR pvVMMR0EntryEx;
420	} VMMR0;
421	/** SUPLDRLOADEP_SERVICE. */
422	struct
423	{
424	/** The service request handler.
425	* (PFNR0SERVICEREQHANDLER isn't defined yet.) */
426	RTR0PTR pfnServiceReq;
427	/** Reserved, must be NIL. */
428	RTR0PTR apvReserved[3];
429	} Service;
430	} EP;
431	/** Address. */
432	RTR0PTR pvImageBase;
433	/** Entry point type. */
434	SUPLDRLOADEP eEPType;
435	/** The size of the image bits (starting at offset 0 and
436	* approaching offSymbols). */
437	uint32_t cbImageBits;
438	/** The offset of the symbol table. */
439	uint32_t offSymbols;
440	/** The number of entries in the symbol table. */
441	uint32_t cSymbols;
442	/** The offset of the string table. */
443	uint32_t offStrTab;
444	/** Size of the string table. */
445	uint32_t cbStrTab;
446	/** Size of image data in achImage. */
447	uint32_t cbImageWithTabs;
448	/** The image data. */
449	uint8_t abImage[1];
450	} In;
451	struct
452	{
453	/** Magic value indicating whether extended error information is
454	* present or not (SUPLDRLOAD_ERROR_MAGIC). */
455	uint64_t uErrorMagic;
456	/** Extended error information. */
457	char szError[2048];
458	} Out;
459	} u;
460	} SUPLDRLOAD, *PSUPLDRLOAD;
461	/** Magic value that indicates that there is a valid error information string
462	* present on SUP_IOCTL_LDR_LOAD failure.
463	* @remarks The value is choosen to be an unlikely init and term address. */
464	#define SUPLDRLOAD_ERROR_MAGIC UINT64_C(0xabcdefef0feddcb9)
465	/** @} */
466
467
468	/** @name SUP_IOCTL_LDR_FREE
469	* Free an image.
470	* @{
471	*/
472	#define SUP_IOCTL_LDR_FREE SUP_CTL_CODE_SIZE(5, SUP_IOCTL_LDR_FREE_SIZE)
473	#define SUP_IOCTL_LDR_FREE_SIZE sizeof(SUPLDRFREE)
474	#define SUP_IOCTL_LDR_FREE_SIZE_IN sizeof(SUPLDRFREE)
475	#define SUP_IOCTL_LDR_FREE_SIZE_OUT sizeof(SUPREQHDR)
476	typedef struct SUPLDRFREE
477	{
478	/** The header. */
479	SUPREQHDR Hdr;
480	union
481	{
482	struct
483	{
484	/** Address. */
485	RTR0PTR pvImageBase;
486	} In;
487	} u;
488	} SUPLDRFREE, *PSUPLDRFREE;
489	/** @} */
490
491
492	/** @name SUP_IOCTL_LDR_LOCK_DOWN
493	* Lock down the image loader interface.
494	* @{
495	*/
496	#define SUP_IOCTL_LDR_LOCK_DOWN SUP_CTL_CODE_SIZE(38, SUP_IOCTL_LDR_LOCK_DOWN_SIZE)
497	#define SUP_IOCTL_LDR_LOCK_DOWN_SIZE sizeof(SUPREQHDR)
498	#define SUP_IOCTL_LDR_LOCK_DOWN_SIZE_IN sizeof(SUPREQHDR)
499	#define SUP_IOCTL_LDR_LOCK_DOWN_SIZE_OUT sizeof(SUPREQHDR)
500	/** @} */
501
502
503	/** @name SUP_IOCTL_LDR_GET_SYMBOL
504	* Get address of a symbol within an image.
505	* @{
506	*/
507	#define SUP_IOCTL_LDR_GET_SYMBOL SUP_CTL_CODE_SIZE(6, SUP_IOCTL_LDR_GET_SYMBOL_SIZE)
508	#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE sizeof(SUPLDRGETSYMBOL)
509	#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_IN sizeof(SUPLDRGETSYMBOL)
510	#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_OUT (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDRGETSYMBOL, u.Out))
511	typedef struct SUPLDRGETSYMBOL
512	{
513	/** The header. */
514	SUPREQHDR Hdr;
515	union
516	{
517	struct
518	{
519	/** Address. */
520	RTR0PTR pvImageBase;
521	/** The symbol name. */
522	char szSymbol[64];
523	} In;
524	struct
525	{
526	/** The symbol address. */
527	RTR0PTR pvSymbol;
528	} Out;
529	} u;
530	} SUPLDRGETSYMBOL, *PSUPLDRGETSYMBOL;
531	/** @} */
532
533
534	/** @name SUP_IOCTL_CALL_VMMR0
535	* Call the R0 VMM Entry point.
536	* @{
537	*/
538	#define SUP_IOCTL_CALL_VMMR0(cbReq) SUP_CTL_CODE_SIZE(7, SUP_IOCTL_CALL_VMMR0_SIZE(cbReq))
539	#define SUP_IOCTL_CALL_VMMR0_NO_SIZE() SUP_CTL_CODE_SIZE(7, 0)
540	#define SUP_IOCTL_CALL_VMMR0_SIZE(cbReq) RT_UOFFSETOF(SUPCALLVMMR0, abReqPkt[cbReq])
541	#define SUP_IOCTL_CALL_VMMR0_SIZE_IN(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
542	#define SUP_IOCTL_CALL_VMMR0_SIZE_OUT(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
543	typedef struct SUPCALLVMMR0
544	{
545	/** The header. */
546	SUPREQHDR Hdr;
547	union
548	{
549	struct
550	{
551	/** The VM handle. */
552	PVMR0 pVMR0;
553	/** VCPU id. */
554	uint32_t idCpu;
555	/** Which operation to execute. */
556	uint32_t uOperation;
557	/** Argument to use when no request packet is supplied. */
558	uint64_t u64Arg;
559	} In;
560	} u;
561	/** The VMMR0Entry request packet. */
562	uint8_t abReqPkt[1];
563	} SUPCALLVMMR0, *PSUPCALLVMMR0;
564	/** @} */
565
566
567	/** @name SUP_IOCTL_CALL_VMMR0_BIG
568	* Version of SUP_IOCTL_CALL_VMMR0 for dealing with large requests.
569	* @{
570	*/
571	#define SUP_IOCTL_CALL_VMMR0_BIG SUP_CTL_CODE_BIG(27)
572	#define SUP_IOCTL_CALL_VMMR0_BIG_SIZE(cbReq) RT_UOFFSETOF(SUPCALLVMMR0, abReqPkt[cbReq])
573	#define SUP_IOCTL_CALL_VMMR0_BIG_SIZE_IN(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
574	#define SUP_IOCTL_CALL_VMMR0_BIG_SIZE_OUT(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
575	/** @} */
576
577
578	/** @name SUP_IOCTL_LOW_ALLOC
579	* Allocate memory below 4GB (physically).
580	* @{
581	*/
582	#define SUP_IOCTL_LOW_ALLOC SUP_CTL_CODE_BIG(8)
583	#define SUP_IOCTL_LOW_ALLOC_SIZE(cPages) ((uint32_t)RT_UOFFSETOF(SUPLOWALLOC, u.Out.aPages[cPages]))
584	#define SUP_IOCTL_LOW_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLOWALLOC, u.In))
585	#define SUP_IOCTL_LOW_ALLOC_SIZE_OUT(cPages) SUP_IOCTL_LOW_ALLOC_SIZE(cPages)
586	typedef struct SUPLOWALLOC
587	{
588	/** The header. */
589	SUPREQHDR Hdr;
590	union
591	{
592	struct
593	{
594	/** Number of pages to allocate. */
595	uint32_t cPages;
596	} In;
597	struct
598	{
599	/** The ring-3 address of the allocated memory. */
600	RTR3PTR pvR3;
601	/** The ring-0 address of the allocated memory. */
602	RTR0PTR pvR0;
603	/** Array of pages. */
604	RTHCPHYS aPages[1];
605	} Out;
606	} u;
607	} SUPLOWALLOC, *PSUPLOWALLOC;
608	/** @} */
609
610
611	/** @name SUP_IOCTL_LOW_FREE
612	* Free low memory.
613	* @{
614	*/
615	#define SUP_IOCTL_LOW_FREE SUP_CTL_CODE_SIZE(9, SUP_IOCTL_LOW_FREE_SIZE)
616	#define SUP_IOCTL_LOW_FREE_SIZE sizeof(SUPLOWFREE)
617	#define SUP_IOCTL_LOW_FREE_SIZE_IN sizeof(SUPLOWFREE)
618	#define SUP_IOCTL_LOW_FREE_SIZE_OUT sizeof(SUPREQHDR)
619	typedef struct SUPLOWFREE
620	{
621	/** The header. */
622	SUPREQHDR Hdr;
623	union
624	{
625	struct
626	{
627	/** The ring-3 address of the memory to free. */
628	RTR3PTR pvR3;
629	} In;
630	} u;
631	} SUPLOWFREE, *PSUPLOWFREE;
632	/** @} */
633
634
635	/** @name SUP_IOCTL_PAGE_ALLOC_EX
636	* Allocate memory and map it into kernel and/or user space. The memory is of
637	* course locked. The result should be freed using SUP_IOCTL_PAGE_FREE.
638	*
639	* @remarks Allocations without a kernel mapping may fail with
640	* VERR_NOT_SUPPORTED on some platforms.
641	*
642	* @{
643	*/
644	#define SUP_IOCTL_PAGE_ALLOC_EX SUP_CTL_CODE_BIG(10)
645	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages) RT_UOFFSETOF(SUPPAGEALLOCEX, u.Out.aPages[cPages])
646	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGEALLOCEX, u.In))
647	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_OUT(cPages) SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages)
648	typedef struct SUPPAGEALLOCEX
649	{
650	/** The header. */
651	SUPREQHDR Hdr;
652	union
653	{
654	struct
655	{
656	/** Number of pages to allocate */
657	uint32_t cPages;
658	/** Whether it should have kernel mapping. */
659	bool fKernelMapping;
660	/** Whether it should have a user mapping. */
661	bool fUserMapping;
662	/** Reserved. Must be false. */
663	bool fReserved0;
664	/** Reserved. Must be false. */
665	bool fReserved1;
666	} In;
667	struct
668	{
669	/** Returned ring-3 address. */
670	RTR3PTR pvR3;
671	/** Returned ring-0 address. */
672	RTR0PTR pvR0;
673	/** The physical addresses of the allocated pages. */
674	RTHCPHYS aPages[1];
675	} Out;
676	} u;
677	} SUPPAGEALLOCEX, *PSUPPAGEALLOCEX;
678	/** @} */
679
680
681	/** @name SUP_IOCTL_PAGE_MAP_KERNEL
682	* Maps a portion of memory allocated by SUP_IOCTL_PAGE_ALLOC_EX /
683	* SUPR0PageAllocEx into kernel space for use by a device or similar.
684	*
685	* The mapping will be freed together with the ring-3 mapping when
686	* SUP_IOCTL_PAGE_FREE or SUPR0PageFree is called.
687	*
688	* @remarks Not necessarily supported on all platforms.
689	*
690	* @{
691	*/
692	#define SUP_IOCTL_PAGE_MAP_KERNEL SUP_CTL_CODE_SIZE(11, SUP_IOCTL_PAGE_MAP_KERNEL_SIZE)
693	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE sizeof(SUPPAGEMAPKERNEL)
694	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_IN sizeof(SUPPAGEMAPKERNEL)
695	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_OUT sizeof(SUPPAGEMAPKERNEL)
696	typedef struct SUPPAGEMAPKERNEL
697	{
698	/** The header. */
699	SUPREQHDR Hdr;
700	union
701	{
702	struct
703	{
704	/** The pointer of to the previously allocated memory. */
705	RTR3PTR pvR3;
706	/** The offset to start mapping from. */
707	uint32_t offSub;
708	/** Size of the section to map. */
709	uint32_t cbSub;
710	/** Flags reserved for future fun. */
711	uint32_t fFlags;
712	} In;
713	struct
714	{
715	/** The ring-0 address corresponding to pvR3 + offSub. */
716	RTR0PTR pvR0;
717	} Out;
718	} u;
719	} SUPPAGEMAPKERNEL, *PSUPPAGEMAPKERNEL;
720	/** @} */
721
722
723	/** @name SUP_IOCTL_PAGE_PROTECT
724	* Changes the page level protection of the user and/or kernel mappings of
725	* memory previously allocated by SUPR0PageAllocEx.
726	*
727	* @remarks Not necessarily supported on all platforms.
728	*
729	* @{
730	*/
731	#define SUP_IOCTL_PAGE_PROTECT SUP_CTL_CODE_SIZE(12, SUP_IOCTL_PAGE_PROTECT_SIZE)
732	#define SUP_IOCTL_PAGE_PROTECT_SIZE sizeof(SUPPAGEPROTECT)
733	#define SUP_IOCTL_PAGE_PROTECT_SIZE_IN sizeof(SUPPAGEPROTECT)
734	#define SUP_IOCTL_PAGE_PROTECT_SIZE_OUT sizeof(SUPPAGEPROTECT)
735	typedef struct SUPPAGEPROTECT
736	{
737	/** The header. */
738	SUPREQHDR Hdr;
739	union
740	{
741	struct
742	{
743	/** The pointer of to the previously allocated memory.
744	* Pass NIL_RTR3PTR if the ring-0 mapping should remain unaffected. */
745	RTR3PTR pvR3;
746	/** The pointer of to the previously allocated memory.
747	* Pass NIL_RTR0PTR if the ring-0 mapping should remain unaffected. */
748	RTR0PTR pvR0;
749	/** The offset to start changing protection at. */
750	uint32_t offSub;
751	/** Size of the portion that should be changed. */
752	uint32_t cbSub;
753	/** Protection flags, RTMEM_PROT_. /
754	uint32_t fProt;
755	} In;
756	} u;
757	} SUPPAGEPROTECT, *PSUPPAGEPROTECT;
758	/** @} */
759
760
761	/** @name SUP_IOCTL_PAGE_FREE
762	* Free memory allocated with SUP_IOCTL_PAGE_ALLOC_EX.
763	* @{
764	*/
765	#define SUP_IOCTL_PAGE_FREE SUP_CTL_CODE_SIZE(13, SUP_IOCTL_PAGE_FREE_SIZE_IN)
766	#define SUP_IOCTL_PAGE_FREE_SIZE sizeof(SUPPAGEFREE)
767	#define SUP_IOCTL_PAGE_FREE_SIZE_IN sizeof(SUPPAGEFREE)
768	#define SUP_IOCTL_PAGE_FREE_SIZE_OUT sizeof(SUPREQHDR)
769	typedef struct SUPPAGEFREE
770	{
771	/** The header. */
772	SUPREQHDR Hdr;
773	union
774	{
775	struct
776	{
777	/** Address of memory range to free. */
778	RTR3PTR pvR3;
779	} In;
780	} u;
781	} SUPPAGEFREE, *PSUPPAGEFREE;
782	/** @} */
783
784
785
786
787	/** @name SUP_IOCTL_PAGE_LOCK
788	* Pin down physical pages.
789	* @{
790	*/
791	#define SUP_IOCTL_PAGE_LOCK SUP_CTL_CODE_BIG(14)
792	#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)))
793	#define SUP_IOCTL_PAGE_LOCK_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGELOCK, u.In))
794	#define SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages) RT_UOFFSETOF(SUPPAGELOCK, u.Out.aPages[cPages])
795	typedef struct SUPPAGELOCK
796	{
797	/** The header. */
798	SUPREQHDR Hdr;
799	union
800	{
801	struct
802	{
803	/** Start of page range. Must be PAGE aligned. */
804	RTR3PTR pvR3;
805	/** The range size given as a page count. */
806	uint32_t cPages;
807	} In;
808
809	struct
810	{
811	/** Array of pages. */
812	RTHCPHYS aPages[1];
813	} Out;
814	} u;
815	} SUPPAGELOCK, *PSUPPAGELOCK;
816	/** @} */
817
818
819	/** @name SUP_IOCTL_PAGE_UNLOCK
820	* Unpin physical pages.
821	* @{ */
822	#define SUP_IOCTL_PAGE_UNLOCK SUP_CTL_CODE_SIZE(15, SUP_IOCTL_PAGE_UNLOCK_SIZE)
823	#define SUP_IOCTL_PAGE_UNLOCK_SIZE sizeof(SUPPAGEUNLOCK)
824	#define SUP_IOCTL_PAGE_UNLOCK_SIZE_IN sizeof(SUPPAGEUNLOCK)
825	#define SUP_IOCTL_PAGE_UNLOCK_SIZE_OUT sizeof(SUPREQHDR)
826	typedef struct SUPPAGEUNLOCK
827	{
828	/** The header. */
829	SUPREQHDR Hdr;
830	union
831	{
832	struct
833	{
834	/** Start of page range of a range previously pinned. */
835	RTR3PTR pvR3;
836	} In;
837	} u;
838	} SUPPAGEUNLOCK, *PSUPPAGEUNLOCK;
839	/** @} */
840
841
842	/** @name SUP_IOCTL_CONT_ALLOC
843	* Allocate continuous memory.
844	* @{
845	*/
846	#define SUP_IOCTL_CONT_ALLOC SUP_CTL_CODE_SIZE(16, SUP_IOCTL_CONT_ALLOC_SIZE)
847	#define SUP_IOCTL_CONT_ALLOC_SIZE sizeof(SUPCONTALLOC)
848	#define SUP_IOCTL_CONT_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCONTALLOC, u.In))
849	#define SUP_IOCTL_CONT_ALLOC_SIZE_OUT sizeof(SUPCONTALLOC)
850	typedef struct SUPCONTALLOC
851	{
852	/** The header. */
853	SUPREQHDR Hdr;
854	union
855	{
856	struct
857	{
858	/** The allocation size given as a page count. */
859	uint32_t cPages;
860	} In;
861
862	struct
863	{
864	/** The address of the ring-0 mapping of the allocated memory. */
865	RTR0PTR pvR0;
866	/** The address of the ring-3 mapping of the allocated memory. */
867	RTR3PTR pvR3;
868	/** The physical address of the allocation. */
869	RTHCPHYS HCPhys;
870	} Out;
871	} u;
872	} SUPCONTALLOC, *PSUPCONTALLOC;
873	/** @} */
874
875
876	/** @name SUP_IOCTL_CONT_FREE Input.
877	* @{
878	*/
879	/** Free continuous memory. */
880	#define SUP_IOCTL_CONT_FREE SUP_CTL_CODE_SIZE(17, SUP_IOCTL_CONT_FREE_SIZE)
881	#define SUP_IOCTL_CONT_FREE_SIZE sizeof(SUPCONTFREE)
882	#define SUP_IOCTL_CONT_FREE_SIZE_IN sizeof(SUPCONTFREE)
883	#define SUP_IOCTL_CONT_FREE_SIZE_OUT sizeof(SUPREQHDR)
884	typedef struct SUPCONTFREE
885	{
886	/** The header. */
887	SUPREQHDR Hdr;
888	union
889	{
890	struct
891	{
892	/** The ring-3 address of the memory to free. */
893	RTR3PTR pvR3;
894	} In;
895	} u;
896	} SUPCONTFREE, *PSUPCONTFREE;
897	/** @} */
898
899
900	/** @name SUP_IOCTL_GET_PAGING_MODE
901	* Get the host paging mode.
902	* @{
903	*/
904	#define SUP_IOCTL_GET_PAGING_MODE SUP_CTL_CODE_SIZE(18, SUP_IOCTL_GET_PAGING_MODE_SIZE)
905	#define SUP_IOCTL_GET_PAGING_MODE_SIZE sizeof(SUPGETPAGINGMODE)
906	#define SUP_IOCTL_GET_PAGING_MODE_SIZE_IN sizeof(SUPREQHDR)
907	#define SUP_IOCTL_GET_PAGING_MODE_SIZE_OUT sizeof(SUPGETPAGINGMODE)
908	typedef struct SUPGETPAGINGMODE
909	{
910	/** The header. */
911	SUPREQHDR Hdr;
912	union
913	{
914	struct
915	{
916	/** The paging mode. */
917	SUPPAGINGMODE enmMode;
918	} Out;
919	} u;
920	} SUPGETPAGINGMODE, *PSUPGETPAGINGMODE;
921	/** @} */
922
923
924	/** @name SUP_IOCTL_SET_VM_FOR_FAST
925	* Set the VM handle for doing fast call ioctl calls.
926	* @{
927	*/
928	#define SUP_IOCTL_SET_VM_FOR_FAST SUP_CTL_CODE_SIZE(19, SUP_IOCTL_SET_VM_FOR_FAST_SIZE)
929	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE sizeof(SUPSETVMFORFAST)
930	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_IN sizeof(SUPSETVMFORFAST)
931	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_OUT sizeof(SUPREQHDR)
932	typedef struct SUPSETVMFORFAST
933	{
934	/** The header. */
935	SUPREQHDR Hdr;
936	union
937	{
938	struct
939	{
940	/** The ring-0 VM handle (pointer). */
941	PVMR0 pVMR0;
942	} In;
943	} u;
944	} SUPSETVMFORFAST, *PSUPSETVMFORFAST;
945	/** @} */
946
947
948	/** @name SUP_IOCTL_GIP_MAP
949	* Map the GIP into user space.
950	* @{
951	*/
952	#define SUP_IOCTL_GIP_MAP SUP_CTL_CODE_SIZE(20, SUP_IOCTL_GIP_MAP_SIZE)
953	#define SUP_IOCTL_GIP_MAP_SIZE sizeof(SUPGIPMAP)
954	#define SUP_IOCTL_GIP_MAP_SIZE_IN sizeof(SUPREQHDR)
955	#define SUP_IOCTL_GIP_MAP_SIZE_OUT sizeof(SUPGIPMAP)
956	typedef struct SUPGIPMAP
957	{
958	/** The header. */
959	SUPREQHDR Hdr;
960	union
961	{
962	struct
963	{
964	/** The physical address of the GIP. */
965	RTHCPHYS HCPhysGip;
966	/** Pointer to the read-only usermode GIP mapping for this session. */
967	R3PTRTYPE(PSUPGLOBALINFOPAGE) pGipR3;
968	/** Pointer to the supervisor mode GIP mapping. */
969	R0PTRTYPE(PSUPGLOBALINFOPAGE) pGipR0;
970	} Out;
971	} u;
972	} SUPGIPMAP, *PSUPGIPMAP;
973	/** @} */
974
975
976	/** @name SUP_IOCTL_GIP_UNMAP
977	* Unmap the GIP.
978	* @{
979	*/
980	#define SUP_IOCTL_GIP_UNMAP SUP_CTL_CODE_SIZE(21, SUP_IOCTL_GIP_UNMAP_SIZE)
981	#define SUP_IOCTL_GIP_UNMAP_SIZE sizeof(SUPGIPUNMAP)
982	#define SUP_IOCTL_GIP_UNMAP_SIZE_IN sizeof(SUPGIPUNMAP)
983	#define SUP_IOCTL_GIP_UNMAP_SIZE_OUT sizeof(SUPGIPUNMAP)
984	typedef struct SUPGIPUNMAP
985	{
986	/** The header. */
987	SUPREQHDR Hdr;
988	} SUPGIPUNMAP, *PSUPGIPUNMAP;
989	/** @} */
990
991
992	/** @name SUP_IOCTL_CALL_SERVICE
993	* Call the a ring-0 service.
994	*
995	* @todo Might have to convert this to a big request, just like
996	* SUP_IOCTL_CALL_VMMR0
997	* @{
998	*/
999	#define SUP_IOCTL_CALL_SERVICE(cbReq) SUP_CTL_CODE_SIZE(22, SUP_IOCTL_CALL_SERVICE_SIZE(cbReq))
1000	#define SUP_IOCTL_CALL_SERVICE_NO_SIZE() SUP_CTL_CODE_SIZE(22, 0)
1001	#define SUP_IOCTL_CALL_SERVICE_SIZE(cbReq) RT_UOFFSETOF(SUPCALLSERVICE, abReqPkt[cbReq])
1002	#define SUP_IOCTL_CALL_SERVICE_SIZE_IN(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
1003	#define SUP_IOCTL_CALL_SERVICE_SIZE_OUT(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
1004	typedef struct SUPCALLSERVICE
1005	{
1006	/** The header. */
1007	SUPREQHDR Hdr;
1008	union
1009	{
1010	struct
1011	{
1012	/** The service name. */
1013	char szName[28];
1014	/** Which operation to execute. */
1015	uint32_t uOperation;
1016	/** Argument to use when no request packet is supplied. */
1017	uint64_t u64Arg;
1018	} In;
1019	} u;
1020	/** The request packet passed to SUP. */
1021	uint8_t abReqPkt[1];
1022	} SUPCALLSERVICE, *PSUPCALLSERVICE;
1023	/** @} */
1024
1025
1026	/** @name SUP_IOCTL_LOGGER_SETTINGS
1027	* Changes the ring-0 release or debug logger settings.
1028	* @{
1029	*/
1030	#define SUP_IOCTL_LOGGER_SETTINGS(cbStrTab) SUP_CTL_CODE_SIZE(23, SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab))
1031	#define SUP_IOCTL_LOGGER_SETTINGS_NO_SIZE() SUP_CTL_CODE_SIZE(23, 0)
1032	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab) RT_UOFFSETOF(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
1033	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE_IN(cbStrTab) RT_UOFFSETOF(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
1034	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE_OUT sizeof(SUPREQHDR)
1035	typedef struct SUPLOGGERSETTINGS
1036	{
1037	/** The header. */
1038	SUPREQHDR Hdr;
1039	union
1040	{
1041	struct
1042	{
1043	/** Which logger. */
1044	uint32_t fWhich;
1045	/** What to do with it. */
1046	uint32_t fWhat;
1047	/** Offset of the flags setting string. */
1048	uint32_t offFlags;
1049	/** Offset of the groups setting string. */
1050	uint32_t offGroups;
1051	/** Offset of the destination setting string. */
1052	uint32_t offDestination;
1053	/** The string table. */
1054	char szStrings[1];
1055	} In;
1056	} u;
1057	} SUPLOGGERSETTINGS, *PSUPLOGGERSETTINGS;
1058
1059	/** Debug logger. */
1060	#define SUPLOGGERSETTINGS_WHICH_DEBUG 0
1061	/** Release logger. */
1062	#define SUPLOGGERSETTINGS_WHICH_RELEASE 1
1063
1064	/** Change the settings. */
1065	#define SUPLOGGERSETTINGS_WHAT_SETTINGS 0
1066	/** Create the logger instance. */
1067	#define SUPLOGGERSETTINGS_WHAT_CREATE 1
1068	/** Destroy the logger instance. */
1069	#define SUPLOGGERSETTINGS_WHAT_DESTROY 2
1070
1071	/** @} */
1072
1073
1074	/** @name Semaphore Types
1075	* @{ */
1076	#define SUP_SEM_TYPE_EVENT 0
1077	#define SUP_SEM_TYPE_EVENT_MULTI 1
1078	/** @} */
1079
1080
1081	/** @name SUP_IOCTL_SEM_OP2
1082	* Semaphore operations.
1083	* @remarks This replaces the old SUP_IOCTL_SEM_OP interface.
1084	* @{
1085	*/
1086	#define SUP_IOCTL_SEM_OP2 SUP_CTL_CODE_SIZE(24, SUP_IOCTL_SEM_OP2_SIZE)
1087	#define SUP_IOCTL_SEM_OP2_SIZE sizeof(SUPSEMOP2)
1088	#define SUP_IOCTL_SEM_OP2_SIZE_IN sizeof(SUPSEMOP2)
1089	#define SUP_IOCTL_SEM_OP2_SIZE_OUT sizeof(SUPREQHDR)
1090	typedef struct SUPSEMOP2
1091	{
1092	/** The header. */
1093	SUPREQHDR Hdr;
1094	union
1095	{
1096	struct
1097	{
1098	/** The semaphore type. */
1099	uint32_t uType;
1100	/** The semaphore handle. */
1101	uint32_t hSem;
1102	/** The operation. */
1103	uint32_t uOp;
1104	/** Reserved, must be zero. */
1105	uint32_t uReserved;
1106	/** The number of milliseconds to wait if it's a wait operation. */
1107	union
1108	{
1109	/** Absolute timeout (RTTime[System]NanoTS).
1110	* Used by SUPSEMOP2_WAIT_NS_ABS. */
1111	uint64_t uAbsNsTimeout;
1112	/** Relative nanosecond timeout.
1113	* Used by SUPSEMOP2_WAIT_NS_REL. */
1114	uint64_t cRelNsTimeout;
1115	/** Relative millisecond timeout.
1116	* Used by SUPSEMOP2_WAIT_MS_REL. */
1117	uint32_t cRelMsTimeout;
1118	/** Generic 64-bit accessor.
1119	* ASSUMES little endian! */
1120	uint64_t u64;
1121	} uArg;
1122	} In;
1123	} u;
1124	} SUPSEMOP2, *PSUPSEMOP2;
1125
1126	/** Wait for a number of milliseconds. */
1127	#define SUPSEMOP2_WAIT_MS_REL 0
1128	/** Wait until the specified deadline is reached. */
1129	#define SUPSEMOP2_WAIT_NS_ABS 1
1130	/** Wait for a number of nanoseconds. */
1131	#define SUPSEMOP2_WAIT_NS_REL 2
1132	/** Signal the semaphore. */
1133	#define SUPSEMOP2_SIGNAL 3
1134	/** Reset the semaphore (only applicable to SUP_SEM_TYPE_EVENT_MULTI). */
1135	#define SUPSEMOP2_RESET 4
1136	/** Close the semaphore handle. */
1137	#define SUPSEMOP2_CLOSE 5
1138	/** @} */
1139
1140
1141	/** @name SUP_IOCTL_SEM_OP3
1142	* Semaphore operations.
1143	* @{
1144	*/
1145	#define SUP_IOCTL_SEM_OP3 SUP_CTL_CODE_SIZE(25, SUP_IOCTL_SEM_OP3_SIZE)
1146	#define SUP_IOCTL_SEM_OP3_SIZE sizeof(SUPSEMOP3)
1147	#define SUP_IOCTL_SEM_OP3_SIZE_IN sizeof(SUPSEMOP3)
1148	#define SUP_IOCTL_SEM_OP3_SIZE_OUT sizeof(SUPSEMOP3)
1149	typedef struct SUPSEMOP3
1150	{
1151	/** The header. */
1152	SUPREQHDR Hdr;
1153	union
1154	{
1155	struct
1156	{
1157	/** The semaphore type. */
1158	uint32_t uType;
1159	/** The semaphore handle. */
1160	uint32_t hSem;
1161	/** The operation. */
1162	uint32_t uOp;
1163	/** Reserved, must be zero. */
1164	uint32_t u32Reserved;
1165	/** Reserved for future use. */
1166	uint64_t u64Reserved;
1167	} In;
1168	union
1169	{
1170	/** The handle of the created semaphore.
1171	* Used by SUPSEMOP3_CREATE. */
1172	uint32_t hSem;
1173	/** The semaphore resolution in nano seconds.
1174	* Used by SUPSEMOP3_GET_RESOLUTION. */
1175	uint32_t cNsResolution;
1176	/** The 32-bit view. */
1177	uint32_t u32;
1178	/** Reserved some space for later expansion. */
1179	uint64_t u64Reserved;
1180	} Out;
1181	} u;
1182	} SUPSEMOP3, *PSUPSEMOP3;
1183
1184	/** Get the wait resolution. */
1185	#define SUPSEMOP3_CREATE 0
1186	/** Get the wait resolution. */
1187	#define SUPSEMOP3_GET_RESOLUTION 1
1188	/** @} */
1189
1190
1191	/** @name SUP_IOCTL_VT_CAPS
1192	* Get the VT-x/AMD-V capabilities.
1193	*
1194	* @todo Intended for main, which means we need to relax the privilege requires
1195	* when accessing certain vboxdrv functions.
1196	*
1197	* @{
1198	*/
1199	#define SUP_IOCTL_VT_CAPS SUP_CTL_CODE_SIZE(26, SUP_IOCTL_VT_CAPS_SIZE)
1200	#define SUP_IOCTL_VT_CAPS_SIZE sizeof(SUPVTCAPS)
1201	#define SUP_IOCTL_VT_CAPS_SIZE_IN sizeof(SUPREQHDR)
1202	#define SUP_IOCTL_VT_CAPS_SIZE_OUT sizeof(SUPVTCAPS)
1203	typedef struct SUPVTCAPS
1204	{
1205	/** The header. */
1206	SUPREQHDR Hdr;
1207	union
1208	{
1209	struct
1210	{
1211	/** The VT capability dword. */
1212	uint32_t Caps;
1213	} Out;
1214	} u;
1215	} SUPVTCAPS, *PSUPVTCAPS;
1216	/** @} */
1217
1218
1219	/** @name SUP_IOCTL_TRACER_OPEN
1220	* Open the tracer.
1221	*
1222	* Should be matched by an SUP_IOCTL_TRACER_CLOSE call.
1223	*
1224	* @{
1225	*/
1226	#define SUP_IOCTL_TRACER_OPEN SUP_CTL_CODE_SIZE(28, SUP_IOCTL_TRACER_OPEN_SIZE)
1227	#define SUP_IOCTL_TRACER_OPEN_SIZE sizeof(SUPTRACEROPEN)
1228	#define SUP_IOCTL_TRACER_OPEN_SIZE_IN sizeof(SUPTRACEROPEN)
1229	#define SUP_IOCTL_TRACER_OPEN_SIZE_OUT sizeof(SUPREQHDR)
1230	typedef struct SUPTRACEROPEN
1231	{
1232	/** The header. */
1233	SUPREQHDR Hdr;
1234	union
1235	{
1236	struct
1237	{
1238	/** Tracer cookie. Used to make sure we only open a matching tracer. */
1239	uint32_t uCookie;
1240	/** Tracer specific argument. */
1241	RTHCUINTPTR uArg;
1242	} In;
1243	} u;
1244	} SUPTRACEROPEN, *PSUPTRACEROPEN;
1245	/** @} */
1246
1247
1248	/** @name SUP_IOCTL_TRACER_CLOSE
1249	* Close the tracer.
1250	*
1251	* Must match a SUP_IOCTL_TRACER_OPEN call.
1252	*
1253	* @{
1254	*/
1255	#define SUP_IOCTL_TRACER_CLOSE SUP_CTL_CODE_SIZE(29, SUP_IOCTL_TRACER_CLOSE_SIZE)
1256	#define SUP_IOCTL_TRACER_CLOSE_SIZE sizeof(SUPREQHDR)
1257	#define SUP_IOCTL_TRACER_CLOSE_SIZE_IN sizeof(SUPREQHDR)
1258	#define SUP_IOCTL_TRACER_CLOSE_SIZE_OUT sizeof(SUPREQHDR)
1259	/** @} */
1260
1261
1262	/** @name SUP_IOCTL_TRACER_IOCTL
1263	* Speak UNIX ioctl() with the tracer.
1264	*
1265	* The session must have opened the tracer prior to issuing this request.
1266	*
1267	* @{
1268	*/
1269	#define SUP_IOCTL_TRACER_IOCTL SUP_CTL_CODE_SIZE(30, SUP_IOCTL_TRACER_IOCTL_SIZE)
1270	#define SUP_IOCTL_TRACER_IOCTL_SIZE sizeof(SUPTRACERIOCTL)
1271	#define SUP_IOCTL_TRACER_IOCTL_SIZE_IN sizeof(SUPTRACERIOCTL)
1272	#define SUP_IOCTL_TRACER_IOCTL_SIZE_OUT (RT_UOFFSETOF(SUPTRACERIOCTL, u.Out.iRetVal) + sizeof(int32_t))
1273	typedef struct SUPTRACERIOCTL
1274	{
1275	/** The header. */
1276	SUPREQHDR Hdr;
1277	union
1278	{
1279	struct
1280	{
1281	/** The command. */
1282	RTHCUINTPTR uCmd;
1283	/** Argument to the command. */
1284	RTHCUINTPTR uArg;
1285	} In;
1286
1287	struct
1288	{
1289	/** The return value. */
1290	int32_t iRetVal;
1291	} Out;
1292	} u;
1293	} SUPTRACERIOCTL, *PSUPTRACERIOCTL;
1294	/** @} */
1295
1296
1297	/** @name SUP_IOCTL_TRACER_UMOD_REG
1298	* Registers tracepoints in a user mode module.
1299	*
1300	* @{
1301	*/
1302	#define SUP_IOCTL_TRACER_UMOD_REG SUP_CTL_CODE_SIZE(31, SUP_IOCTL_TRACER_UMOD_REG_SIZE)
1303	#define SUP_IOCTL_TRACER_UMOD_REG_SIZE sizeof(SUPTRACERUMODREG)
1304	#define SUP_IOCTL_TRACER_UMOD_REG_SIZE_IN sizeof(SUPTRACERUMODREG)
1305	#define SUP_IOCTL_TRACER_UMOD_REG_SIZE_OUT sizeof(SUPREQHDR)
1306	typedef struct SUPTRACERUMODREG
1307	{
1308	/** The header. */
1309	SUPREQHDR Hdr;
1310	union
1311	{
1312	struct
1313	{
1314	/** The address at which the VTG header actually resides.
1315	* This will differ from R3PtrVtgHdr for raw-mode context
1316	* modules. */
1317	RTUINTPTR uVtgHdrAddr;
1318	/** The ring-3 pointer of the VTG header. */
1319	RTR3PTR R3PtrVtgHdr;
1320	/** The ring-3 pointer of the probe location string table. */
1321	RTR3PTR R3PtrStrTab;
1322	/** The size of the string table. */
1323	uint32_t cbStrTab;
1324	/** Future flags, MBZ. */
1325	uint32_t fFlags;
1326	/** The module name. */
1327	char szName[64];
1328	} In;
1329	} u;
1330	} SUPTRACERUMODREG, *PSUPTRACERUMODREG;
1331	/** @} */
1332
1333
1334	/** @name SUP_IOCTL_TRACER_UMOD_DEREG
1335	* Deregisters tracepoints in a user mode module.
1336	*
1337	* @{
1338	*/
1339	#define SUP_IOCTL_TRACER_UMOD_DEREG SUP_CTL_CODE_SIZE(32, SUP_IOCTL_TRACER_UMOD_DEREG_SIZE)
1340	#define SUP_IOCTL_TRACER_UMOD_DEREG_SIZE sizeof(SUPTRACERUMODDEREG)
1341	#define SUP_IOCTL_TRACER_UMOD_DEREG_SIZE_IN sizeof(SUPTRACERUMODDEREG)
1342	#define SUP_IOCTL_TRACER_UMOD_DEREG_SIZE_OUT sizeof(SUPREQHDR)
1343	typedef struct SUPTRACERUMODDEREG
1344	{
1345	/** The header. */
1346	SUPREQHDR Hdr;
1347	union
1348	{
1349	struct
1350	{
1351	/** Pointer to the VTG header. */
1352	RTR3PTR pVtgHdr;
1353	} In;
1354	} u;
1355	} SUPTRACERUMODDEREG, *PSUPTRACERUMODDEREG;
1356	/** @} */
1357
1358
1359	/** @name SUP_IOCTL_TRACER_UMOD_FIRE_PROBE
1360	* Fire a probe in a user tracepoint module.
1361	*
1362	* @{
1363	*/
1364	#define SUP_IOCTL_TRACER_UMOD_FIRE_PROBE SUP_CTL_CODE_SIZE(33, SUP_IOCTL_TRACER_UMOD_FIRE_PROBE_SIZE)
1365	#define SUP_IOCTL_TRACER_UMOD_FIRE_PROBE_SIZE sizeof(SUPTRACERUMODFIREPROBE)
1366	#define SUP_IOCTL_TRACER_UMOD_FIRE_PROBE_SIZE_IN sizeof(SUPTRACERUMODFIREPROBE)
1367	#define SUP_IOCTL_TRACER_UMOD_FIRE_PROBE_SIZE_OUT sizeof(SUPREQHDR)
1368	typedef struct SUPTRACERUMODFIREPROBE
1369	{
1370	/** The header. */
1371	SUPREQHDR Hdr;
1372	union
1373	{
1374	SUPDRVTRACERUSRCTX In;
1375	} u;
1376	} SUPTRACERUMODFIREPROBE, *PSUPTRACERUMODFIREPROBE;
1377	/** @} */
1378
1379
1380	/** @name SUP_IOCTL_MSR_PROBER
1381	* MSR probing interface, not available in normal builds.
1382	*
1383	* @{
1384	*/
1385	#define SUP_IOCTL_MSR_PROBER SUP_CTL_CODE_SIZE(34, SUP_IOCTL_MSR_PROBER_SIZE)
1386	#define SUP_IOCTL_MSR_PROBER_SIZE sizeof(SUPMSRPROBER)
1387	#define SUP_IOCTL_MSR_PROBER_SIZE_IN sizeof(SUPMSRPROBER)
1388	#define SUP_IOCTL_MSR_PROBER_SIZE_OUT sizeof(SUPMSRPROBER)
1389
1390	typedef enum SUPMSRPROBEROP
1391	{
1392	SUPMSRPROBEROP_INVALID = 0, /*< The customary invalid zero value. /
1393	SUPMSRPROBEROP_READ, /*< Read an MSR. /
1394	SUPMSRPROBEROP_WRITE, /*< Write a value to an MSR (use with care!). /
1395	SUPMSRPROBEROP_MODIFY, /*< Read-modify-restore-flushall. /
1396	SUPMSRPROBEROP_MODIFY_FASTER, /*< Read-modify-restore, skip the flushing. /
1397	SUPMSRPROBEROP_END, /*< End of valid values. /
1398	SUPMSRPROBEROP_32BIT_HACK = 0x7fffffff /*< The customary 32-bit type hack. /
1399	} SUPMSRPROBEROP;
1400
1401	typedef struct SUPMSRPROBER
1402	{
1403	/** The header. */
1404	SUPREQHDR Hdr;
1405
1406	/** Input/output union. */
1407	union
1408	{
1409	/** Inputs. */
1410	struct
1411	{
1412	/** The operation. */
1413	SUPMSRPROBEROP enmOp;
1414	/** The MSR to test. */
1415	uint32_t uMsr;
1416	/** The CPU to perform the operation on.
1417	* Use UINT32_MAX to indicate that any CPU will do. */
1418	uint32_t idCpu;
1419	/** Alignment padding. */
1420	uint32_t u32Padding;
1421	/** Operation specific arguments. */
1422	union
1423	{
1424	/* SUPMSRPROBEROP_READ takes no extra arguments. */
1425
1426	/** For SUPMSRPROBEROP_WRITE. */
1427	struct
1428	{
1429	/** The value to write. */
1430	uint64_t uToWrite;
1431	} Write;
1432
1433	/** For SUPMSRPROBEROP_MODIFY and SUPMSRPROBEROP_MODIFY_FASTER. */
1434	struct
1435	{
1436	/** The value to AND the current MSR value with to construct the value to
1437	* write. This applied first. */
1438	uint64_t fAndMask;
1439	/** The value to OR the result of the above mentioned AND operation with
1440	* attempting to modify the MSR. */
1441	uint64_t fOrMask;
1442	} Modify;
1443
1444	/** Reserve space for the future. */
1445	uint64_t auPadding[3];
1446	} uArgs;
1447	} In;
1448
1449	/** Outputs. */
1450	struct
1451	{
1452	/** Operation specific results. */
1453	union
1454	{
1455	/** For SUPMSRPROBEROP_READ. */
1456	struct
1457	{
1458	/** The value we've read. */
1459	uint64_t uValue;
1460	/** Set if we GPed while reading it. */
1461	bool fGp;
1462	} Read;
1463
1464	/** For SUPMSRPROBEROP_WRITE. */
1465	struct
1466	{
1467	/** Set if we GPed while writing it. */
1468	bool fGp;
1469	} Write;
1470
1471	/** For SUPMSRPROBEROP_MODIFY and SUPMSRPROBEROP_MODIFY_FASTER. */
1472	SUPMSRPROBERMODIFYRESULT Modify;
1473
1474	/** Size padding/aligning. */
1475	uint64_t auPadding[5];
1476	} uResults;
1477	} Out;
1478	} u;
1479	} SUPMSRPROBER, *PSUPMSRPROBER;
1480	AssertCompileMemberAlignment(SUPMSRPROBER, u, 8);
1481	AssertCompileMemberAlignment(SUPMSRPROBER, u.In.uArgs, 8);
1482	AssertCompileMembersSameSizeAndOffset(SUPMSRPROBER, u.In, SUPMSRPROBER, u.Out);
1483	/** @} */
1484
1485	/** @name SUP_IOCTL_RESUME_SUSPENDED_KBDS
1486	* Resume suspended keyboard devices if any found in the system.
1487	*
1488	* @{
1489	*/
1490	#define SUP_IOCTL_RESUME_SUSPENDED_KBDS SUP_CTL_CODE_SIZE(35, SUP_IOCTL_RESUME_SUSPENDED_KBDS_SIZE)
1491	#define SUP_IOCTL_RESUME_SUSPENDED_KBDS_SIZE sizeof(SUPREQHDR)
1492	#define SUP_IOCTL_RESUME_SUSPENDED_KBDS_SIZE_IN sizeof(SUPREQHDR)
1493	#define SUP_IOCTL_RESUME_SUSPENDED_KBDS_SIZE_OUT sizeof(SUPREQHDR)
1494	/** @} */
1495
1496
1497	/** @name SUP_IOCTL_TSC_DELTA_MEASURE
1498	* Measure the TSC-delta between the specified CPU and the master TSC.
1499	*
1500	* To call this I/O control, the client must first have mapped the GIP.
1501	*
1502	* @{
1503	*/
1504	#define SUP_IOCTL_TSC_DELTA_MEASURE SUP_CTL_CODE_SIZE(36, SUP_IOCTL_TSC_DELTA_MEASURE_SIZE)
1505	#define SUP_IOCTL_TSC_DELTA_MEASURE_SIZE sizeof(SUPTSCDELTAMEASURE)
1506	#define SUP_IOCTL_TSC_DELTA_MEASURE_SIZE_IN sizeof(SUPTSCDELTAMEASURE)
1507	#define SUP_IOCTL_TSC_DELTA_MEASURE_SIZE_OUT sizeof(SUPREQHDR)
1508	typedef struct SUPTSCDELTAMEASURE
1509	{
1510	/** The header. */
1511	SUPREQHDR Hdr;
1512
1513	/** Input/output union. */
1514	union
1515	{
1516	struct
1517	{
1518	/** Which CPU to take the TSC-delta measurement for. */
1519	RTCPUID idCpu;
1520	/** Number of times to retry on failure (specify 0 for default). */
1521	uint8_t cRetries;
1522	/** Number of milliseconds to wait before each retry. */
1523	uint8_t cMsWaitRetry;
1524	/** Whether to force taking a measurement if one exists already. */
1525	bool fForce;
1526	/** Whether to do the measurement asynchronously (if possible). */
1527	bool fAsync;
1528	} In;
1529	} u;
1530	} SUPTSCDELTAMEASURE, *PSUPTSCDELTAMEASURE;
1531	AssertCompileMemberAlignment(SUPTSCDELTAMEASURE, u, 8);
1532	AssertCompileSize(SUPTSCDELTAMEASURE, 6*4 + 4+1+1+1+1);
1533	/** @} */
1534
1535
1536	/** @name SUP_IOCTL_TSC_READ
1537	* Reads the TSC and apply TSC-delta if applicable, determining the delta if
1538	* necessary (i64TSCDelta = INT64_MAX).
1539	*
1540	* This latter function is the primary use case of this I/O control. To call
1541	* this I/O control, the client must first have mapped the GIP.
1542	*
1543	* @{
1544	*/
1545	#define SUP_IOCTL_TSC_READ SUP_CTL_CODE_SIZE(37, SUP_IOCTL_TSC_READ_SIZE)
1546	#define SUP_IOCTL_TSC_READ_SIZE sizeof(SUPTSCREAD)
1547	#define SUP_IOCTL_TSC_READ_SIZE_IN sizeof(SUPREQHDR)
1548	#define SUP_IOCTL_TSC_READ_SIZE_OUT sizeof(SUPTSCREAD)
1549	typedef struct SUPTSCREAD
1550	{
1551	/** The header. */
1552	SUPREQHDR Hdr;
1553
1554	/** Input/output union. */
1555	union
1556	{
1557	struct
1558	{
1559	/** The TSC after applying the relevant delta. */
1560	uint64_t u64AdjustedTsc;
1561	/** The APIC Id of the CPU where the TSC was read. */
1562	uint16_t idApic;
1563	/** Explicit alignment padding. */
1564	uint16_t auPadding[3];
1565	} Out;
1566	} u;
1567	} SUPTSCREAD, *PSUPTSCREAD;
1568	AssertCompileMemberAlignment(SUPTSCREAD, u, 8);
1569	AssertCompileSize(SUPTSCREAD, 64 + 28);
1570	/** @} */
1571
1572
1573	/** @name SUP_IOCTL_GIP_SET_FLAGS
1574	* Set GIP flags.
1575	*
1576	* @{
1577	*/
1578	#define SUP_IOCTL_GIP_SET_FLAGS SUP_CTL_CODE_SIZE(39, SUP_IOCTL_GIP_SET_FLAGS_SIZE)
1579	#define SUP_IOCTL_GIP_SET_FLAGS_SIZE sizeof(SUPGIPSETFLAGS)
1580	#define SUP_IOCTL_GIP_SET_FLAGS_SIZE_IN sizeof(SUPGIPSETFLAGS)
1581	#define SUP_IOCTL_GIP_SET_FLAGS_SIZE_OUT sizeof(SUPREQHDR)
1582	typedef struct SUPGIPSETFLAGS
1583	{
1584	/** The header. */
1585	SUPREQHDR Hdr;
1586	union
1587	{
1588	struct
1589	{
1590	/** The AND flags mask, see SUPGIP_FLAGS_XXX. */
1591	uint32_t fAndMask;
1592	/** The OR flags mask, see SUPGIP_FLAGS_XXX. */
1593	uint32_t fOrMask;
1594	} In;
1595	} u;
1596	} SUPGIPSETFLAGS, *PSUPGIPSETFLAGS;
1597	/** @} */
1598
1599	#pragma pack() /* paranoia */
1600
1601	#endif
1602

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

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

Download in other formats: