SUPDrvIOC.h@ 28545

Last change on this file since 28545 was 27617, checked in by vboxsync, 15 years ago
SUPDrvIOC.h: More sparc (just to make the VBoxRT deps build).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 37.0 KB

Line
1	/* $Revision: 27617 $ */
2	/** @file
3	* VirtualBox Support Driver - IOCtl definitions.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27	* Clara, CA 95054 USA or visit http://www.sun.com if you need
28	* additional information or have any questions.
29	*/
30
31	#ifndef ___SUPDrvIOC_h___
32	#define ___SUPDrvIOC_h___
33
34	/*
35	* Basic types.
36	*/
37	#include <iprt/types.h>
38
39	/*
40	* IOCtl numbers.
41	* We're using the Win32 type of numbers here, thus the macros below.
42	* The SUP_IOCTL_FLAG macro is used to separate requests from 32-bit
43	* and 64-bit processes.
44	*/
45	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_SPARC64)
46	# define SUP_IOCTL_FLAG 128
47	#elif defined(RT_ARCH_X86) \|\| defined(RT_ARCH_SPARC)
48	# define SUP_IOCTL_FLAG 0
49	#else
50	# error "dunno which arch this is!"
51	#endif
52
53	#ifdef RT_OS_WINDOWS
54	# ifndef CTL_CODE
55	# include <Windows.h>
56	# endif
57	/* Automatic buffering, size not encoded. */
58	# define SUP_CTL_CODE_SIZE(Function, Size) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) \| SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
59	# define SUP_CTL_CODE_BIG(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) \| SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
60	# define SUP_CTL_CODE_FAST(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) \| SUP_IOCTL_FLAG, METHOD_NEITHER, FILE_WRITE_ACCESS)
61	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
62
63	#elif defined(RT_OS_SOLARIS)
64	/* No automatic buffering, size limited to 255 bytes. */
65	# include <sys/ioccom.h>
66	# define SUP_CTL_CODE_SIZE(Function, Size) _IOWRN('V', (Function) \| SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
67	# define SUP_CTL_CODE_BIG(Function) _IOWRN('V', (Function) \| SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
68	# define SUP_CTL_CODE_FAST(Function) _IO( 'V', (Function) \| SUP_IOCTL_FLAG)
69	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
70
71	#elif defined(RT_OS_OS2)
72	/* No automatic buffering, size not encoded. */
73	# define SUP_CTL_CATEGORY 0xc0
74	# define SUP_CTL_CODE_SIZE(Function, Size) ((unsigned char)(Function))
75	# define SUP_CTL_CODE_BIG(Function) ((unsigned char)(Function))
76	# define SUP_CTL_CATEGORY_FAST 0xc1
77	# define SUP_CTL_CODE_FAST(Function) ((unsigned char)(Function))
78	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
79
80	#elif defined(RT_OS_LINUX)
81	/* No automatic buffering, size limited to 16KB. */
82	# include <linux/ioctl.h>
83	# define SUP_CTL_CODE_SIZE(Function, Size) _IOC(_IOC_READ \| _IOC_WRITE, 'V', (Function) \| SUP_IOCTL_FLAG, (Size))
84	# define SUP_CTL_CODE_BIG(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
85	# define SUP_CTL_CODE_FAST(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
86	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) ((uIOCtl) & ~IOCSIZE_MASK)
87
88	#elif defined(RT_OS_L4)
89	/* Implemented in suplib, no worries. */
90	# define SUP_CTL_CODE_SIZE(Function, Size) (Function)
91	# define SUP_CTL_CODE_BIG(Function) (Function)
92	# define SUP_CTL_CODE_FAST(Function) (Function)
93	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
94
95	#else /* BSD Like */
96	/* Automatic buffering, size limited to 4KB on BSD and 8KB on Darwin - commands the limit, 4KB. /
97	# include <sys/ioccom.h>
98	# define SUP_CTL_CODE_SIZE(Function, Size) _IOC(IOC_INOUT, 'V', (Function) \| SUP_IOCTL_FLAG, (Size))
99	# define SUP_CTL_CODE_BIG(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
100	# define SUP_CTL_CODE_FAST(Function) _IO('V', (Function) \| SUP_IOCTL_FLAG)
101	# define SUP_CTL_CODE_NO_SIZE(uIOCtl) ( (uIOCtl) & ~_IOC(0,0,0,IOCPARM_MASK) )
102	#endif
103
104	/** Fast path IOCtl: VMMR0_DO_RAW_RUN */
105	#define SUP_IOCTL_FAST_DO_RAW_RUN SUP_CTL_CODE_FAST(64)
106	/** Fast path IOCtl: VMMR0_DO_HWACC_RUN */
107	#define SUP_IOCTL_FAST_DO_HWACC_RUN SUP_CTL_CODE_FAST(65)
108	/** Just a NOP call for profiling the latency of a fast ioctl call to VMMR0. */
109	#define SUP_IOCTL_FAST_DO_NOP SUP_CTL_CODE_FAST(66)
110
111
112
113	/*******************************************************************************
114	* Structures and Typedefs *
115	*******************************************************************************/
116	#ifdef RT_ARCH_AMD64
117	# pragma pack(8) /* paranoia. */
118	#else
119	# pragma pack(4) /* paranoia. */
120	#endif
121
122
123	/**
124	* Common In/Out header.
125	*/
126	typedef struct SUPREQHDR
127	{
128	/** Cookie. */
129	uint32_t u32Cookie;
130	/** Session cookie. */
131	uint32_t u32SessionCookie;
132	/** The size of the input. */
133	uint32_t cbIn;
134	/** The size of the output. */
135	uint32_t cbOut;
136	/** Flags. See SUPREQHDR_FLAGS_* for details and values. */
137	uint32_t fFlags;
138	/** The VBox status code of the operation, out direction only. */
139	int32_t rc;
140	} SUPREQHDR;
141	/** Pointer to a IOC header. */
142	typedef SUPREQHDR *PSUPREQHDR;
143
144	/** @name SUPREQHDR::fFlags values
145	* @{ */
146	/** Masks out the magic value. */
147	#define SUPREQHDR_FLAGS_MAGIC_MASK UINT32_C(0xff0000ff)
148	/** The generic mask. */
149	#define SUPREQHDR_FLAGS_GEN_MASK UINT32_C(0x0000ff00)
150	/** The request specific mask. */
151	#define SUPREQHDR_FLAGS_REQ_MASK UINT32_C(0x00ff0000)
152
153	/** There is extra input that needs copying on some platforms. */
154	#define SUPREQHDR_FLAGS_EXTRA_IN UINT32_C(0x00000100)
155	/** There is extra output that needs copying on some platforms. */
156	#define SUPREQHDR_FLAGS_EXTRA_OUT UINT32_C(0x00000200)
157
158	/** The magic value. */
159	#define SUPREQHDR_FLAGS_MAGIC UINT32_C(0x42000042)
160	/** The default value. Use this when no special stuff is requested. */
161	#define SUPREQHDR_FLAGS_DEFAULT SUPREQHDR_FLAGS_MAGIC
162	/** @} */
163
164
165	/** @name SUP_IOCTL_COOKIE
166	* @{
167	*/
168	/** Negotiate cookie. */
169	#define SUP_IOCTL_COOKIE SUP_CTL_CODE_SIZE(1, SUP_IOCTL_COOKIE_SIZE)
170	/** The request size. */
171	#define SUP_IOCTL_COOKIE_SIZE sizeof(SUPCOOKIE)
172	/** The SUPREQHDR::cbIn value. */
173	#define SUP_IOCTL_COOKIE_SIZE_IN sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.In)
174	/** The SUPREQHDR::cbOut value. */
175	#define SUP_IOCTL_COOKIE_SIZE_OUT sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.Out)
176	/** SUPCOOKIE_IN magic word. */
177	#define SUPCOOKIE_MAGIC "The Magic Word!"
178	/** The initial cookie. */
179	#define SUPCOOKIE_INITIAL_COOKIE 0x69726f74 /* 'tori' */
180
181	/** Current interface version.
182	* The upper 16-bit is the major version, the the lower the minor version.
183	* When incompatible changes are made, the upper major number has to be changed.
184	*
185	* Update rules:
186	* -# Only update the major number when incompatible changes have been made to
187	* the IOC interface or the ABI provided via the functions returned by
188	* SUPQUERYFUNCS.
189	* -# When adding new features (new IOC number, new flags, new exports, ++)
190	* only update the minor number and change SUPLib.cpp to require the
191	* new IOC version.
192	* -# When incrementing the major number, clear the minor part and reset
193	* any IOC version requirements in SUPLib.cpp.
194	* -# When increment the major number, execute all pending work.
195	*
196	* @todo Pending work on next major version change:
197	* - Nothing.
198	*/
199	#define SUPDRV_IOC_VERSION 0x00140001
200
201	/** SUP_IOCTL_COOKIE. */
202	typedef struct SUPCOOKIE
203	{
204	/** The header.
205	* u32Cookie must be set to SUPCOOKIE_INITIAL_COOKIE.
206	* u32SessionCookie should be set to some random value. */
207	SUPREQHDR Hdr;
208	union
209	{
210	struct
211	{
212	/** Magic word. */
213	char szMagic[16];
214	/** The requested interface version number. */
215	uint32_t u32ReqVersion;
216	/** The minimum interface version number. */
217	uint32_t u32MinVersion;
218	} In;
219	struct
220	{
221	/** Cookie. */
222	uint32_t u32Cookie;
223	/** Session cookie. */
224	uint32_t u32SessionCookie;
225	/** Interface version for this session. */
226	uint32_t u32SessionVersion;
227	/** The actual interface version in the driver. */
228	uint32_t u32DriverVersion;
229	/** Number of functions available for the SUP_IOCTL_QUERY_FUNCS request. */
230	uint32_t cFunctions;
231	/** Session handle. */
232	R0PTRTYPE(PSUPDRVSESSION) pSession;
233	} Out;
234	} u;
235	} SUPCOOKIE, *PSUPCOOKIE;
236	/** @} */
237
238
239	/** @name SUP_IOCTL_QUERY_FUNCS
240	* Query SUPR0 functions.
241	* @{
242	*/
243	#define SUP_IOCTL_QUERY_FUNCS(cFuncs) SUP_CTL_CODE_BIG(2)
244	#define SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs) RT_UOFFSETOF(SUPQUERYFUNCS, u.Out.aFunctions[(cFuncs)])
245	#define SUP_IOCTL_QUERY_FUNCS_SIZE_IN sizeof(SUPREQHDR)
246	#define SUP_IOCTL_QUERY_FUNCS_SIZE_OUT(cFuncs) SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs)
247
248	/** A function. */
249	typedef struct SUPFUNC
250	{
251	/** Name - mangled. */
252	char szName[32];
253	/** Address. */
254	RTR0PTR pfn;
255	} SUPFUNC, *PSUPFUNC;
256
257	typedef struct SUPQUERYFUNCS
258	{
259	/** The header. */
260	SUPREQHDR Hdr;
261	union
262	{
263	struct
264	{
265	/** Number of functions returned. */
266	uint32_t cFunctions;
267	/** Array of functions. */
268	SUPFUNC aFunctions[1];
269	} Out;
270	} u;
271	} SUPQUERYFUNCS, *PSUPQUERYFUNCS;
272	/** @} */
273
274
275	/** @name SUP_IOCTL_LDR_OPEN
276	* Open an image.
277	* @{
278	*/
279	#define SUP_IOCTL_LDR_OPEN SUP_CTL_CODE_SIZE(3, SUP_IOCTL_LDR_OPEN_SIZE)
280	#define SUP_IOCTL_LDR_OPEN_SIZE sizeof(SUPLDROPEN)
281	#define SUP_IOCTL_LDR_OPEN_SIZE_IN sizeof(SUPLDROPEN)
282	#define SUP_IOCTL_LDR_OPEN_SIZE_OUT (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDROPEN, u.Out))
283	typedef struct SUPLDROPEN
284	{
285	/** The header. */
286	SUPREQHDR Hdr;
287	union
288	{
289	struct
290	{
291	/** Size of the image we'll be loading (includeing tables). */
292	uint32_t cbImageWithTabs;
293	/** The size of the image bits. (Less or equal to cbImageWithTabs.) */
294	uint32_t cbImageBits;
295	/** Image name.
296	* This is the NAME of the image, not the file name. It is used
297	* to share code with other processes. (Max len is 32 chars!) */
298	char szName[32];
299	/** Image file name.
300	* This can be used to load the image using a native loader. */
301	char szFilename[196];
302	} In;
303	struct
304	{
305	/** The base address of the image. */
306	RTR0PTR pvImageBase;
307	/** Indicate whether or not the image requires loading. */
308	bool fNeedsLoading;
309	/** Indicates that we're using the native ring-0 loader. */
310	bool fNativeLoader;
311	} Out;
312	} u;
313	} SUPLDROPEN, *PSUPLDROPEN;
314	/** @} */
315
316
317	/** @name SUP_IOCTL_LDR_LOAD
318	* Upload the image bits.
319	* @{
320	*/
321	#define SUP_IOCTL_LDR_LOAD SUP_CTL_CODE_BIG(4)
322	#define SUP_IOCTL_LDR_LOAD_SIZE(cbImage) RT_UOFFSETOF(SUPLDRLOAD, u.In.abImage[cbImage])
323	#define SUP_IOCTL_LDR_LOAD_SIZE_IN(cbImage) RT_UOFFSETOF(SUPLDRLOAD, u.In.abImage[cbImage])
324	#define SUP_IOCTL_LDR_LOAD_SIZE_OUT sizeof(SUPREQHDR)
325
326	/**
327	* Module initialization callback function.
328	* This is called once after the module has been loaded.
329	*
330	* @returns 0 on success.
331	* @returns Appropriate error code on failure.
332	*/
333	typedef DECLCALLBACK(int) FNR0MODULEINIT(void);
334	/** Pointer to a FNR0MODULEINIT(). */
335	typedef R0PTRTYPE(FNR0MODULEINIT *) PFNR0MODULEINIT;
336
337	/**
338	* Module termination callback function.
339	* This is called once right before the module is being unloaded.
340	*/
341	typedef DECLCALLBACK(void) FNR0MODULETERM(void);
342	/** Pointer to a FNR0MODULETERM(). */
343	typedef R0PTRTYPE(FNR0MODULETERM *) PFNR0MODULETERM;
344
345	/**
346	* Symbol table entry.
347	*/
348	typedef struct SUPLDRSYM
349	{
350	/** Offset into of the string table. */
351	uint32_t offName;
352	/** Offset of the symbol relative to the image load address. */
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	* @todo Might have to convert this to a big request...
492	* @{
493	*/
494	#define SUP_IOCTL_CALL_VMMR0(cbReq) SUP_CTL_CODE_SIZE(7, SUP_IOCTL_CALL_VMMR0_SIZE(cbReq))
495	#define SUP_IOCTL_CALL_VMMR0_SIZE(cbReq) RT_UOFFSETOF(SUPCALLVMMR0, abReqPkt[cbReq])
496	#define SUP_IOCTL_CALL_VMMR0_SIZE_IN(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
497	#define SUP_IOCTL_CALL_VMMR0_SIZE_OUT(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
498	typedef struct SUPCALLVMMR0
499	{
500	/** The header. */
501	SUPREQHDR Hdr;
502	union
503	{
504	struct
505	{
506	/** The VM handle. */
507	PVMR0 pVMR0;
508	/** VCPU id. */
509	uint32_t idCpu;
510	/** Which operation to execute. */
511	uint32_t uOperation;
512	/** Argument to use when no request packet is supplied. */
513	uint64_t u64Arg;
514	} In;
515	} u;
516	/** The VMMR0Entry request packet. */
517	uint8_t abReqPkt[1];
518	} SUPCALLVMMR0, *PSUPCALLVMMR0;
519	/** @} */
520
521
522	/** @name SUP_IOCTL_LOW_ALLOC
523	* Allocate memory below 4GB (physically).
524	* @{
525	*/
526	#define SUP_IOCTL_LOW_ALLOC SUP_CTL_CODE_BIG(8)
527	#define SUP_IOCTL_LOW_ALLOC_SIZE(cPages) ((uint32_t)RT_UOFFSETOF(SUPLOWALLOC, u.Out.aPages[cPages]))
528	#define SUP_IOCTL_LOW_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLOWALLOC, u.In))
529	#define SUP_IOCTL_LOW_ALLOC_SIZE_OUT(cPages) SUP_IOCTL_LOW_ALLOC_SIZE(cPages)
530	typedef struct SUPLOWALLOC
531	{
532	/** The header. */
533	SUPREQHDR Hdr;
534	union
535	{
536	struct
537	{
538	/** Number of pages to allocate. */
539	uint32_t cPages;
540	} In;
541	struct
542	{
543	/** The ring-3 address of the allocated memory. */
544	RTR3PTR pvR3;
545	/** The ring-0 address of the allocated memory. */
546	RTR0PTR pvR0;
547	/** Array of pages. */
548	RTHCPHYS aPages[1];
549	} Out;
550	} u;
551	} SUPLOWALLOC, *PSUPLOWALLOC;
552	/** @} */
553
554
555	/** @name SUP_IOCTL_LOW_FREE
556	* Free low memory.
557	* @{
558	*/
559	#define SUP_IOCTL_LOW_FREE SUP_CTL_CODE_SIZE(9, SUP_IOCTL_LOW_FREE_SIZE)
560	#define SUP_IOCTL_LOW_FREE_SIZE sizeof(SUPLOWFREE)
561	#define SUP_IOCTL_LOW_FREE_SIZE_IN sizeof(SUPLOWFREE)
562	#define SUP_IOCTL_LOW_FREE_SIZE_OUT sizeof(SUPREQHDR)
563	typedef struct SUPLOWFREE
564	{
565	/** The header. */
566	SUPREQHDR Hdr;
567	union
568	{
569	struct
570	{
571	/** The ring-3 address of the memory to free. */
572	RTR3PTR pvR3;
573	} In;
574	} u;
575	} SUPLOWFREE, *PSUPLOWFREE;
576	/** @} */
577
578
579	/** @name SUP_IOCTL_PAGE_ALLOC_EX
580	* Allocate memory and map it into kernel and/or user space. The memory is of
581	* course locked. The result should be freed using SUP_IOCTL_PAGE_FREE.
582	*
583	* @remarks Allocations without a kernel mapping may fail with
584	* VERR_NOT_SUPPORTED on some platforms.
585	*
586	* @{
587	*/
588	#define SUP_IOCTL_PAGE_ALLOC_EX SUP_CTL_CODE_BIG(10)
589	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages) RT_UOFFSETOF(SUPPAGEALLOCEX, u.Out.aPages[cPages])
590	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGEALLOCEX, u.In))
591	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_OUT(cPages) SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages)
592	typedef struct SUPPAGEALLOCEX
593	{
594	/** The header. */
595	SUPREQHDR Hdr;
596	union
597	{
598	struct
599	{
600	/** Number of pages to allocate */
601	uint32_t cPages;
602	/** Whether it should have kernel mapping. */
603	bool fKernelMapping;
604	/** Whether it should have a user mapping. */
605	bool fUserMapping;
606	/** Reserved. Must be false. */
607	bool fReserved0;
608	/** Reserved. Must be false. */
609	bool fReserved1;
610	} In;
611	struct
612	{
613	/** Returned ring-3 address. */
614	RTR3PTR pvR3;
615	/** Returned ring-0 address. */
616	RTR0PTR pvR0;
617	/** The physical addresses of the allocated pages. */
618	RTHCPHYS aPages[1];
619	} Out;
620	} u;
621	} SUPPAGEALLOCEX, *PSUPPAGEALLOCEX;
622	/** @} */
623
624
625	/** @name SUP_IOCTL_PAGE_MAP_KERNEL
626	* Maps a portion of memory allocated by SUP_IOCTL_PAGE_ALLOC_EX /
627	* SUPR0PageAllocEx into kernel space for use by a device or similar.
628	*
629	* The mapping will be freed together with the ring-3 mapping when
630	* SUP_IOCTL_PAGE_FREE or SUPR0PageFree is called.
631	*
632	* @remarks Not necessarily supported on all platforms.
633	*
634	* @{
635	*/
636	#define SUP_IOCTL_PAGE_MAP_KERNEL SUP_CTL_CODE_SIZE(11, SUP_IOCTL_PAGE_MAP_KERNEL_SIZE)
637	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE sizeof(SUPPAGEMAPKERNEL)
638	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_IN sizeof(SUPPAGEMAPKERNEL)
639	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_OUT sizeof(SUPPAGEMAPKERNEL)
640	typedef struct SUPPAGEMAPKERNEL
641	{
642	/** The header. */
643	SUPREQHDR Hdr;
644	union
645	{
646	struct
647	{
648	/** The pointer of to the previously allocated memory. */
649	RTR3PTR pvR3;
650	/** The offset to start mapping from. */
651	uint32_t offSub;
652	/** Size of the section to map. */
653	uint32_t cbSub;
654	/** Flags reserved for future fun. */
655	uint32_t fFlags;
656	} In;
657	struct
658	{
659	/** The ring-0 address corresponding to pvR3 + offSub. */
660	RTR0PTR pvR0;
661	} Out;
662	} u;
663	} SUPPAGEMAPKERNEL, *PSUPPAGEMAPKERNEL;
664	/** @} */
665
666
667	/** @name SUP_IOCTL_PAGE_PROTECT
668	* Changes the page level protection of the user and/or kernel mappings of
669	* memory previously allocated by SUPR0PageAllocEx.
670	*
671	* @remarks Not necessarily supported on all platforms.
672	*
673	* @{
674	*/
675	#define SUP_IOCTL_PAGE_PROTECT SUP_CTL_CODE_SIZE(12, SUP_IOCTL_PAGE_PROTECT_SIZE)
676	#define SUP_IOCTL_PAGE_PROTECT_SIZE sizeof(SUPPAGEPROTECT)
677	#define SUP_IOCTL_PAGE_PROTECT_SIZE_IN sizeof(SUPPAGEPROTECT)
678	#define SUP_IOCTL_PAGE_PROTECT_SIZE_OUT sizeof(SUPPAGEPROTECT)
679	typedef struct SUPPAGEPROTECT
680	{
681	/** The header. */
682	SUPREQHDR Hdr;
683	union
684	{
685	struct
686	{
687	/** The pointer of to the previously allocated memory.
688	* Pass NIL_RTR3PTR if the ring-0 mapping should remain unaffected. */
689	RTR3PTR pvR3;
690	/** The pointer of to the previously allocated memory.
691	* Pass NIL_RTR0PTR if the ring-0 mapping should remain unaffected. */
692	RTR0PTR pvR0;
693	/** The offset to start changing protection at. */
694	uint32_t offSub;
695	/** Size of the portion that should be changed. */
696	uint32_t cbSub;
697	/** Protection flags, RTMEM_PROT_. /
698	uint32_t fProt;
699	} In;
700	} u;
701	} SUPPAGEPROTECT, *PSUPPAGEPROTECT;
702	/** @} */
703
704
705	/** @name SUP_IOCTL_PAGE_FREE
706	* Free memory allocated with SUP_IOCTL_PAGE_ALLOC_EX.
707	* @{
708	*/
709	#define SUP_IOCTL_PAGE_FREE SUP_CTL_CODE_SIZE(13, SUP_IOCTL_PAGE_FREE_SIZE_IN)
710	#define SUP_IOCTL_PAGE_FREE_SIZE sizeof(SUPPAGEFREE)
711	#define SUP_IOCTL_PAGE_FREE_SIZE_IN sizeof(SUPPAGEFREE)
712	#define SUP_IOCTL_PAGE_FREE_SIZE_OUT sizeof(SUPREQHDR)
713	typedef struct SUPPAGEFREE
714	{
715	/** The header. */
716	SUPREQHDR Hdr;
717	union
718	{
719	struct
720	{
721	/** Address of memory range to free. */
722	RTR3PTR pvR3;
723	} In;
724	} u;
725	} SUPPAGEFREE, *PSUPPAGEFREE;
726	/** @} */
727
728
729
730
731	/** @name SUP_IOCTL_PAGE_LOCK
732	* Pin down physical pages.
733	* @{
734	*/
735	#define SUP_IOCTL_PAGE_LOCK SUP_CTL_CODE_BIG(14)
736	#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)))
737	#define SUP_IOCTL_PAGE_LOCK_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGELOCK, u.In))
738	#define SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages) RT_UOFFSETOF(SUPPAGELOCK, u.Out.aPages[cPages])
739	typedef struct SUPPAGELOCK
740	{
741	/** The header. */
742	SUPREQHDR Hdr;
743	union
744	{
745	struct
746	{
747	/** Start of page range. Must be PAGE aligned. */
748	RTR3PTR pvR3;
749	/** The range size given as a page count. */
750	uint32_t cPages;
751	} In;
752
753	struct
754	{
755	/** Array of pages. */
756	RTHCPHYS aPages[1];
757	} Out;
758	} u;
759	} SUPPAGELOCK, *PSUPPAGELOCK;
760	/** @} */
761
762
763	/** @name SUP_IOCTL_PAGE_UNLOCK
764	* Unpin physical pages.
765	* @{ */
766	#define SUP_IOCTL_PAGE_UNLOCK SUP_CTL_CODE_SIZE(15, SUP_IOCTL_PAGE_UNLOCK_SIZE)
767	#define SUP_IOCTL_PAGE_UNLOCK_SIZE sizeof(SUPPAGEUNLOCK)
768	#define SUP_IOCTL_PAGE_UNLOCK_SIZE_IN sizeof(SUPPAGEUNLOCK)
769	#define SUP_IOCTL_PAGE_UNLOCK_SIZE_OUT sizeof(SUPREQHDR)
770	typedef struct SUPPAGEUNLOCK
771	{
772	/** The header. */
773	SUPREQHDR Hdr;
774	union
775	{
776	struct
777	{
778	/** Start of page range of a range previuosly pinned. */
779	RTR3PTR pvR3;
780	} In;
781	} u;
782	} SUPPAGEUNLOCK, *PSUPPAGEUNLOCK;
783	/** @} */
784
785
786	/** @name SUP_IOCTL_CONT_ALLOC
787	* Allocate contious memory.
788	* @{
789	*/
790	#define SUP_IOCTL_CONT_ALLOC SUP_CTL_CODE_SIZE(16, SUP_IOCTL_CONT_ALLOC_SIZE)
791	#define SUP_IOCTL_CONT_ALLOC_SIZE sizeof(SUPCONTALLOC)
792	#define SUP_IOCTL_CONT_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCONTALLOC, u.In))
793	#define SUP_IOCTL_CONT_ALLOC_SIZE_OUT sizeof(SUPCONTALLOC)
794	typedef struct SUPCONTALLOC
795	{
796	/** The header. */
797	SUPREQHDR Hdr;
798	union
799	{
800	struct
801	{
802	/** The allocation size given as a page count. */
803	uint32_t cPages;
804	} In;
805
806	struct
807	{
808	/** The address of the ring-0 mapping of the allocated memory. */
809	RTR0PTR pvR0;
810	/** The address of the ring-3 mapping of the allocated memory. */
811	RTR3PTR pvR3;
812	/** The physical address of the allocation. */
813	RTHCPHYS HCPhys;
814	} Out;
815	} u;
816	} SUPCONTALLOC, *PSUPCONTALLOC;
817	/** @} */
818
819
820	/** @name SUP_IOCTL_CONT_FREE Input.
821	* @{
822	*/
823	/** Free contious memory. */
824	#define SUP_IOCTL_CONT_FREE SUP_CTL_CODE_SIZE(17, SUP_IOCTL_CONT_FREE_SIZE)
825	#define SUP_IOCTL_CONT_FREE_SIZE sizeof(SUPCONTFREE)
826	#define SUP_IOCTL_CONT_FREE_SIZE_IN sizeof(SUPCONTFREE)
827	#define SUP_IOCTL_CONT_FREE_SIZE_OUT sizeof(SUPREQHDR)
828	typedef struct SUPCONTFREE
829	{
830	/** The header. */
831	SUPREQHDR Hdr;
832	union
833	{
834	struct
835	{
836	/** The ring-3 address of the memory to free. */
837	RTR3PTR pvR3;
838	} In;
839	} u;
840	} SUPCONTFREE, *PSUPCONTFREE;
841	/** @} */
842
843
844	/** @name SUP_IOCTL_GET_PAGING_MODE
845	* Get the host paging mode.
846	* @{
847	*/
848	#define SUP_IOCTL_GET_PAGING_MODE SUP_CTL_CODE_SIZE(18, SUP_IOCTL_GET_PAGING_MODE_SIZE)
849	#define SUP_IOCTL_GET_PAGING_MODE_SIZE sizeof(SUPGETPAGINGMODE)
850	#define SUP_IOCTL_GET_PAGING_MODE_SIZE_IN sizeof(SUPREQHDR)
851	#define SUP_IOCTL_GET_PAGING_MODE_SIZE_OUT sizeof(SUPGETPAGINGMODE)
852	typedef struct SUPGETPAGINGMODE
853	{
854	/** The header. */
855	SUPREQHDR Hdr;
856	union
857	{
858	struct
859	{
860	/** The paging mode. */
861	SUPPAGINGMODE enmMode;
862	} Out;
863	} u;
864	} SUPGETPAGINGMODE, *PSUPGETPAGINGMODE;
865	/** @} */
866
867
868	/** @name SUP_IOCTL_SET_VM_FOR_FAST
869	* Set the VM handle for doing fast call ioctl calls.
870	* @{
871	*/
872	#define SUP_IOCTL_SET_VM_FOR_FAST SUP_CTL_CODE_SIZE(19, SUP_IOCTL_SET_VM_FOR_FAST_SIZE)
873	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE sizeof(SUPSETVMFORFAST)
874	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_IN sizeof(SUPSETVMFORFAST)
875	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_OUT sizeof(SUPREQHDR)
876	typedef struct SUPSETVMFORFAST
877	{
878	/** The header. */
879	SUPREQHDR Hdr;
880	union
881	{
882	struct
883	{
884	/** The ring-0 VM handle (pointer). */
885	PVMR0 pVMR0;
886	} In;
887	} u;
888	} SUPSETVMFORFAST, *PSUPSETVMFORFAST;
889	/** @} */
890
891
892	/** @name SUP_IOCTL_GIP_MAP
893	* Map the GIP into user space.
894	* @{
895	*/
896	#define SUP_IOCTL_GIP_MAP SUP_CTL_CODE_SIZE(20, SUP_IOCTL_GIP_MAP_SIZE)
897	#define SUP_IOCTL_GIP_MAP_SIZE sizeof(SUPGIPMAP)
898	#define SUP_IOCTL_GIP_MAP_SIZE_IN sizeof(SUPREQHDR)
899	#define SUP_IOCTL_GIP_MAP_SIZE_OUT sizeof(SUPGIPMAP)
900	typedef struct SUPGIPMAP
901	{
902	/** The header. */
903	SUPREQHDR Hdr;
904	union
905	{
906	struct
907	{
908	/** The physical address of the GIP. */
909	RTHCPHYS HCPhysGip;
910	/** Pointer to the read-only usermode GIP mapping for this session. */
911	R3PTRTYPE(PSUPGLOBALINFOPAGE) pGipR3;
912	/** Pointer to the supervisor mode GIP mapping. */
913	R0PTRTYPE(PSUPGLOBALINFOPAGE) pGipR0;
914	} Out;
915	} u;
916	} SUPGIPMAP, *PSUPGIPMAP;
917	/** @} */
918
919
920	/** @name SUP_IOCTL_GIP_UNMAP
921	* Unmap the GIP.
922	* @{
923	*/
924	#define SUP_IOCTL_GIP_UNMAP SUP_CTL_CODE_SIZE(21, SUP_IOCTL_GIP_UNMAP_SIZE)
925	#define SUP_IOCTL_GIP_UNMAP_SIZE sizeof(SUPGIPUNMAP)
926	#define SUP_IOCTL_GIP_UNMAP_SIZE_IN sizeof(SUPGIPUNMAP)
927	#define SUP_IOCTL_GIP_UNMAP_SIZE_OUT sizeof(SUPGIPUNMAP)
928	typedef struct SUPGIPUNMAP
929	{
930	/** The header. */
931	SUPREQHDR Hdr;
932	} SUPGIPUNMAP, *PSUPGIPUNMAP;
933	/** @} */
934
935
936	/** @name SUP_IOCTL_CALL_SERVICE
937	* Call the a ring-0 service.
938	*
939	* @todo Might have to convert this to a big request, just like
940	* SUP_IOCTL_CALL_VMMR0
941	* @{
942	*/
943	#define SUP_IOCTL_CALL_SERVICE(cbReq) SUP_CTL_CODE_SIZE(22, SUP_IOCTL_CALL_SERVICE_SIZE(cbReq))
944	#define SUP_IOCTL_CALL_SERVICE_SIZE(cbReq) RT_UOFFSETOF(SUPCALLSERVICE, abReqPkt[cbReq])
945	#define SUP_IOCTL_CALL_SERVICE_SIZE_IN(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
946	#define SUP_IOCTL_CALL_SERVICE_SIZE_OUT(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
947	typedef struct SUPCALLSERVICE
948	{
949	/** The header. */
950	SUPREQHDR Hdr;
951	union
952	{
953	struct
954	{
955	/** The service name. */
956	char szName[28];
957	/** Which operation to execute. */
958	uint32_t uOperation;
959	/** Argument to use when no request packet is supplied. */
960	uint64_t u64Arg;
961	} In;
962	} u;
963	/** The request packet passed to SUP. */
964	uint8_t abReqPkt[1];
965	} SUPCALLSERVICE, *PSUPCALLSERVICE;
966	/** @} */
967
968
969	/** @name SUP_IOCTL_LOGGER_SETTINGS
970	* Changes the ring-0 release or debug logger settings.
971	* @{
972	*/
973	#define SUP_IOCTL_LOGGER_SETTINGS(cbStrTab) SUP_CTL_CODE_SIZE(23, SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab))
974	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab) RT_UOFFSETOF(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
975	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE_IN(cbStrTab) RT_UOFFSETOF(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
976	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE_OUT sizeof(SUPREQHDR)
977	typedef struct SUPLOGGERSETTINGS
978	{
979	/** The header. */
980	SUPREQHDR Hdr;
981	union
982	{
983	struct
984	{
985	/** Which logger. */
986	uint32_t fWhich;
987	/** What to do with it. */
988	uint32_t fWhat;
989	/** Offset of the flags setting string. */
990	uint32_t offFlags;
991	/** Offset of the groups setting string. */
992	uint32_t offGroups;
993	/** Offset of the destination setting string. */
994	uint32_t offDestination;
995	/** The string table. */
996	char szStrings[1];
997	} In;
998	} u;
999	} SUPLOGGERSETTINGS, *PSUPLOGGERSETTINGS;
1000
1001	/** Debug logger. */
1002	#define SUPLOGGERSETTINGS_WHICH_DEBUG 0
1003	/** Release logger. */
1004	#define SUPLOGGERSETTINGS_WHICH_RELEASE 1
1005
1006	/** Change the settings. */
1007	#define SUPLOGGERSETTINGS_WHAT_SETTINGS 0
1008	/** Create the logger instance. */
1009	#define SUPLOGGERSETTINGS_WHAT_CREATE 1
1010	/** Destroy the logger instance. */
1011	#define SUPLOGGERSETTINGS_WHAT_DESTROY 2
1012
1013	/** @} */
1014
1015
1016	/** @name Semaphore Types
1017	* @{ */
1018	#define SUP_SEM_TYPE_EVENT 0
1019	#define SUP_SEM_TYPE_EVENT_MULTI 1
1020	/** @} */
1021
1022
1023	/** @name SUP_IOCTL_SEM_CREATE
1024	* Create a semaphore
1025	* @{
1026	*/
1027	#define SUP_IOCTL_SEM_CREATE SUP_CTL_CODE_SIZE(24, SUP_IOCTL_SEM_CREATE_SIZE)
1028	#define SUP_IOCTL_SEM_CREATE_SIZE sizeof(SUPSEMCREATE)
1029	#define SUP_IOCTL_SEM_CREATE_SIZE_IN sizeof(SUPSEMCREATE)
1030	#define SUP_IOCTL_SEM_CREATE_SIZE_OUT sizeof(SUPSEMCREATE)
1031	typedef struct SUPSEMCREATE
1032	{
1033	/** The header. */
1034	SUPREQHDR Hdr;
1035	union
1036	{
1037	struct
1038	{
1039	/** The semaphore type. */
1040	uint32_t uType;
1041	} In;
1042	struct
1043	{
1044	/** The handle of the created semaphore. */
1045	uint32_t hSem;
1046	} Out;
1047	} u;
1048	} SUPSEMCREATE, *PSUPSEMCREATE;
1049
1050	/** @} */
1051
1052
1053	/** @name SUP_IOCTL_SEM_OP
1054	* Semaphore operations.
1055	* @{
1056	*/
1057	#define SUP_IOCTL_SEM_OP SUP_CTL_CODE_SIZE(25, SUP_IOCTL_SEM_OP_SIZE)
1058	#define SUP_IOCTL_SEM_OP_SIZE sizeof(SUPSEMOP)
1059	#define SUP_IOCTL_SEM_OP_SIZE_IN sizeof(SUPSEMOP)
1060	#define SUP_IOCTL_SEM_OP_SIZE_OUT sizeof(SUPREQHDR)
1061	typedef struct SUPSEMOP
1062	{
1063	/** The header. */
1064	SUPREQHDR Hdr;
1065	union
1066	{
1067	struct
1068	{
1069	/** The semaphore type. */
1070	uint32_t uType;
1071	/** The semaphore handle. */
1072	uint32_t hSem;
1073	/** The operation. */
1074	uint32_t uOp;
1075	/** The number of milliseconds to wait if it's a wait operation. */
1076	uint32_t cMillies;
1077	} In;
1078	} u;
1079	} SUPSEMOP, *PSUPSEMOP;
1080
1081	/** Wait for a number of millisecons. */
1082	#define SUPSEMOP_WAIT 0
1083	/** Signal the semaphore. */
1084	#define SUPSEMOP_SIGNAL 1
1085	/** Reset the sempahore (only applicable to SUP_SEM_TYPE_EVENT_MULTI). */
1086	#define SUPSEMOP_RESET 2
1087	/** Close the semaphore handle. */
1088	#define SUPSEMOP_CLOSE 3
1089
1090	/** @} */
1091
1092	/** @name SUP_IOCTL_VT_CAPS Input.
1093	* @{
1094	*/
1095	/** Free contious memory. */
1096	#define SUP_IOCTL_VT_CAPS SUP_CTL_CODE_SIZE(26, SUP_IOCTL_VT_CAPS_SIZE)
1097	#define SUP_IOCTL_VT_CAPS_SIZE sizeof(SUPVTCAPS)
1098	#define SUP_IOCTL_VT_CAPS_SIZE_IN sizeof(SUPREQHDR)
1099	#define SUP_IOCTL_VT_CAPS_SIZE_OUT sizeof(SUPVTCAPS)
1100	typedef struct SUPVTCAPS
1101	{
1102	/** The header. */
1103	SUPREQHDR Hdr;
1104	union
1105	{
1106	struct
1107	{
1108	/** The VT capability dword. */
1109	uint32_t Caps;
1110	} Out;
1111	} u;
1112	} SUPVTCAPS, *PSUPVTCAPS;
1113	/** @} */
1114
1115	#pragma pack() /* paranoia */
1116
1117	#endif
1118

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

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

Download in other formats: