sup.h@ 20862

Last change on this file since 20862 was 20862, checked in by vboxsync, 15 years ago
SUP: Made SUPPageLock and SUPPageUnlock internal to SUP.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 40.9 KB

Line
1	/** @file
2	* SUP - Support Library.
3	*/
4
5	/*
6	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*
16	* The contents of this file may alternatively be used under the terms
17	* of the Common Development and Distribution License Version 1.0
18	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19	* VirtualBox OSE distribution, in which case the provisions of the
20	* CDDL are applicable instead of those of the GPL.
21	*
22	* You may elect to license modified versions of this file under the
23	* terms and conditions of either the GPL or the CDDL or both.
24	*
25	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
26	* Clara, CA 95054 USA or visit http://www.sun.com if you need
27	* additional information or have any questions.
28	*/
29
30	#ifndef ___VBox_sup_h
31	#define ___VBox_sup_h
32
33	#include <VBox/cdefs.h>
34	#include <VBox/types.h>
35	#include <iprt/assert.h>
36	#include <iprt/stdarg.h>
37	#include <iprt/asm.h>
38
39	RT_C_DECLS_BEGIN
40
41	/** @defgroup grp_sup The Support Library API
42	* @{
43	*/
44
45	/**
46	* Physical page descriptor.
47	*/
48	#pragma pack(4) /* space is more important. */
49	typedef struct SUPPAGE
50	{
51	/** Physical memory address. */
52	RTHCPHYS Phys;
53	/** Reserved entry for internal use by the caller. */
54	RTHCUINTPTR uReserved;
55	} SUPPAGE;
56	#pragma pack()
57	/** Pointer to a page descriptor. */
58	typedef SUPPAGE *PSUPPAGE;
59	/** Pointer to a const page descriptor. */
60	typedef const SUPPAGE *PCSUPPAGE;
61
62	/**
63	* The paging mode.
64	*
65	* @remarks Users are making assumptions about the order here!
66	*/
67	typedef enum SUPPAGINGMODE
68	{
69	/** The usual invalid entry.
70	* This is returned by SUPGetPagingMode() */
71	SUPPAGINGMODE_INVALID = 0,
72	/** Normal 32-bit paging, no global pages */
73	SUPPAGINGMODE_32_BIT,
74	/** Normal 32-bit paging with global pages. */
75	SUPPAGINGMODE_32_BIT_GLOBAL,
76	/** PAE mode, no global pages, no NX. */
77	SUPPAGINGMODE_PAE,
78	/** PAE mode with global pages. */
79	SUPPAGINGMODE_PAE_GLOBAL,
80	/** PAE mode with NX, no global pages. */
81	SUPPAGINGMODE_PAE_NX,
82	/** PAE mode with global pages and NX. */
83	SUPPAGINGMODE_PAE_GLOBAL_NX,
84	/** AMD64 mode, no global pages. */
85	SUPPAGINGMODE_AMD64,
86	/** AMD64 mode with global pages, no NX. */
87	SUPPAGINGMODE_AMD64_GLOBAL,
88	/** AMD64 mode with NX, no global pages. */
89	SUPPAGINGMODE_AMD64_NX,
90	/** AMD64 mode with global pages and NX. */
91	SUPPAGINGMODE_AMD64_GLOBAL_NX
92	} SUPPAGINGMODE;
93
94
95	#pragma pack(1) /* paranoia */
96
97	/**
98	* Per CPU data.
99	* This is only used when
100	*/
101	typedef struct SUPGIPCPU
102	{
103	/** Update transaction number.
104	* This number is incremented at the start and end of each update. It follows
105	* thusly that odd numbers indicates update in progress, while even numbers
106	* indicate stable data. Use this to make sure that the data items you fetch
107	* are consistent. */
108	volatile uint32_t u32TransactionId;
109	/** The interval in TSC ticks between two NanoTS updates.
110	* This is the average interval over the last 2, 4 or 8 updates + a little slack.
111	* The slack makes the time go a tiny tiny bit slower and extends the interval enough
112	* to avoid ending up with too many 1ns increments. */
113	volatile uint32_t u32UpdateIntervalTSC;
114	/** Current nanosecond timestamp. */
115	volatile uint64_t u64NanoTS;
116	/** The TSC at the time of u64NanoTS. */
117	volatile uint64_t u64TSC;
118	/** Current CPU Frequency. */
119	volatile uint64_t u64CpuHz;
120	/** Number of errors during updating.
121	* Typical errors are under/overflows. */
122	volatile uint32_t cErrors;
123	/** Index of the head item in au32TSCHistory. */
124	volatile uint32_t iTSCHistoryHead;
125	/** Array of recent TSC interval deltas.
126	* The most recent item is at index iTSCHistoryHead.
127	* This history is used to calculate u32UpdateIntervalTSC.
128	*/
129	volatile uint32_t au32TSCHistory[8];
130	/** Reserved for future per processor data. */
131	volatile uint32_t au32Reserved[6];
132	} SUPGIPCPU;
133	AssertCompileSize(SUPGIPCPU, 96);
134	/AssertCompileMemberAlignment(SUPGIPCPU, u64TSC, 8); -fixme /
135
136	/** Pointer to per cpu data.
137	* @remark there is no const version of this typedef, see g_pSUPGlobalInfoPage for details. */
138	typedef SUPGIPCPU *PSUPGIPCPU;
139
140	/**
141	* Global Information Page.
142	*
143	* This page contains useful information and can be mapped into any
144	* process or VM. It can be accessed thru the g_pSUPGlobalInfoPage
145	* pointer when a session is open.
146	*/
147	typedef struct SUPGLOBALINFOPAGE
148	{
149	/** Magic (SUPGLOBALINFOPAGE_MAGIC). */
150	uint32_t u32Magic;
151	/** The GIP version. */
152	uint32_t u32Version;
153
154	/** The GIP update mode, see SUPGIPMODE. */
155	uint32_t u32Mode;
156	/** Reserved / padding. */
157	uint32_t u32Padding0;
158	/** The update frequency of the of the NanoTS. */
159	volatile uint32_t u32UpdateHz;
160	/** The update interval in nanoseconds. (10^9 / u32UpdateHz) */
161	volatile uint32_t u32UpdateIntervalNS;
162	/** The timestamp of the last time we update the update frequency. */
163	volatile uint64_t u64NanoTSLastUpdateHz;
164
165	/** Padding / reserved space for future data. */
166	uint32_t au32Padding1[56];
167
168	/** Array of per-cpu data.
169	* If u32Mode == SUPGIPMODE_SYNC_TSC then only the first entry is used.
170	* If u32Mode == SUPGIPMODE_ASYNC_TSC then the CPU ACPI ID is used as an
171	* index into the array. */
172	SUPGIPCPU aCPUs[32];
173	} SUPGLOBALINFOPAGE;
174	AssertCompile(sizeof(SUPGLOBALINFOPAGE) <= 0x1000);
175	/* AssertCompileMemberAlignment(SUPGLOBALINFOPAGE, aCPU, 32); - fixme */
176
177	/** Pointer to the global info page.
178	* @remark there is no const version of this typedef, see g_pSUPGlobalInfoPage for details. */
179	typedef SUPGLOBALINFOPAGE *PSUPGLOBALINFOPAGE;
180
181	#pragma pack() /* end of paranoia */
182
183	/** The value of the SUPGLOBALINFOPAGE::u32Magic field. (Soryo Fuyumi) */
184	#define SUPGLOBALINFOPAGE_MAGIC 0x19590106
185	/** The GIP version.
186	* Upper 16 bits is the major version. Major version is only changed with
187	* incompatible changes in the GIP. */
188	#define SUPGLOBALINFOPAGE_VERSION 0x00020000
189
190	/**
191	* SUPGLOBALINFOPAGE::u32Mode values.
192	*/
193	typedef enum SUPGIPMODE
194	{
195	/** The usual invalid null entry. */
196	SUPGIPMODE_INVALID = 0,
197	/** The TSC of the cores and cpus in the system is in sync. */
198	SUPGIPMODE_SYNC_TSC,
199	/** Each core has it's own TSC. */
200	SUPGIPMODE_ASYNC_TSC,
201	/** The usual 32-bit hack. */
202	SUPGIPMODE_32BIT_HACK = 0x7fffffff
203	} SUPGIPMODE;
204
205	/** Pointer to the Global Information Page.
206	*
207	* This pointer is valid as long as SUPLib has a open session. Anyone using
208	* the page must treat this pointer as higly volatile and not trust it beyond
209	* one transaction.
210	*
211	* @remark The GIP page is read-only to everyone but the support driver and
212	* is actually mapped read only everywhere but in ring-0. However
213	* it is not marked 'const' as this might confuse compilers into
214	* thinking that values doesn't change even if members are marked
215	* as volatile. Thus, there is no PCSUPGLOBALINFOPAGE type.
216	*/
217	#if defined(IN_SUP_R0) \|\| defined(IN_SUP_R3) \|\| defined(IN_SUP_GC)
218	extern DECLEXPORT(PSUPGLOBALINFOPAGE) g_pSUPGlobalInfoPage;
219	#elif defined(IN_RING0)
220	extern DECLIMPORT(SUPGLOBALINFOPAGE) g_SUPGlobalInfoPage;
221	# if defined(__GNUC__) && !defined(RT_OS_DARWIN) && defined(RT_ARCH_AMD64)
222	/** Workaround for ELF+GCC problem on 64-bit hosts.
223	* (GCC emits a mov with a R_X86_64_32 reloc, we need R_X86_64_64.) */
224	DECLINLINE(PSUPGLOBALINFOPAGE) SUPGetGIP(void)
225	{
226	PSUPGLOBALINFOPAGE pGIP;
227	__asm__ __volatile__ ("movabs $g_SUPGlobalInfoPage,%0\n\t"
228	: "=a" (pGIP));
229	return pGIP;
230	}
231	# define g_pSUPGlobalInfoPage (SUPGetGIP())
232	# else
233	# define g_pSUPGlobalInfoPage (&g_SUPGlobalInfoPage)
234	# endif
235	#else
236	extern DECLIMPORT(PSUPGLOBALINFOPAGE) g_pSUPGlobalInfoPage;
237	#endif
238
239
240	/**
241	* Gets the TSC frequency of the calling CPU.
242	*
243	* @returns TSC frequency.
244	* @param pGip The GIP pointer.
245	*/
246	DECLINLINE(uint64_t) SUPGetCpuHzFromGIP(PSUPGLOBALINFOPAGE pGip)
247	{
248	unsigned iCpu;
249
250	if (RT_UNLIKELY(!pGip \|\| pGip->u32Magic != SUPGLOBALINFOPAGE_MAGIC))
251	return ~(uint64_t)0;
252
253	if (pGip->u32Mode != SUPGIPMODE_ASYNC_TSC)
254	iCpu = 0;
255	else
256	{
257	iCpu = ASMGetApicId();
258	if (RT_UNLIKELY(iCpu >= RT_ELEMENTS(pGip->aCPUs)))
259	return ~(uint64_t)0;
260	}
261
262	return pGip->aCPUs[iCpu].u64CpuHz;
263	}
264
265
266	/**
267	* Request for generic VMMR0Entry calls.
268	*/
269	typedef struct SUPVMMR0REQHDR
270	{
271	/** The magic. (SUPVMMR0REQHDR_MAGIC) */
272	uint32_t u32Magic;
273	/** The size of the request. */
274	uint32_t cbReq;
275	} SUPVMMR0REQHDR;
276	/** Pointer to a ring-0 request header. */
277	typedef SUPVMMR0REQHDR *PSUPVMMR0REQHDR;
278	/** the SUPVMMR0REQHDR::u32Magic value (Ethan Iverson - The Bad Plus). */
279	#define SUPVMMR0REQHDR_MAGIC UINT32_C(0x19730211)
280
281
282	/** For the fast ioctl path.
283	* @{
284	*/
285	/** @see VMMR0_DO_RAW_RUN. */
286	#define SUP_VMMR0_DO_RAW_RUN 0
287	/** @see VMMR0_DO_HWACC_RUN. */
288	#define SUP_VMMR0_DO_HWACC_RUN 1
289	/** @see VMMR0_DO_NOP */
290	#define SUP_VMMR0_DO_NOP 2
291	/** @} */
292
293
294	/**
295	* Request for generic FNSUPR0SERVICEREQHANDLER calls.
296	*/
297	typedef struct SUPR0SERVICEREQHDR
298	{
299	/** The magic. (SUPR0SERVICEREQHDR_MAGIC) */
300	uint32_t u32Magic;
301	/** The size of the request. */
302	uint32_t cbReq;
303	} SUPR0SERVICEREQHDR;
304	/** Pointer to a ring-0 service request header. */
305	typedef SUPR0SERVICEREQHDR *PSUPR0SERVICEREQHDR;
306	/** the SUPVMMR0REQHDR::u32Magic value (Esbjoern Svensson - E.S.P.). */
307	#define SUPR0SERVICEREQHDR_MAGIC UINT32_C(0x19640416)
308
309
310	/** Event semaphore handle. Ring-0 / ring-3. */
311	typedef R0PTRTYPE(struct SUPSEMEVENTHANDLE *) SUPSEMEVENT;
312	/** Pointer to an event semaphore handle. */
313	typedef SUPSEMEVENT *PSUPSEMEVENT;
314	/** Nil event semaphore handle. */
315	#define NIL_SUPSEMEVENT ((SUPSEMEVENT)0)
316
317	/**
318	* Creates a single release event semaphore.
319	*
320	* @returns VBox status code.
321	* @param pSession The session handle of the caller.
322	* @param phEvent Where to return the handle to the event semaphore.
323	*/
324	SUPDECL(int) SUPSemEventCreate(PSUPDRVSESSION pSession, PSUPSEMEVENT phEvent);
325
326	/**
327	* Closes a single release event semaphore handle.
328	*
329	* @returns VBox status code.
330	* @retval VINF_OBJECT_DESTROYED if the semaphore was destroyed.
331	* @retval VINF_SUCCESS if the handle was successfully closed but the sempahore
332	* object remained alive because of other references.
333	*
334	* @param pSession The session handle of the caller.
335	* @param hEvent The handle. Nil is quietly ignored.
336	*/
337	SUPDECL(int) SUPSemEventClose(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent);
338
339	/**
340	* Signals a single release event semaphore.
341	*
342	* @returns VBox status code.
343	* @param pSession The session handle of the caller.
344	* @param hEvent The semaphore handle.
345	*/
346	SUPDECL(int) SUPSemEventSignal(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent);
347
348	#ifdef IN_RING0
349	/**
350	* Waits on a single release event semaphore, not interruptible.
351	*
352	* @returns VBox status code.
353	* @param pSession The session handle of the caller.
354	* @param hEvent The semaphore handle.
355	* @param cMillies The number of milliseconds to wait.
356	* @remarks Not available in ring-3.
357	*/
358	SUPDECL(int) SUPSemEventWait(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies);
359	#endif
360
361	/**
362	* Waits on a single release event semaphore, interruptible.
363	*
364	* @returns VBox status code.
365	* @param pSession The session handle of the caller.
366	* @param hEvent The semaphore handle.
367	* @param cMillies The number of milliseconds to wait.
368	*/
369	SUPDECL(int) SUPSemEventWaitNoResume(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies);
370
371
372	/** Multiple release event semaphore handle. Ring-0 / ring-3. */
373	typedef R0PTRTYPE(struct SUPSEMEVENTMULTIHANDLE *) SUPSEMEVENTMULTI;
374	/** Pointer to an multiple release event semaphore handle. */
375	typedef SUPSEMEVENTMULTI *PSUPSEMEVENTMULTI;
376	/** Nil multiple release event semaphore handle. */
377	#define NIL_SUPSEMEVENTMULTI ((SUPSEMEVENTMULTI)0)
378
379	/**
380	* Creates a multiple release event semaphore.
381	*
382	* @returns VBox status code.
383	* @param pSession The session handle of the caller.
384	* @param phEventMulti Where to return the handle to the event semaphore.
385	*/
386	SUPDECL(int) SUPSemEventMultiCreate(PSUPDRVSESSION pSession, PSUPSEMEVENTMULTI phEventMulti);
387
388	/**
389	* Closes a multiple release event semaphore handle.
390	*
391	* @returns VBox status code.
392	* @retval VINF_OBJECT_DESTROYED if the semaphore was destroyed.
393	* @retval VINF_SUCCESS if the handle was successfully closed but the sempahore
394	* object remained alive because of other references.
395	*
396	* @param pSession The session handle of the caller.
397	* @param hEventMulti The handle. Nil is quietly ignored.
398	*/
399	SUPDECL(int) SUPSemEventMultiClose(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
400
401	/**
402	* Signals a multiple release event semaphore.
403	*
404	* @returns VBox status code.
405	* @param pSession The session handle of the caller.
406	* @param hEventMulti The semaphore handle.
407	*/
408	SUPDECL(int) SUPSemEventMultiSignal(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
409
410	/**
411	* Resets a multiple release event semaphore.
412	*
413	* @returns VBox status code.
414	* @param pSession The session handle of the caller.
415	* @param hEventMulti The semaphore handle.
416	*/
417	SUPDECL(int) SUPSemEventMultiReset(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
418
419	#ifdef IN_RING0
420	/**
421	* Waits on a multiple release event semaphore, not interruptible.
422	*
423	* @returns VBox status code.
424	* @param pSession The session handle of the caller.
425	* @param hEventMulti The semaphore handle.
426	* @param cMillies The number of milliseconds to wait.
427	* @remarks Not available in ring-3.
428	*/
429	SUPDECL(int) SUPSemEventMultiWait(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies);
430	#endif
431
432	/**
433	* Waits on a multiple release event semaphore, interruptible.
434	*
435	* @returns VBox status code.
436	* @param pSession The session handle of the caller.
437	* @param hEventMulti The semaphore handle.
438	* @param cMillies The number of milliseconds to wait.
439	*/
440	SUPDECL(int) SUPSemEventMultiWaitNoResume(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies);
441
442
443	#ifdef IN_RING3
444
445	/** @defgroup grp_sup_r3 SUP Host Context Ring 3 API
446	* @ingroup grp_sup
447	* @{
448	*/
449
450	/**
451	* Installs the support library.
452	*
453	* @returns VBox status code.
454	*/
455	SUPR3DECL(int) SUPInstall(void);
456
457	/**
458	* Uninstalls the support library.
459	*
460	* @returns VBox status code.
461	*/
462	SUPR3DECL(int) SUPUninstall(void);
463
464	/**
465	* Trusted main entry point.
466	*
467	* This is exported as "TrustedMain" by the dynamic libraries which contains the
468	* "real" application binary for which the hardened stub is built. The entry
469	* point is invoked upon successfull initialization of the support library and
470	* runtime.
471	*
472	* @returns main kind of exit code.
473	* @param argc The argument count.
474	* @param argv The argument vector.
475	* @param envp The environment vector.
476	*/
477	typedef DECLCALLBACK(int) FNSUPTRUSTEDMAIN(int argc, char argv, char envp);
478	/** Pointer to FNSUPTRUSTEDMAIN(). */
479	typedef FNSUPTRUSTEDMAIN *PFNSUPTRUSTEDMAIN;
480
481	/** Which operation failed. */
482	typedef enum SUPINITOP
483	{
484	/** Invalid. */
485	kSupInitOp_Invalid = 0,
486	/** Installation integrity error. */
487	kSupInitOp_Integrity,
488	/** Setuid related. */
489	kSupInitOp_RootCheck,
490	/** Driver related. */
491	kSupInitOp_Driver,
492	/** IPRT init related. */
493	kSupInitOp_IPRT,
494	/** Place holder. */
495	kSupInitOp_End
496	} SUPINITOP;
497
498	/**
499	* Trusted error entry point, optional.
500	*
501	* This is exported as "TrustedError" by the dynamic libraries which contains
502	* the "real" application binary for which the hardened stub is built.
503	*
504	* @param pszWhere Where the error occured (function name).
505	* @param enmWhat Which operation went wrong.
506	* @param rc The status code.
507	* @param pszMsgFmt Error message format string.
508	* @param va The message format arguments.
509	*/
510	typedef DECLCALLBACK(void) FNSUPTRUSTEDERROR(const char pszWhere, SUPINITOP enmWhat, int rc, const char pszMsgFmt, va_list va);
511	/** Pointer to FNSUPTRUSTEDERROR. */
512	typedef FNSUPTRUSTEDERROR *PFNSUPTRUSTEDERROR;
513
514	/**
515	* Secure main.
516	*
517	* This is used for the set-user-ID-on-execute binaries on unixy systems
518	* and when using the open-vboxdrv-via-root-service setup on Windows.
519	*
520	* This function will perform the integrity checks of the VirtualBox
521	* installation, open the support driver, open the root service (later),
522	* and load the DLL corresponding to \a pszProgName and execute its main
523	* function.
524	*
525	* @returns Return code appropriate for main().
526	*
527	* @param pszProgName The program name. This will be used to figure out which
528	* DLL/SO/DYLIB to load and execute.
529	* @param fFlags Flags.
530	* @param argc The argument count.
531	* @param argv The argument vector.
532	* @param envp The environment vector.
533	*/
534	DECLHIDDEN(int) SUPR3HardenedMain(const char pszProgName, uint32_t fFlags, int argc, char argv, char *envp);
535
536	/** @name SUPR3SecureMain flags.
537	* @{ */
538	/** Don't open the device. (Intended for VirtualBox without -startvm.) */
539	#define SUPSECMAIN_FLAGS_DONT_OPEN_DEV RT_BIT_32(0)
540	/** @} */
541
542	/**
543	* Initializes the support library.
544	* Each succesful call to SUPR3Init() must be countered by a
545	* call to SUPTerm(false).
546	*
547	* @returns VBox status code.
548	* @param ppSession Where to store the session handle. Defaults to NULL.
549	*/
550	SUPR3DECL(int) SUPR3Init(PSUPDRVSESSION *ppSession);
551
552	/**
553	* Terminates the support library.
554	*
555	* @returns VBox status code.
556	* @param fForced Forced termination. This means to ignore the
557	* init call count and just terminated.
558	*/
559	#ifdef __cplusplus
560	SUPR3DECL(int) SUPTerm(bool fForced = false);
561	#else
562	SUPR3DECL(int) SUPTerm(int fForced);
563	#endif
564
565	/**
566	* Sets the ring-0 VM handle for use with fast IOCtls.
567	*
568	* @returns VBox status code.
569	* @param pVMR0 The ring-0 VM handle.
570	* NIL_RTR0PTR can be used to unset the handle when the
571	* VM is about to be destroyed.
572	*/
573	SUPR3DECL(int) SUPSetVMForFastIOCtl(PVMR0 pVMR0);
574
575	/**
576	* Calls the HC R0 VMM entry point.
577	* See VMMR0Entry() for more details.
578	*
579	* @returns error code specific to uFunction.
580	* @param pVMR0 Pointer to the Ring-0 (Host Context) mapping of the VM structure.
581	* @param idCpu The virtual CPU ID.
582	* @param uOperation Operation to execute.
583	* @param pvArg Argument.
584	*/
585	SUPR3DECL(int) SUPCallVMMR0(PVMR0 pVMR0, VMCPUID idCpu, unsigned uOperation, void *pvArg);
586
587	/**
588	* Variant of SUPCallVMMR0, except that this takes the fast ioclt path
589	* regardsless of compile-time defaults.
590	*
591	* @returns VBox status code.
592	* @param pVMR0 The ring-0 VM handle.
593	* @param uOperation The operation; only the SUP_VMMR0_DO_* ones are valid.
594	* @param idCpu The virtual CPU ID.
595	*/
596	SUPR3DECL(int) SUPCallVMMR0Fast(PVMR0 pVMR0, unsigned uOperation, VMCPUID idCpu);
597
598	/**
599	* Calls the HC R0 VMM entry point, in a safer but slower manner than SUPCallVMMR0.
600	* When entering using this call the R0 components can call into the host kernel
601	* (i.e. use the SUPR0 and RT APIs).
602	*
603	* See VMMR0Entry() for more details.
604	*
605	* @returns error code specific to uFunction.
606	* @param pVMR0 Pointer to the Ring-0 (Host Context) mapping of the VM structure.
607	* @param idCpu The virtual CPU ID.
608	* @param uOperation Operation to execute.
609	* @param u64Arg Constant argument.
610	* @param pReqHdr Pointer to a request header. Optional.
611	* This will be copied in and out of kernel space. There currently is a size
612	* limit on this, just below 4KB.
613	*/
614	SUPR3DECL(int) SUPCallVMMR0Ex(PVMR0 pVMR0, VMCPUID idCpu, unsigned uOperation, uint64_t u64Arg, PSUPVMMR0REQHDR pReqHdr);
615
616	/**
617	* Calls a ring-0 service.
618	*
619	* The operation and the request packet is specific to the service.
620	*
621	* @returns error code specific to uFunction.
622	* @param pszService The service name.
623	* @param cchService The length of the service name.
624	* @param uReq The request number.
625	* @param u64Arg Constant argument.
626	* @param pReqHdr Pointer to a request header. Optional.
627	* This will be copied in and out of kernel space. There currently is a size
628	* limit on this, just below 4KB.
629	*/
630	SUPR3DECL(int) SUPR3CallR0Service(const char *pszService, size_t cchService, uint32_t uOperation, uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr);
631
632	/** Which logger. */
633	typedef enum SUPLOGGER
634	{
635	SUPLOGGER_DEBUG = 1,
636	SUPLOGGER_RELEASE
637	} SUPLOGGER;
638
639	/**
640	* Changes the settings of the specified ring-0 logger.
641	*
642	* @returns VBox status code.
643	* @param enmWhich Which logger.
644	* @param pszFlags The flags settings.
645	* @param pszGroups The groups settings.
646	* @param pszDest The destionation specificier.
647	*/
648	SUPR3DECL(int) SUPR3LoggerSettings(SUPLOGGER enmWhich, const char pszFlags, const char pszGroups, const char *pszDest);
649
650	/**
651	* Creates a ring-0 logger instance.
652	*
653	* @returns VBox status code.
654	* @param enmWhich Which logger to create.
655	* @param pszFlags The flags settings.
656	* @param pszGroups The groups settings.
657	* @param pszDest The destionation specificier.
658	*/
659	SUPR3DECL(int) SUPR3LoggerCreate(SUPLOGGER enmWhich, const char pszFlags, const char pszGroups, const char *pszDest);
660
661	/**
662	* Destroys a ring-0 logger instance.
663	*
664	* @returns VBox status code.
665	* @param enmWhich Which logger.
666	*/
667	SUPR3DECL(int) SUPR3LoggerDestroy(SUPLOGGER enmWhich);
668
669	/**
670	* Queries the paging mode of the host OS.
671	*
672	* @returns The paging mode.
673	*/
674	SUPR3DECL(SUPPAGINGMODE) SUPGetPagingMode(void);
675
676	/**
677	* Allocate zero-filled pages.
678	*
679	* Use this to allocate a number of pages rather than using RTMem*() and mess with
680	* alignment. The returned address is of course page aligned. Call SUPPageFree()
681	* to free the pages once done with them.
682	*
683	* @returns VBox status.
684	* @param cPages Number of pages to allocate.
685	* @param ppvPages Where to store the base pointer to the allocated pages.
686	*/
687	SUPR3DECL(int) SUPPageAlloc(size_t cPages, void **ppvPages);
688
689	/**
690	* Frees pages allocated with SUPPageAlloc().
691	*
692	* @returns VBox status.
693	* @param pvPages Pointer returned by SUPPageAlloc().
694	* @param cPages Number of pages that was allocated.
695	*/
696	SUPR3DECL(int) SUPPageFree(void *pvPages, size_t cPages);
697
698	/**
699	* Allocate non-zeroed, locked, pages with user and, optionally, kernel
700	* mappings.
701	*
702	* Use SUPR3PageFreeEx() to free memory allocated with this function.
703	*
704	* This SUPR3PageAllocEx and SUPR3PageFreeEx replaces SUPPageAllocLocked,
705	* SUPPageAllocLockedEx, SUPPageFreeLocked, SUPPageAlloc, SUPPageLock,
706	* SUPPageUnlock and SUPPageFree.
707	*
708	* @returns VBox status code.
709	* @param cPages The number of pages to allocate.
710	* @param fFlags Flags, reserved. Must be zero.
711	* @param ppvPages Where to store the address of the user mapping.
712	* @param pR0Ptr Where to store the address of the kernel mapping.
713	* NULL if no kernel mapping is desired.
714	* @param paPages Where to store the physical addresses of each page.
715	* Optional.
716	*/
717	SUPR3DECL(int) SUPR3PageAllocEx(size_t cPages, uint32_t fFlags, void **ppvPages, PRTR0PTR pR0Ptr, PSUPPAGE paPages);
718
719	/**
720	* Maps a portion of a ring-3 only allocation into kernel space.
721	*
722	* @returns VBox status code.
723	*
724	* @param pvR3 The address SUPR3PageAllocEx return.
725	* @param off Offset to start mapping at. Must be page aligned.
726	* @param cb Number of bytes to map. Must be page aligned.
727	* @param fFlags Flags, must be zero.
728	* @param pR0Ptr Where to store the address on success.
729	*
730	*/
731	SUPR3DECL(int) SUPR3PageMapKernel(void *pvR3, uint32_t off, uint32_t cb, uint32_t fFlags, PRTR0PTR pR0Ptr);
732
733	/**
734	* Changes the protection of
735	*
736	* @returns VBox status code.
737	* @retval VERR_NOT_SUPPORTED if the OS doesn't allow us to change page level
738	* protection. See also RTR0MemObjProtect.
739	*
740	* @param pvR3 The ring-3 address SUPR3PageAllocEx returned.
741	* @param R0Ptr The ring-0 address SUPR3PageAllocEx returned if it
742	* is desired that the corresponding ring-0 page
743	* mappings should change protection as well. Pass
744	* NIL_RTR0PTR if the ring-0 pages should remain
745	* unaffected.
746	* @param off Offset to start at which to start chagning the page
747	* level protection. Must be page aligned.
748	* @param cb Number of bytes to change. Must be page aligned.
749	* @param fProt The new page level protection, either a combination
750	* of RTMEM_PROT_READ, RTMEM_PROT_WRITE and
751	* RTMEM_PROT_EXEC, or just RTMEM_PROT_NONE.
752	*/
753	SUPR3DECL(int) SUPR3PageProtect(void *pvR3, RTR0PTR R0Ptr, uint32_t off, uint32_t cb, uint32_t fProt);
754
755	/**
756	* Free pages allocated by SUPR3PageAllocEx.
757	*
758	* @returns VBox status code.
759	* @param pvPages The address of the user mapping.
760	* @param cPages The number of pages.
761	*/
762	SUPR3DECL(int) SUPR3PageFreeEx(void *pvPages, size_t cPages);
763
764	/**
765	* Allocate non-zeroed locked pages.
766	*
767	* Use this to allocate a number of pages rather than using RTMem*() and mess with
768	* alignment. The returned address is of course page aligned. Call SUPPageFreeLocked()
769	* to free the pages once done with them.
770	*
771	* @returns VBox status code.
772	* @param cPages Number of pages to allocate.
773	* @param ppvPages Where to store the base pointer to the allocated pages.
774	* @param paPages Where to store the physical page addresses returned.
775	* On entry this will point to an array of with cbMemory >> PAGE_SHIFT entries.
776	* NULL is allowed.
777	*/
778	SUPR3DECL(int) SUPPageAllocLockedEx(size_t cPages, void **ppvPages, PSUPPAGE paPages);
779
780	/**
781	* Frees locked pages allocated with SUPPageAllocLocked().
782	*
783	* @returns VBox status.
784	* @param pvPages Pointer returned by SUPPageAlloc().
785	* @param cPages Number of pages that was allocated.
786	*/
787	SUPR3DECL(int) SUPPageFreeLocked(void *pvPages, size_t cPages);
788
789	/**
790	* Allocated memory with page aligned memory with a contiguous and locked physical
791	* memory backing below 4GB.
792	*
793	* @returns Pointer to the allocated memory (virtual address).
794	* *pHCPhys is set to the physical address of the memory.
795	* The returned memory must be freed using SUPContFree().
796	* @returns NULL on failure.
797	* @param cPages Number of pages to allocate.
798	* @param pHCPhys Where to store the physical address of the memory block.
799	*/
800	SUPR3DECL(void *) SUPContAlloc(size_t cPages, PRTHCPHYS pHCPhys);
801
802	/**
803	* Allocated memory with page aligned memory with a contiguous and locked physical
804	* memory backing below 4GB.
805	*
806	* @returns Pointer to the allocated memory (virtual address).
807	* *pHCPhys is set to the physical address of the memory.
808	* If ppvR0 isn't NULL, *ppvR0 is set to the ring-0 mapping.
809	* The returned memory must be freed using SUPContFree().
810	* @returns NULL on failure.
811	* @param cPages Number of pages to allocate.
812	* @param pR0Ptr Where to store the ring-0 mapping of the allocation. (optional)
813	* @param pHCPhys Where to store the physical address of the memory block.
814	*
815	* @remark This 2nd version of this API exists because we're not able to map the
816	* ring-3 mapping executable on WIN64. This is a serious problem in regard to
817	* the world switchers.
818	*/
819	SUPR3DECL(void *) SUPContAlloc2(size_t cPages, PRTR0PTR pR0Ptr, PRTHCPHYS pHCPhys);
820
821	/**
822	* Frees memory allocated with SUPContAlloc().
823	*
824	* @returns VBox status code.
825	* @param pv Pointer to the memory block which should be freed.
826	* @param cPages Number of pages to be freed.
827	*/
828	SUPR3DECL(int) SUPContFree(void *pv, size_t cPages);
829
830	/**
831	* Allocated non contiguous physical memory below 4GB.
832	*
833	* The memory isn't zeroed.
834	*
835	* @returns VBox status code.
836	* @returns NULL on failure.
837	* @param cPages Number of pages to allocate.
838	* @param ppvPages Where to store the pointer to the allocated memory.
839	* The pointer stored here on success must be passed to SUPLowFree when
840	* the memory should be released.
841	* @param ppvPagesR0 Where to store the ring-0 pointer to the allocated memory. optional.
842	* @param paPages Where to store the physical addresses of the individual pages.
843	*/
844	SUPR3DECL(int) SUPLowAlloc(size_t cPages, void **ppvPages, PRTR0PTR ppvPagesR0, PSUPPAGE paPages);
845
846	/**
847	* Frees memory allocated with SUPLowAlloc().
848	*
849	* @returns VBox status code.
850	* @param pv Pointer to the memory block which should be freed.
851	* @param cPages Number of pages that was allocated.
852	*/
853	SUPR3DECL(int) SUPLowFree(void *pv, size_t cPages);
854
855	/**
856	* Load a module into R0 HC.
857	*
858	* This will verify the file integrity in a similar manner as
859	* SUPR3HardenedVerifyFile before loading it.
860	*
861	* @returns VBox status code.
862	* @param pszFilename The path to the image file.
863	* @param pszModule The module name. Max 32 bytes.
864	* @param ppvImageBase Where to store the image address.
865	*/
866	SUPR3DECL(int) SUPLoadModule(const char pszFilename, const char pszModule, void **ppvImageBase);
867
868	/**
869	* Load a module into R0 HC.
870	*
871	* This will verify the file integrity in a similar manner as
872	* SUPR3HardenedVerifyFile before loading it.
873	*
874	* @returns VBox status code.
875	* @param pszFilename The path to the image file.
876	* @param pszModule The module name. Max 32 bytes.
877	* @param pszSrvReqHandler The name of the service request handler entry
878	* point. See FNSUPR0SERVICEREQHANDLER.
879	* @param ppvImageBase Where to store the image address.
880	*/
881	SUPR3DECL(int) SUPR3LoadServiceModule(const char pszFilename, const char pszModule,
882	const char pszSrvReqHandler, void *ppvImageBase);
883
884	/**
885	* Frees a R0 HC module.
886	*
887	* @returns VBox status code.
888	* @param pszModule The module to free.
889	* @remark This will not actually 'free' the module, there are of course usage counting.
890	*/
891	SUPR3DECL(int) SUPFreeModule(void *pvImageBase);
892
893	/**
894	* Get the address of a symbol in a ring-0 module.
895	*
896	* @returns VBox status code.
897	* @param pszModule The module name.
898	* @param pszSymbol Symbol name. If it's value is less than 64k it's treated like a
899	* ordinal value rather than a string pointer.
900	* @param ppvValue Where to store the symbol value.
901	*/
902	SUPR3DECL(int) SUPGetSymbolR0(void pvImageBase, const char pszSymbol, void **ppvValue);
903
904	/**
905	* Load R0 HC VMM code.
906	*
907	* @returns VBox status code.
908	* @deprecated Use SUPLoadModule(pszFilename, "VMMR0.r0", &pvImageBase)
909	*/
910	SUPR3DECL(int) SUPLoadVMM(const char *pszFilename);
911
912	/**
913	* Unloads R0 HC VMM code.
914	*
915	* @returns VBox status code.
916	* @deprecated Use SUPFreeModule().
917	*/
918	SUPR3DECL(int) SUPUnloadVMM(void);
919
920	/**
921	* Get the physical address of the GIP.
922	*
923	* @returns VBox status code.
924	* @param pHCPhys Where to store the physical address of the GIP.
925	*/
926	SUPR3DECL(int) SUPGipGetPhys(PRTHCPHYS pHCPhys);
927
928	/**
929	* Verifies the integrity of a file, and optionally opens it.
930	*
931	* The integrity check is for whether the file is suitable for loading into
932	* the hypervisor or VM process. The integrity check may include verifying
933	* the authenticode/elfsign/whatever signature of the file, which can take
934	* a little while.
935	*
936	* @returns VBox status code. On failure it will have printed a LogRel message.
937	*
938	* @param pszFilename The file.
939	* @param pszWhat For the LogRel on failure.
940	* @param phFile Where to store the handle to the opened file. This is optional, pass NULL
941	* if the file should not be opened.
942	*/
943	SUPR3DECL(int) SUPR3HardenedVerifyFile(const char pszFilename, const char pszWhat, PRTFILE phFile);
944
945	/**
946	* Same as RTLdrLoad() but will verify the files it loads (hardened builds).
947	*
948	* Will add dll suffix if missing and try load the file.
949	*
950	* @returns iprt status code.
951	* @param pszFilename Image filename. This must have a path.
952	* @param phLdrMod Where to store the handle to the loaded module.
953	*/
954	SUPR3DECL(int) SUPR3HardenedLdrLoad(const char *pszFilename, PRTLDRMOD phLdrMod);
955
956	/**
957	* Same as RTLdrLoadAppPriv() but it will verify the files it loads (hardened
958	* builds).
959	*
960	* Will add dll suffix to the file if missing, then look for it in the
961	* architecture dependent application directory.
962	*
963	* @returns iprt status code.
964	* @param pszFilename Image filename.
965	* @param phLdrMod Where to store the handle to the loaded module.
966	*/
967	SUPR3DECL(int) SUPR3HardenedLdrLoadAppPriv(const char *pszFilename, PRTLDRMOD phLdrMod);
968
969	/** @} */
970	#endif /* IN_RING3 */
971
972
973	#ifdef IN_RING0
974	/** @defgroup grp_sup_r0 SUP Host Context Ring 0 API
975	* @ingroup grp_sup
976	* @{
977	*/
978
979	/**
980	* Security objectype.
981	*/
982	typedef enum SUPDRVOBJTYPE
983	{
984	/** The usual invalid object. */
985	SUPDRVOBJTYPE_INVALID = 0,
986	/** A Virtual Machine instance. */
987	SUPDRVOBJTYPE_VM,
988	/** Internal network. */
989	SUPDRVOBJTYPE_INTERNAL_NETWORK,
990	/** Internal network interface. */
991	SUPDRVOBJTYPE_INTERNAL_NETWORK_INTERFACE,
992	/** Single release event semaphore. */
993	SUPDRVOBJTYPE_SEM_EVENT,
994	/** Multiple release event semaphore. */
995	SUPDRVOBJTYPE_SEM_EVENT_MULTI,
996	/** The first invalid object type in this end. */
997	SUPDRVOBJTYPE_END,
998	/** The usual 32-bit type size hack. */
999	SUPDRVOBJTYPE_32_BIT_HACK = 0x7ffffff
1000	} SUPDRVOBJTYPE;
1001
1002	/**
1003	* Object destructor callback.
1004	* This is called for reference counted objectes when the count reaches 0.
1005	*
1006	* @param pvObj The object pointer.
1007	* @param pvUser1 The first user argument.
1008	* @param pvUser2 The second user argument.
1009	*/
1010	typedef DECLCALLBACK(void) FNSUPDRVDESTRUCTOR(void pvObj, void pvUser1, void *pvUser2);
1011	/** Pointer to a FNSUPDRVDESTRUCTOR(). */
1012	typedef FNSUPDRVDESTRUCTOR *PFNSUPDRVDESTRUCTOR;
1013
1014	SUPR0DECL(void ) SUPR0ObjRegister(PSUPDRVSESSION pSession, SUPDRVOBJTYPE enmType, PFNSUPDRVDESTRUCTOR pfnDestructor, void pvUser1, void *pvUser2);
1015	SUPR0DECL(int) SUPR0ObjAddRef(void *pvObj, PSUPDRVSESSION pSession);
1016	SUPR0DECL(int) SUPR0ObjAddRefEx(void *pvObj, PSUPDRVSESSION pSession, bool fNoBlocking);
1017	SUPR0DECL(int) SUPR0ObjRelease(void *pvObj, PSUPDRVSESSION pSession);
1018	SUPR0DECL(int) SUPR0ObjVerifyAccess(void pvObj, PSUPDRVSESSION pSession, const char pszObjName);
1019
1020	SUPR0DECL(int) SUPR0LockMem(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages);
1021	SUPR0DECL(int) SUPR0UnlockMem(PSUPDRVSESSION pSession, RTR3PTR pvR3);
1022	SUPR0DECL(int) SUPR0ContAlloc(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS pHCPhys);
1023	SUPR0DECL(int) SUPR0ContFree(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
1024	SUPR0DECL(int) SUPR0LowAlloc(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS paPages);
1025	SUPR0DECL(int) SUPR0LowFree(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
1026	SUPR0DECL(int) SUPR0MemAlloc(PSUPDRVSESSION pSession, uint32_t cb, PRTR0PTR ppvR0, PRTR3PTR ppvR3);
1027	SUPR0DECL(int) SUPR0MemGetPhys(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, PSUPPAGE paPages);
1028	SUPR0DECL(int) SUPR0MemFree(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
1029	SUPR0DECL(int) SUPR0PageAllocEx(PSUPDRVSESSION pSession, uint32_t cPages, uint32_t fFlags, PRTR3PTR ppvR3, PRTR0PTR ppvR0, PRTHCPHYS paPages);
1030	SUPR0DECL(int) SUPR0PageMapKernel(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t offSub, uint32_t cbSub, uint32_t fFlags, PRTR0PTR ppvR0);
1031	SUPR0DECL(int) SUPR0PageProtect(PSUPDRVSESSION pSession, RTR3PTR pvR3, RTR0PTR pvR0, uint32_t offSub, uint32_t cbSub, uint32_t fProt);
1032	SUPR0DECL(int) SUPR0PageFree(PSUPDRVSESSION pSession, RTR3PTR pvR3);
1033	SUPR0DECL(int) SUPR0GipMap(PSUPDRVSESSION pSession, PRTR3PTR ppGipR3, PRTHCPHYS pHCPhysGip);
1034	SUPR0DECL(int) SUPR0GipUnmap(PSUPDRVSESSION pSession);
1035	SUPR0DECL(int) SUPR0Printf(const char *pszFormat, ...);
1036	SUPR0DECL(SUPPAGINGMODE) SUPR0GetPagingMode(void);
1037	SUPR0DECL(int) SUPR0EnableVTx(bool fEnable);
1038
1039	/** @name Absolute symbols
1040	* Take the address of these, don't try call them.
1041	* @{ */
1042	SUPR0DECL(void) SUPR0AbsIs64bit(void);
1043	SUPR0DECL(void) SUPR0Abs64bitKernelCS(void);
1044	SUPR0DECL(void) SUPR0Abs64bitKernelSS(void);
1045	SUPR0DECL(void) SUPR0Abs64bitKernelDS(void);
1046	SUPR0DECL(void) SUPR0AbsKernelCS(void);
1047	SUPR0DECL(void) SUPR0AbsKernelSS(void);
1048	SUPR0DECL(void) SUPR0AbsKernelDS(void);
1049	SUPR0DECL(void) SUPR0AbsKernelES(void);
1050	SUPR0DECL(void) SUPR0AbsKernelFS(void);
1051	SUPR0DECL(void) SUPR0AbsKernelGS(void);
1052	/** @} */
1053
1054	/**
1055	* Support driver component factory.
1056	*
1057	* Component factories are registered by drivers that provides services
1058	* such as the host network interface filtering and access to the host
1059	* TCP/IP stack.
1060	*
1061	* @remark Module dependencies and making sure that a component doesn't
1062	* get unloaded while in use, is the sole responsibility of the
1063	* driver/kext/whatever implementing the component.
1064	*/
1065	typedef struct SUPDRVFACTORY
1066	{
1067	/** The (unique) name of the component factory. */
1068	char szName[56];
1069	/**
1070	* Queries a factory interface.
1071	*
1072	* The factory interface is specific to each component and will be be
1073	* found in the header(s) for the component alongside its UUID.
1074	*
1075	* @returns Pointer to the factory interfaces on success, NULL on failure.
1076	*
1077	* @param pSupDrvFactory Pointer to this structure.
1078	* @param pSession The SUPDRV session making the query.
1079	* @param pszInterfaceUuid The UUID of the factory interface.
1080	*/
1081	DECLR0CALLBACKMEMBER(void , pfnQueryFactoryInterface,(struct SUPDRVFACTORY const pSupDrvFactory, PSUPDRVSESSION pSession, const char *pszInterfaceUuid));
1082	} SUPDRVFACTORY;
1083	/** Pointer to a support driver factory. */
1084	typedef SUPDRVFACTORY *PSUPDRVFACTORY;
1085	/** Pointer to a const support driver factory. */
1086	typedef SUPDRVFACTORY const *PCSUPDRVFACTORY;
1087
1088	SUPR0DECL(int) SUPR0ComponentRegisterFactory(PSUPDRVSESSION pSession, PCSUPDRVFACTORY pFactory);
1089	SUPR0DECL(int) SUPR0ComponentDeregisterFactory(PSUPDRVSESSION pSession, PCSUPDRVFACTORY pFactory);
1090	SUPR0DECL(int) SUPR0ComponentQueryFactory(PSUPDRVSESSION pSession, const char pszName, const char pszInterfaceUuid, void **ppvFactoryIf);
1091
1092
1093	/**
1094	* Service request callback function.
1095	*
1096	* @returns VBox status code.
1097	* @param pSession The caller's session.
1098	* @param u64Arg 64-bit integer argument.
1099	* @param pReqHdr The request header. Input / Output. Optional.
1100	*/
1101	typedef DECLCALLBACK(int) FNSUPR0SERVICEREQHANDLER(PSUPDRVSESSION pSession, uint32_t uOperation,
1102	uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr);
1103	/** Pointer to a FNR0SERVICEREQHANDLER(). */
1104	typedef R0PTRTYPE(FNSUPR0SERVICEREQHANDLER *) PFNSUPR0SERVICEREQHANDLER;
1105
1106
1107	/** @defgroup grp_sup_r0_idc The IDC Interface
1108	* @ingroup grp_sup_r0
1109	* @{
1110	*/
1111
1112	/** The current SUPDRV IDC version.
1113	* This follows the usual high word / low word rules, i.e. high word is the
1114	* major number and it signifies incompatible interface changes. */
1115	#define SUPDRV_IDC_VERSION UINT32_C(0x00010000)
1116
1117	/**
1118	* Inter-Driver Communcation Handle.
1119	*/
1120	typedef union SUPDRVIDCHANDLE
1121	{
1122	/** Padding for opaque usage.
1123	* Must be greater or equal in size than the private struct. */
1124	void *apvPadding[4];
1125	#ifdef SUPDRVIDCHANDLEPRIVATE_DECLARED
1126	/** The private view. */
1127	struct SUPDRVIDCHANDLEPRIVATE s;
1128	#endif
1129	} SUPDRVIDCHANDLE;
1130	/** Pointer to a handle. */
1131	typedef SUPDRVIDCHANDLE *PSUPDRVIDCHANDLE;
1132
1133	SUPR0DECL(int) SUPR0IdcOpen(PSUPDRVIDCHANDLE pHandle, uint32_t uReqVersion, uint32_t uMinVersion,
1134	uint32_t puSessionVersion, uint32_t puDriverVersion, uint32_t *puDriverRevision);
1135	SUPR0DECL(int) SUPR0IdcCall(PSUPDRVIDCHANDLE pHandle, uint32_t iReq, void *pvReq, uint32_t cbReq);
1136	SUPR0DECL(int) SUPR0IdcClose(PSUPDRVIDCHANDLE pHandle);
1137	SUPR0DECL(PSUPDRVSESSION) SUPR0IdcGetSession(PSUPDRVIDCHANDLE pHandle);
1138	SUPR0DECL(int) SUPR0IdcComponentRegisterFactory(PSUPDRVIDCHANDLE pHandle, PCSUPDRVFACTORY pFactory);
1139	SUPR0DECL(int) SUPR0IdcComponentDeregisterFactory(PSUPDRVIDCHANDLE pHandle, PCSUPDRVFACTORY pFactory);
1140
1141	/** @} */
1142
1143	/** @} */
1144	#endif
1145
1146	/** @} */
1147
1148	RT_C_DECLS_END
1149
1150	#endif
1151

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

source: vbox/trunk/include/VBox/sup.h@ 20862

Download in other formats: