SUPDrvIOC.h@ 22509

Last change on this file since 22509 was 22150, checked in by vboxsync, 15 years ago
IPRT,SUPDrv: Changed RTTHREADPREEMPTSTATE breaking binary compatibility - increased the major SUPDrv version.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.8 KB

Line
1	/* $Revision: 22150 $ */
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	#ifdef RT_ARCH_AMD64
46	# define SUP_IOCTL_FLAG 128
47	#elif defined(RT_ARCH_X86)
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 has 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 0x000f0000
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. */
292	uint32_t cbImage;
293	/** Image name.
294	* This is the NAME of the image, not the file name. It is used
295	* to share code with other processes. (Max len is 32 chars!) */
296	char szName[32];
297	} In;
298	struct
299	{
300	/** The base address of the image. */
301	RTR0PTR pvImageBase;
302	/** Indicate whether or not the image requires loading. */
303	bool fNeedsLoading;
304	} Out;
305	} u;
306	} SUPLDROPEN, *PSUPLDROPEN;
307	/** @} */
308
309
310	/** @name SUP_IOCTL_LDR_LOAD
311	* Upload the image bits.
312	* @{
313	*/
314	#define SUP_IOCTL_LDR_LOAD SUP_CTL_CODE_BIG(4)
315	#define SUP_IOCTL_LDR_LOAD_SIZE(cbImage) RT_UOFFSETOF(SUPLDRLOAD, u.In.achImage[cbImage])
316	#define SUP_IOCTL_LDR_LOAD_SIZE_IN(cbImage) RT_UOFFSETOF(SUPLDRLOAD, u.In.achImage[cbImage])
317	#define SUP_IOCTL_LDR_LOAD_SIZE_OUT sizeof(SUPREQHDR)
318
319	/**
320	* Module initialization callback function.
321	* This is called once after the module has been loaded.
322	*
323	* @returns 0 on success.
324	* @returns Appropriate error code on failure.
325	*/
326	typedef DECLCALLBACK(int) FNR0MODULEINIT(void);
327	/** Pointer to a FNR0MODULEINIT(). */
328	typedef R0PTRTYPE(FNR0MODULEINIT *) PFNR0MODULEINIT;
329
330	/**
331	* Module termination callback function.
332	* This is called once right before the module is being unloaded.
333	*/
334	typedef DECLCALLBACK(void) FNR0MODULETERM(void);
335	/** Pointer to a FNR0MODULETERM(). */
336	typedef R0PTRTYPE(FNR0MODULETERM *) PFNR0MODULETERM;
337
338	/**
339	* Symbol table entry.
340	*/
341	typedef struct SUPLDRSYM
342	{
343	/** Offset into of the string table. */
344	uint32_t offName;
345	/** Offset of the symbol relative to the image load address. */
346	uint32_t offSymbol;
347	} SUPLDRSYM;
348	/** Pointer to a symbol table entry. */
349	typedef SUPLDRSYM *PSUPLDRSYM;
350	/** Pointer to a const symbol table entry. */
351	typedef SUPLDRSYM const *PCSUPLDRSYM;
352
353	/**
354	* SUPLDRLOAD::u::In::EP type.
355	*/
356	typedef enum SUPLDRLOADEP
357	{
358	SUPLDRLOADEP_NOTHING = 0,
359	SUPLDRLOADEP_VMMR0,
360	SUPLDRLOADEP_SERVICE,
361	SUPLDRLOADEP_32BIT_HACK = 0x7fffffff
362	} SUPLDRLOADEP;
363
364	typedef struct SUPLDRLOAD
365	{
366	/** The header. */
367	SUPREQHDR Hdr;
368	union
369	{
370	struct
371	{
372	/** The address of module initialization function. Similar to _DLL_InitTerm(hmod, 0). */
373	PFNR0MODULEINIT pfnModuleInit;
374	/** The address of module termination function. Similar to _DLL_InitTerm(hmod, 1). */
375	PFNR0MODULETERM pfnModuleTerm;
376	/** Special entry points. */
377	union
378	{
379	/** SUPLDRLOADEP_VMMR0. */
380	struct
381	{
382	/** The module handle (i.e. address). */
383	RTR0PTR pvVMMR0;
384	/** Address of VMMR0EntryInt function. */
385	RTR0PTR pvVMMR0EntryInt;
386	/** Address of VMMR0EntryFast function. */
387	RTR0PTR pvVMMR0EntryFast;
388	/** Address of VMMR0EntryEx function. */
389	RTR0PTR pvVMMR0EntryEx;
390	} VMMR0;
391	/** SUPLDRLOADEP_SERVICE. */
392	struct
393	{
394	/** The service request handler.
395	* (PFNR0SERVICEREQHANDLER isn't defined yet.) */
396	RTR0PTR pfnServiceReq;
397	/** Reserved, must be NIL. */
398	RTR0PTR apvReserved[3];
399	} Service;
400	} EP;
401	/** Address. */
402	RTR0PTR pvImageBase;
403	/** Entry point type. */
404	SUPLDRLOADEP eEPType;
405	/** The offset of the symbol table. */
406	uint32_t offSymbols;
407	/** The number of entries in the symbol table. */
408	uint32_t cSymbols;
409	/** The offset of the string table. */
410	uint32_t offStrTab;
411	/** Size of the string table. */
412	uint32_t cbStrTab;
413	/** Size of image (including string and symbol tables). */
414	uint32_t cbImage;
415	/** The image data. */
416	char achImage[1];
417	} In;
418	} u;
419	} SUPLDRLOAD, *PSUPLDRLOAD;
420	/** @} */
421
422
423	/** @name SUP_IOCTL_LDR_FREE
424	* Free an image.
425	* @{
426	*/
427	#define SUP_IOCTL_LDR_FREE SUP_CTL_CODE_SIZE(5, SUP_IOCTL_LDR_FREE_SIZE)
428	#define SUP_IOCTL_LDR_FREE_SIZE sizeof(SUPLDRFREE)
429	#define SUP_IOCTL_LDR_FREE_SIZE_IN sizeof(SUPLDRFREE)
430	#define SUP_IOCTL_LDR_FREE_SIZE_OUT sizeof(SUPREQHDR)
431	typedef struct SUPLDRFREE
432	{
433	/** The header. */
434	SUPREQHDR Hdr;
435	union
436	{
437	struct
438	{
439	/** Address. */
440	RTR0PTR pvImageBase;
441	} In;
442	} u;
443	} SUPLDRFREE, *PSUPLDRFREE;
444	/** @} */
445
446
447	/** @name SUP_IOCTL_LDR_GET_SYMBOL
448	* Get address of a symbol within an image.
449	* @{
450	*/
451	#define SUP_IOCTL_LDR_GET_SYMBOL SUP_CTL_CODE_SIZE(6, SUP_IOCTL_LDR_GET_SYMBOL_SIZE)
452	#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE sizeof(SUPLDRGETSYMBOL)
453	#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_IN sizeof(SUPLDRGETSYMBOL)
454	#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_OUT (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDRGETSYMBOL, u.Out))
455	typedef struct SUPLDRGETSYMBOL
456	{
457	/** The header. */
458	SUPREQHDR Hdr;
459	union
460	{
461	struct
462	{
463	/** Address. */
464	RTR0PTR pvImageBase;
465	/** The symbol name. */
466	char szSymbol[64];
467	} In;
468	struct
469	{
470	/** The symbol address. */
471	RTR0PTR pvSymbol;
472	} Out;
473	} u;
474	} SUPLDRGETSYMBOL, *PSUPLDRGETSYMBOL;
475	/** @} */
476
477
478	/** @name SUP_IOCTL_CALL_VMMR0
479	* Call the R0 VMM Entry point.
480	*
481	* @todo Might have to convert this to a big request...
482	* @{
483	*/
484	#define SUP_IOCTL_CALL_VMMR0(cbReq) SUP_CTL_CODE_SIZE(7, SUP_IOCTL_CALL_VMMR0_SIZE(cbReq))
485	#define SUP_IOCTL_CALL_VMMR0_SIZE(cbReq) RT_UOFFSETOF(SUPCALLVMMR0, abReqPkt[cbReq])
486	#define SUP_IOCTL_CALL_VMMR0_SIZE_IN(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
487	#define SUP_IOCTL_CALL_VMMR0_SIZE_OUT(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
488	typedef struct SUPCALLVMMR0
489	{
490	/** The header. */
491	SUPREQHDR Hdr;
492	union
493	{
494	struct
495	{
496	/** The VM handle. */
497	PVMR0 pVMR0;
498	/** VCPU id. */
499	uint32_t idCpu;
500	/** Which operation to execute. */
501	uint32_t uOperation;
502	/** Argument to use when no request packet is supplied. */
503	uint64_t u64Arg;
504	} In;
505	} u;
506	/** The VMMR0Entry request packet. */
507	uint8_t abReqPkt[1];
508	} SUPCALLVMMR0, *PSUPCALLVMMR0;
509	/** @} */
510
511
512	/** @name SUP_IOCTL_LOW_ALLOC
513	* Allocate memory below 4GB (physically).
514	* @{
515	*/
516	#define SUP_IOCTL_LOW_ALLOC SUP_CTL_CODE_BIG(8)
517	#define SUP_IOCTL_LOW_ALLOC_SIZE(cPages) ((uint32_t)RT_UOFFSETOF(SUPLOWALLOC, u.Out.aPages[cPages]))
518	#define SUP_IOCTL_LOW_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLOWALLOC, u.In))
519	#define SUP_IOCTL_LOW_ALLOC_SIZE_OUT(cPages) SUP_IOCTL_LOW_ALLOC_SIZE(cPages)
520	typedef struct SUPLOWALLOC
521	{
522	/** The header. */
523	SUPREQHDR Hdr;
524	union
525	{
526	struct
527	{
528	/** Number of pages to allocate. */
529	uint32_t cPages;
530	} In;
531	struct
532	{
533	/** The ring-3 address of the allocated memory. */
534	RTR3PTR pvR3;
535	/** The ring-0 address of the allocated memory. */
536	RTR0PTR pvR0;
537	/** Array of pages. */
538	RTHCPHYS aPages[1];
539	} Out;
540	} u;
541	} SUPLOWALLOC, *PSUPLOWALLOC;
542	/** @} */
543
544
545	/** @name SUP_IOCTL_LOW_FREE
546	* Free low memory.
547	* @{
548	*/
549	#define SUP_IOCTL_LOW_FREE SUP_CTL_CODE_SIZE(9, SUP_IOCTL_LOW_FREE_SIZE)
550	#define SUP_IOCTL_LOW_FREE_SIZE sizeof(SUPLOWFREE)
551	#define SUP_IOCTL_LOW_FREE_SIZE_IN sizeof(SUPLOWFREE)
552	#define SUP_IOCTL_LOW_FREE_SIZE_OUT sizeof(SUPREQHDR)
553	typedef struct SUPLOWFREE
554	{
555	/** The header. */
556	SUPREQHDR Hdr;
557	union
558	{
559	struct
560	{
561	/** The ring-3 address of the memory to free. */
562	RTR3PTR pvR3;
563	} In;
564	} u;
565	} SUPLOWFREE, *PSUPLOWFREE;
566	/** @} */
567
568
569	/** @name SUP_IOCTL_PAGE_ALLOC_EX
570	* Allocate memory and map it into kernel and/or user space. The memory is of
571	* course locked. The result should be freed using SUP_IOCTL_PAGE_FREE.
572	*
573	* @remarks Allocations without a kernel mapping may fail with
574	* VERR_NOT_SUPPORTED on some platforms.
575	*
576	* @{
577	*/
578	#define SUP_IOCTL_PAGE_ALLOC_EX SUP_CTL_CODE_BIG(10)
579	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages) RT_UOFFSETOF(SUPPAGEALLOCEX, u.Out.aPages[cPages])
580	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGEALLOCEX, u.In))
581	#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_OUT(cPages) SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages)
582	typedef struct SUPPAGEALLOCEX
583	{
584	/** The header. */
585	SUPREQHDR Hdr;
586	union
587	{
588	struct
589	{
590	/** Number of pages to allocate */
591	uint32_t cPages;
592	/** Whether it should have kernel mapping. */
593	bool fKernelMapping;
594	/** Whether it should have a user mapping. */
595	bool fUserMapping;
596	/** Reserved. Must be false. */
597	bool fReserved0;
598	/** Reserved. Must be false. */
599	bool fReserved1;
600	} In;
601	struct
602	{
603	/** Returned ring-3 address. */
604	RTR3PTR pvR3;
605	/** Returned ring-0 address. */
606	RTR0PTR pvR0;
607	/** The physical addresses of the allocated pages. */
608	RTHCPHYS aPages[1];
609	} Out;
610	} u;
611	} SUPPAGEALLOCEX, *PSUPPAGEALLOCEX;
612	/** @} */
613
614
615	/** @name SUP_IOCTL_PAGE_MAP_KERNEL
616	* Maps a portion of memory allocated by SUP_IOCTL_PAGE_ALLOC_EX /
617	* SUPR0PageAllocEx into kernel space for use by a device or similar.
618	*
619	* The mapping will be freed together with the ring-3 mapping when
620	* SUP_IOCTL_PAGE_FREE or SUPR0PageFree is called.
621	*
622	* @remarks Not necessarily supported on all platforms.
623	*
624	* @{
625	*/
626	#define SUP_IOCTL_PAGE_MAP_KERNEL SUP_CTL_CODE_SIZE(11, SUP_IOCTL_PAGE_MAP_KERNEL_SIZE)
627	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE sizeof(SUPPAGEMAPKERNEL)
628	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_IN sizeof(SUPPAGEMAPKERNEL)
629	#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_OUT sizeof(SUPPAGEMAPKERNEL)
630	typedef struct SUPPAGEMAPKERNEL
631	{
632	/** The header. */
633	SUPREQHDR Hdr;
634	union
635	{
636	struct
637	{
638	/** The pointer of to the previously allocated memory. */
639	RTR3PTR pvR3;
640	/** The offset to start mapping from. */
641	uint32_t offSub;
642	/** Size of the section to map. */
643	uint32_t cbSub;
644	/** Flags reserved for future fun. */
645	uint32_t fFlags;
646	} In;
647	struct
648	{
649	/** The ring-0 address corresponding to pvR3 + offSub. */
650	RTR0PTR pvR0;
651	} Out;
652	} u;
653	} SUPPAGEMAPKERNEL, *PSUPPAGEMAPKERNEL;
654	/** @} */
655
656
657	/** @name SUP_IOCTL_PAGE_PROTECT
658	* Changes the page level protection of the user and/or kernel mappings of
659	* memory previously allocated by SUPR0PageAllocEx.
660	*
661	* @remarks Not necessarily supported on all platforms.
662	*
663	* @{
664	*/
665	#define SUP_IOCTL_PAGE_PROTECT SUP_CTL_CODE_SIZE(12, SUP_IOCTL_PAGE_PROTECT_SIZE)
666	#define SUP_IOCTL_PAGE_PROTECT_SIZE sizeof(SUPPAGEPROTECT)
667	#define SUP_IOCTL_PAGE_PROTECT_SIZE_IN sizeof(SUPPAGEPROTECT)
668	#define SUP_IOCTL_PAGE_PROTECT_SIZE_OUT sizeof(SUPPAGEPROTECT)
669	typedef struct SUPPAGEPROTECT
670	{
671	/** The header. */
672	SUPREQHDR Hdr;
673	union
674	{
675	struct
676	{
677	/** The pointer of to the previously allocated memory.
678	* Pass NIL_RTR3PTR if the ring-0 mapping should remain unaffected. */
679	RTR3PTR pvR3;
680	/** The pointer of to the previously allocated memory.
681	* Pass NIL_RTR0PTR if the ring-0 mapping should remain unaffected. */
682	RTR0PTR pvR0;
683	/** The offset to start changing protection at. */
684	uint32_t offSub;
685	/** Size of the portion that should be changed. */
686	uint32_t cbSub;
687	/** Protection flags, RTMEM_PROT_. /
688	uint32_t fProt;
689	} In;
690	} u;
691	} SUPPAGEPROTECT, *PSUPPAGEPROTECT;
692	/** @} */
693
694
695	/** @name SUP_IOCTL_PAGE_FREE
696	* Free memory allocated with SUP_IOCTL_PAGE_ALLOC_EX.
697	* @{
698	*/
699	#define SUP_IOCTL_PAGE_FREE SUP_CTL_CODE_SIZE(13, SUP_IOCTL_PAGE_FREE_SIZE_IN)
700	#define SUP_IOCTL_PAGE_FREE_SIZE sizeof(SUPPAGEFREE)
701	#define SUP_IOCTL_PAGE_FREE_SIZE_IN sizeof(SUPPAGEFREE)
702	#define SUP_IOCTL_PAGE_FREE_SIZE_OUT sizeof(SUPREQHDR)
703	typedef struct SUPPAGEFREE
704	{
705	/** The header. */
706	SUPREQHDR Hdr;
707	union
708	{
709	struct
710	{
711	/** Address of memory range to free. */
712	RTR3PTR pvR3;
713	} In;
714	} u;
715	} SUPPAGEFREE, *PSUPPAGEFREE;
716	/** @} */
717
718
719
720
721	/** @name SUP_IOCTL_PAGE_LOCK
722	* Pin down physical pages.
723	* @{
724	*/
725	#define SUP_IOCTL_PAGE_LOCK SUP_CTL_CODE_BIG(14)
726	#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)))
727	#define SUP_IOCTL_PAGE_LOCK_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGELOCK, u.In))
728	#define SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages) RT_UOFFSETOF(SUPPAGELOCK, u.Out.aPages[cPages])
729	typedef struct SUPPAGELOCK
730	{
731	/** The header. */
732	SUPREQHDR Hdr;
733	union
734	{
735	struct
736	{
737	/** Start of page range. Must be PAGE aligned. */
738	RTR3PTR pvR3;
739	/** The range size given as a page count. */
740	uint32_t cPages;
741	} In;
742
743	struct
744	{
745	/** Array of pages. */
746	RTHCPHYS aPages[1];
747	} Out;
748	} u;
749	} SUPPAGELOCK, *PSUPPAGELOCK;
750	/** @} */
751
752
753	/** @name SUP_IOCTL_PAGE_UNLOCK
754	* Unpin physical pages.
755	* @{ */
756	#define SUP_IOCTL_PAGE_UNLOCK SUP_CTL_CODE_SIZE(15, SUP_IOCTL_PAGE_UNLOCK_SIZE)
757	#define SUP_IOCTL_PAGE_UNLOCK_SIZE sizeof(SUPPAGEUNLOCK)
758	#define SUP_IOCTL_PAGE_UNLOCK_SIZE_IN sizeof(SUPPAGEUNLOCK)
759	#define SUP_IOCTL_PAGE_UNLOCK_SIZE_OUT sizeof(SUPREQHDR)
760	typedef struct SUPPAGEUNLOCK
761	{
762	/** The header. */
763	SUPREQHDR Hdr;
764	union
765	{
766	struct
767	{
768	/** Start of page range of a range previuosly pinned. */
769	RTR3PTR pvR3;
770	} In;
771	} u;
772	} SUPPAGEUNLOCK, *PSUPPAGEUNLOCK;
773	/** @} */
774
775
776	/** @name SUP_IOCTL_CONT_ALLOC
777	* Allocate contious memory.
778	* @{
779	*/
780	#define SUP_IOCTL_CONT_ALLOC SUP_CTL_CODE_SIZE(16, SUP_IOCTL_CONT_ALLOC_SIZE)
781	#define SUP_IOCTL_CONT_ALLOC_SIZE sizeof(SUPCONTALLOC)
782	#define SUP_IOCTL_CONT_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCONTALLOC, u.In))
783	#define SUP_IOCTL_CONT_ALLOC_SIZE_OUT sizeof(SUPCONTALLOC)
784	typedef struct SUPCONTALLOC
785	{
786	/** The header. */
787	SUPREQHDR Hdr;
788	union
789	{
790	struct
791	{
792	/** The allocation size given as a page count. */
793	uint32_t cPages;
794	} In;
795
796	struct
797	{
798	/** The address of the ring-0 mapping of the allocated memory. */
799	RTR0PTR pvR0;
800	/** The address of the ring-3 mapping of the allocated memory. */
801	RTR3PTR pvR3;
802	/** The physical address of the allocation. */
803	RTHCPHYS HCPhys;
804	} Out;
805	} u;
806	} SUPCONTALLOC, *PSUPCONTALLOC;
807	/** @} */
808
809
810	/** @name SUP_IOCTL_CONT_FREE Input.
811	* @{
812	*/
813	/** Free contious memory. */
814	#define SUP_IOCTL_CONT_FREE SUP_CTL_CODE_SIZE(17, SUP_IOCTL_CONT_FREE_SIZE)
815	#define SUP_IOCTL_CONT_FREE_SIZE sizeof(SUPCONTFREE)
816	#define SUP_IOCTL_CONT_FREE_SIZE_IN sizeof(SUPCONTFREE)
817	#define SUP_IOCTL_CONT_FREE_SIZE_OUT sizeof(SUPREQHDR)
818	typedef struct SUPCONTFREE
819	{
820	/** The header. */
821	SUPREQHDR Hdr;
822	union
823	{
824	struct
825	{
826	/** The ring-3 address of the memory to free. */
827	RTR3PTR pvR3;
828	} In;
829	} u;
830	} SUPCONTFREE, *PSUPCONTFREE;
831	/** @} */
832
833
834	/** @name SUP_IOCTL_GET_PAGING_MODE
835	* Get the host paging mode.
836	* @{
837	*/
838	#define SUP_IOCTL_GET_PAGING_MODE SUP_CTL_CODE_SIZE(18, SUP_IOCTL_GET_PAGING_MODE_SIZE)
839	#define SUP_IOCTL_GET_PAGING_MODE_SIZE sizeof(SUPGETPAGINGMODE)
840	#define SUP_IOCTL_GET_PAGING_MODE_SIZE_IN sizeof(SUPREQHDR)
841	#define SUP_IOCTL_GET_PAGING_MODE_SIZE_OUT sizeof(SUPGETPAGINGMODE)
842	typedef struct SUPGETPAGINGMODE
843	{
844	/** The header. */
845	SUPREQHDR Hdr;
846	union
847	{
848	struct
849	{
850	/** The paging mode. */
851	SUPPAGINGMODE enmMode;
852	} Out;
853	} u;
854	} SUPGETPAGINGMODE, *PSUPGETPAGINGMODE;
855	/** @} */
856
857
858	/** @name SUP_IOCTL_SET_VM_FOR_FAST
859	* Set the VM handle for doing fast call ioctl calls.
860	* @{
861	*/
862	#define SUP_IOCTL_SET_VM_FOR_FAST SUP_CTL_CODE_SIZE(19, SUP_IOCTL_SET_VM_FOR_FAST_SIZE)
863	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE sizeof(SUPSETVMFORFAST)
864	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_IN sizeof(SUPSETVMFORFAST)
865	#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_OUT sizeof(SUPREQHDR)
866	typedef struct SUPSETVMFORFAST
867	{
868	/** The header. */
869	SUPREQHDR Hdr;
870	union
871	{
872	struct
873	{
874	/** The ring-0 VM handle (pointer). */
875	PVMR0 pVMR0;
876	} In;
877	} u;
878	} SUPSETVMFORFAST, *PSUPSETVMFORFAST;
879	/** @} */
880
881
882	/** @name SUP_IOCTL_GIP_MAP
883	* Map the GIP into user space.
884	* @{
885	*/
886	#define SUP_IOCTL_GIP_MAP SUP_CTL_CODE_SIZE(20, SUP_IOCTL_GIP_MAP_SIZE)
887	#define SUP_IOCTL_GIP_MAP_SIZE sizeof(SUPGIPMAP)
888	#define SUP_IOCTL_GIP_MAP_SIZE_IN sizeof(SUPREQHDR)
889	#define SUP_IOCTL_GIP_MAP_SIZE_OUT sizeof(SUPGIPMAP)
890	typedef struct SUPGIPMAP
891	{
892	/** The header. */
893	SUPREQHDR Hdr;
894	union
895	{
896	struct
897	{
898	/** The physical address of the GIP. */
899	RTHCPHYS HCPhysGip;
900	/** Pointer to the read-only usermode GIP mapping for this session. */
901	R3PTRTYPE(PSUPGLOBALINFOPAGE) pGipR3;
902	/** Pointer to the supervisor mode GIP mapping. */
903	R0PTRTYPE(PSUPGLOBALINFOPAGE) pGipR0;
904	} Out;
905	} u;
906	} SUPGIPMAP, *PSUPGIPMAP;
907	/** @} */
908
909
910	/** @name SUP_IOCTL_GIP_UNMAP
911	* Unmap the GIP.
912	* @{
913	*/
914	#define SUP_IOCTL_GIP_UNMAP SUP_CTL_CODE_SIZE(21, SUP_IOCTL_GIP_UNMAP_SIZE)
915	#define SUP_IOCTL_GIP_UNMAP_SIZE sizeof(SUPGIPUNMAP)
916	#define SUP_IOCTL_GIP_UNMAP_SIZE_IN sizeof(SUPGIPUNMAP)
917	#define SUP_IOCTL_GIP_UNMAP_SIZE_OUT sizeof(SUPGIPUNMAP)
918	typedef struct SUPGIPUNMAP
919	{
920	/** The header. */
921	SUPREQHDR Hdr;
922	} SUPGIPUNMAP, *PSUPGIPUNMAP;
923	/** @} */
924
925
926	/** @name SUP_IOCTL_CALL_SERVICE
927	* Call the a ring-0 service.
928	*
929	* @todo Might have to convert this to a big request, just like
930	* SUP_IOCTL_CALL_VMMR0
931	* @{
932	*/
933	#define SUP_IOCTL_CALL_SERVICE(cbReq) SUP_CTL_CODE_SIZE(22, SUP_IOCTL_CALL_SERVICE_SIZE(cbReq))
934	#define SUP_IOCTL_CALL_SERVICE_SIZE(cbReq) RT_UOFFSETOF(SUPCALLSERVICE, abReqPkt[cbReq])
935	#define SUP_IOCTL_CALL_SERVICE_SIZE_IN(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
936	#define SUP_IOCTL_CALL_SERVICE_SIZE_OUT(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
937	typedef struct SUPCALLSERVICE
938	{
939	/** The header. */
940	SUPREQHDR Hdr;
941	union
942	{
943	struct
944	{
945	/** The service name. */
946	char szName[28];
947	/** Which operation to execute. */
948	uint32_t uOperation;
949	/** Argument to use when no request packet is supplied. */
950	uint64_t u64Arg;
951	} In;
952	} u;
953	/** The request packet passed to SUP. */
954	uint8_t abReqPkt[1];
955	} SUPCALLSERVICE, *PSUPCALLSERVICE;
956	/** @} */
957
958
959	/** @name SUP_IOCTL_LOGGER_SETTINGS
960	* Changes the ring-0 release or debug logger settings.
961	* @{
962	*/
963	#define SUP_IOCTL_LOGGER_SETTINGS(cbStrTab) SUP_CTL_CODE_SIZE(23, SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab))
964	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab) RT_UOFFSETOF(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
965	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE_IN(cbStrTab) RT_UOFFSETOF(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
966	#define SUP_IOCTL_LOGGER_SETTINGS_SIZE_OUT sizeof(SUPREQHDR)
967	typedef struct SUPLOGGERSETTINGS
968	{
969	/** The header. */
970	SUPREQHDR Hdr;
971	union
972	{
973	struct
974	{
975	/** Which logger. */
976	uint32_t fWhich;
977	/** What to do with it. */
978	uint32_t fWhat;
979	/** Offset of the flags setting string. */
980	uint32_t offFlags;
981	/** Offset of the groups setting string. */
982	uint32_t offGroups;
983	/** Offset of the destination setting string. */
984	uint32_t offDestination;
985	/** The string table. */
986	char szStrings[1];
987	} In;
988	} u;
989	} SUPLOGGERSETTINGS, *PSUPLOGGERSETTINGS;
990
991	/** Debug logger. */
992	#define SUPLOGGERSETTINGS_WHICH_DEBUG 0
993	/** Release logger. */
994	#define SUPLOGGERSETTINGS_WHICH_RELEASE 1
995
996	/** Change the settings. */
997	#define SUPLOGGERSETTINGS_WHAT_SETTINGS 0
998	/** Create the logger instance. */
999	#define SUPLOGGERSETTINGS_WHAT_CREATE 1
1000	/** Destroy the logger instance. */
1001	#define SUPLOGGERSETTINGS_WHAT_DESTROY 2
1002
1003	/** @} */
1004
1005
1006	/** @name Semaphore Types
1007	* @{ */
1008	#define SUP_SEM_TYPE_EVENT 0
1009	#define SUP_SEM_TYPE_EVENT_MULTI 1
1010	/** @} */
1011
1012
1013	/** @name SUP_IOCTL_SEM_CREATE
1014	* Create a semaphore
1015	* @{
1016	*/
1017	#define SUP_IOCTL_SEM_CREATE SUP_CTL_CODE_SIZE(24, SUP_IOCTL_SEM_CREATE_SIZE)
1018	#define SUP_IOCTL_SEM_CREATE_SIZE sizeof(SUPSEMCREATE)
1019	#define SUP_IOCTL_SEM_CREATE_SIZE_IN sizeof(SUPSEMCREATE)
1020	#define SUP_IOCTL_SEM_CREATE_SIZE_OUT sizeof(SUPSEMCREATE)
1021	typedef struct SUPSEMCREATE
1022	{
1023	/** The header. */
1024	SUPREQHDR Hdr;
1025	union
1026	{
1027	struct
1028	{
1029	/** The semaphore type. */
1030	uint32_t uType;
1031	} In;
1032	struct
1033	{
1034	/** The handle of the created semaphore. */
1035	uint32_t hSem;
1036	} Out;
1037	} u;
1038	} SUPSEMCREATE, *PSUPSEMCREATE;
1039
1040	/** @} */
1041
1042
1043	/** @name SUP_IOCTL_SEM_OP
1044	* Semaphore operations.
1045	* @{
1046	*/
1047	#define SUP_IOCTL_SEM_OP SUP_CTL_CODE_SIZE(25, SUP_IOCTL_SEM_OP_SIZE)
1048	#define SUP_IOCTL_SEM_OP_SIZE sizeof(SUPSEMOP)
1049	#define SUP_IOCTL_SEM_OP_SIZE_IN sizeof(SUPSEMOP)
1050	#define SUP_IOCTL_SEM_OP_SIZE_OUT sizeof(SUPREQHDR)
1051	typedef struct SUPSEMOP
1052	{
1053	/** The header. */
1054	SUPREQHDR Hdr;
1055	union
1056	{
1057	struct
1058	{
1059	/** The semaphore type. */
1060	uint32_t uType;
1061	/** The semaphore handle. */
1062	uint32_t hSem;
1063	/** The operation. */
1064	uint32_t uOp;
1065	/** The number of milliseconds to wait if it's a wait operation. */
1066	uint32_t cMillies;
1067	} In;
1068	} u;
1069	} SUPSEMOP, *PSUPSEMOP;
1070
1071	/** Wait for a number of millisecons. */
1072	#define SUPSEMOP_WAIT 0
1073	/** Signal the semaphore. */
1074	#define SUPSEMOP_SIGNAL 1
1075	/** Reset the sempahore (only applicable to SUP_SEM_TYPE_EVENT_MULTI). */
1076	#define SUPSEMOP_RESET 2
1077	/** Close the semaphore handle. */
1078	#define SUPSEMOP_CLOSE 3
1079
1080	/** @} */
1081
1082
1083	#pragma pack() /* paranoia */
1084
1085	#endif
1086

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

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

Download in other formats: