VirtualBox

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

Last change on this file since 63284 was 62476, checked in by vboxsync, 8 years ago

(C) 2016

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 82.5 KB
Line 
1/** @file
2 * SUP - Support Library. (HDrv)
3 */
4
5/*
6 * Copyright (C) 2006-2016 Oracle Corporation
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
26#ifndef ___VBox_sup_h
27#define ___VBox_sup_h
28
29#include <VBox/cdefs.h>
30#include <VBox/types.h>
31#include <VBox/err.h>
32#include <iprt/assert.h>
33#include <iprt/stdarg.h>
34#include <iprt/cpuset.h>
35#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
36# include <iprt/asm-amd64-x86.h>
37#endif
38
39RT_C_DECLS_BEGIN
40
41struct VTGOBJHDR;
42struct VTGPROBELOC;
43
44
45/** @defgroup grp_sup The Support Library API
46 * @{
47 */
48
49/**
50 * Physical page descriptor.
51 */
52#pragma pack(4) /* space is more important. */
53typedef struct SUPPAGE
54{
55 /** Physical memory address. */
56 RTHCPHYS Phys;
57 /** Reserved entry for internal use by the caller. */
58 RTHCUINTPTR uReserved;
59} SUPPAGE;
60#pragma pack()
61/** Pointer to a page descriptor. */
62typedef SUPPAGE *PSUPPAGE;
63/** Pointer to a const page descriptor. */
64typedef const SUPPAGE *PCSUPPAGE;
65
66/**
67 * The paging mode.
68 *
69 * @remarks Users are making assumptions about the order here!
70 */
71typedef enum SUPPAGINGMODE
72{
73 /** The usual invalid entry.
74 * This is returned by SUPR3GetPagingMode() */
75 SUPPAGINGMODE_INVALID = 0,
76 /** Normal 32-bit paging, no global pages */
77 SUPPAGINGMODE_32_BIT,
78 /** Normal 32-bit paging with global pages. */
79 SUPPAGINGMODE_32_BIT_GLOBAL,
80 /** PAE mode, no global pages, no NX. */
81 SUPPAGINGMODE_PAE,
82 /** PAE mode with global pages. */
83 SUPPAGINGMODE_PAE_GLOBAL,
84 /** PAE mode with NX, no global pages. */
85 SUPPAGINGMODE_PAE_NX,
86 /** PAE mode with global pages and NX. */
87 SUPPAGINGMODE_PAE_GLOBAL_NX,
88 /** AMD64 mode, no global pages. */
89 SUPPAGINGMODE_AMD64,
90 /** AMD64 mode with global pages, no NX. */
91 SUPPAGINGMODE_AMD64_GLOBAL,
92 /** AMD64 mode with NX, no global pages. */
93 SUPPAGINGMODE_AMD64_NX,
94 /** AMD64 mode with global pages and NX. */
95 SUPPAGINGMODE_AMD64_GLOBAL_NX
96} SUPPAGINGMODE;
97
98
99/** @name Flags returned by SUPR0GetKernelFeatures().
100 * @{
101 */
102/** GDT is read-only. */
103#define SUPKERNELFEATURES_GDT_READ_ONLY RT_BIT(0)
104/** SMAP is possibly enabled. */
105#define SUPKERNELFEATURES_SMAP RT_BIT(1)
106/** @} */
107
108
109/**
110 * Usermode probe context information.
111 */
112typedef struct SUPDRVTRACERUSRCTX
113{
114 /** The probe ID from the VTG location record. */
115 uint32_t idProbe;
116 /** 32 if X86, 64 if AMD64. */
117 uint8_t cBits;
118 /** Reserved padding. */
119 uint8_t abReserved[3];
120 /** Data which format is dictated by the cBits member. */
121 union
122 {
123 /** X86 context info. */
124 struct
125 {
126 uint32_t uVtgProbeLoc; /**< Location record address. */
127 uint32_t aArgs[20]; /**< Raw arguments. */
128 uint32_t eip;
129 uint32_t eflags;
130 uint32_t eax;
131 uint32_t ecx;
132 uint32_t edx;
133 uint32_t ebx;
134 uint32_t esp;
135 uint32_t ebp;
136 uint32_t esi;
137 uint32_t edi;
138 uint16_t cs;
139 uint16_t ss;
140 uint16_t ds;
141 uint16_t es;
142 uint16_t fs;
143 uint16_t gs;
144 } X86;
145
146 /** AMD64 context info. */
147 struct
148 {
149 uint64_t uVtgProbeLoc; /**< Location record address. */
150 uint64_t aArgs[10]; /**< Raw arguments. */
151 uint64_t rip;
152 uint64_t rflags;
153 uint64_t rax;
154 uint64_t rcx;
155 uint64_t rdx;
156 uint64_t rbx;
157 uint64_t rsp;
158 uint64_t rbp;
159 uint64_t rsi;
160 uint64_t rdi;
161 uint64_t r8;
162 uint64_t r9;
163 uint64_t r10;
164 uint64_t r11;
165 uint64_t r12;
166 uint64_t r13;
167 uint64_t r14;
168 uint64_t r15;
169 } Amd64;
170 } u;
171} SUPDRVTRACERUSRCTX;
172/** Pointer to the usermode probe context information. */
173typedef SUPDRVTRACERUSRCTX *PSUPDRVTRACERUSRCTX;
174/** Pointer to the const usermode probe context information. */
175typedef SUPDRVTRACERUSRCTX const *PCSUPDRVTRACERUSRCTX;
176
177/**
178 * The result of a modification operation (SUPMSRPROBEROP_MODIFY or
179 * SUPMSRPROBEROP_MODIFY_FASTER).
180 */
181typedef struct SUPMSRPROBERMODIFYRESULT
182{
183 /** The MSR value prior to the modifications. Valid if fBeforeGp is false */
184 uint64_t uBefore;
185 /** The value that was written. Valid if fBeforeGp is false */
186 uint64_t uWritten;
187 /** The MSR value after the modifications. Valid if AfterGp is false. */
188 uint64_t uAfter;
189 /** Set if we GPed reading the MSR before the modification. */
190 bool fBeforeGp;
191 /** Set if we GPed while trying to write the modified value.
192 * This is set when fBeforeGp is true. */
193 bool fModifyGp;
194 /** Set if we GPed while trying to read the MSR after the modification.
195 * This is set when fBeforeGp is true. */
196 bool fAfterGp;
197 /** Set if we GPed while trying to restore the MSR after the modification.
198 * This is set when fBeforeGp is true. */
199 bool fRestoreGp;
200 /** Structure size alignment padding. */
201 bool afReserved[4];
202} SUPMSRPROBERMODIFYRESULT, *PSUPMSRPROBERMODIFYRESULT;
203
204
205/**
206 * The CPU state.
207 */
208typedef enum SUPGIPCPUSTATE
209{
210 /** Invalid CPU state / unused CPU entry. */
211 SUPGIPCPUSTATE_INVALID = 0,
212 /** The CPU is not present. */
213 SUPGIPCPUSTATE_ABSENT,
214 /** The CPU is offline. */
215 SUPGIPCPUSTATE_OFFLINE,
216 /** The CPU is online. */
217 SUPGIPCPUSTATE_ONLINE,
218 /** Force 32-bit enum type. */
219 SUPGIPCPUSTATE_32_BIT_HACK = 0x7fffffff
220} SUPGIPCPUSTATE;
221
222/**
223 * Per CPU data.
224 */
225typedef struct SUPGIPCPU
226{
227 /** Update transaction number.
228 * This number is incremented at the start and end of each update. It follows
229 * thusly that odd numbers indicates update in progress, while even numbers
230 * indicate stable data. Use this to make sure that the data items you fetch
231 * are consistent. */
232 volatile uint32_t u32TransactionId;
233 /** The interval in TSC ticks between two NanoTS updates.
234 * This is the average interval over the last 2, 4 or 8 updates + a little slack.
235 * The slack makes the time go a tiny tiny bit slower and extends the interval enough
236 * to avoid ending up with too many 1ns increments. */
237 volatile uint32_t u32UpdateIntervalTSC;
238 /** Current nanosecond timestamp. */
239 volatile uint64_t u64NanoTS;
240 /** The TSC at the time of u64NanoTS. */
241 volatile uint64_t u64TSC;
242 /** Current CPU Frequency. */
243 volatile uint64_t u64CpuHz;
244 /** The TSC delta with reference to the master TSC, subtract from RDTSC. */
245 volatile int64_t i64TSCDelta;
246 /** Number of errors during updating.
247 * Typical errors are under/overflows. */
248 volatile uint32_t cErrors;
249 /** Index of the head item in au32TSCHistory. */
250 volatile uint32_t iTSCHistoryHead;
251 /** Array of recent TSC interval deltas.
252 * The most recent item is at index iTSCHistoryHead.
253 * This history is used to calculate u32UpdateIntervalTSC.
254 */
255 volatile uint32_t au32TSCHistory[8];
256 /** The interval between the last two NanoTS updates. (experiment for now) */
257 volatile uint32_t u32PrevUpdateIntervalNS;
258
259 /** Reserved for future per processor data. */
260 volatile uint32_t au32Reserved0[5];
261
262 /** The TSC value read while doing TSC delta measurements across CPUs. */
263 volatile uint64_t u64TSCSample;
264
265 /** Reserved for future per processor data. */
266 volatile uint32_t au32Reserved1[1];
267
268 /** @todo Add topology/NUMA info. */
269 /** The CPU state. */
270 SUPGIPCPUSTATE volatile enmState;
271 /** The host CPU ID of this CPU (the SUPGIPCPU is indexed by APIC ID). */
272 RTCPUID idCpu;
273 /** The CPU set index of this CPU. */
274 int16_t iCpuSet;
275 /** The APIC ID of this CPU. */
276 uint16_t idApic;
277} SUPGIPCPU;
278AssertCompileSize(RTCPUID, 4);
279AssertCompileSize(SUPGIPCPU, 128);
280AssertCompileMemberAlignment(SUPGIPCPU, u64NanoTS, 8);
281AssertCompileMemberAlignment(SUPGIPCPU, u64TSC, 8);
282
283/** Pointer to per cpu data.
284 * @remark there is no const version of this typedef, see g_pSUPGlobalInfoPage for details. */
285typedef SUPGIPCPU *PSUPGIPCPU;
286
287
288/**
289 * The rules concerning the applicability of SUPGIPCPU::i64TscDelta.
290 */
291typedef enum SUPGIPUSETSCDELTA
292{
293 /** Value for SUPGIPMODE_ASYNC_TSC. */
294 SUPGIPUSETSCDELTA_NOT_APPLICABLE = 0,
295 /** The OS specific part of SUPDrv (or the user) claims the TSC is as
296 * good as zero. */
297 SUPGIPUSETSCDELTA_ZERO_CLAIMED,
298 /** The differences in RDTSC output between the CPUs/cores/threads should
299 * be considered zero for all practical purposes. */
300 SUPGIPUSETSCDELTA_PRACTICALLY_ZERO,
301 /** The differences in RDTSC output between the CPUs/cores/threads are a few
302 * hundred ticks or less. (Probably not worth calling ASMGetApicId two times
303 * just to apply deltas.) */
304 SUPGIPUSETSCDELTA_ROUGHLY_ZERO,
305 /** Significant differences in RDTSC output between the CPUs/cores/threads,
306 * deltas must be applied. */
307 SUPGIPUSETSCDELTA_NOT_ZERO,
308 /** End of valid values (exclusive). */
309 SUPGIPUSETSCDELTA_END,
310 /** Make sure the type is 32-bit sized. */
311 SUPGIPUSETSCDELTA_32BIT_HACK = 0x7fffffff
312} SUPGIPUSETSCDELTA;
313
314
315/** @name SUPGIPGETCPU_XXX - methods that aCPUs can be indexed.
316 * @{
317 */
318/** Use ASMGetApicId (or equivalent) and translate the result via
319 * aiCpuFromApicId. */
320#define SUPGIPGETCPU_APIC_ID RT_BIT_32(0)
321/** Use RDTSCP and translate the first RTCPUSET_MAX_CPUS of ECX via
322 * aiCpuFromCpuSetIdx.
323 *
324 * Linux stores the RTMpCpuId() value in ECX[11:0] and NUMA node number in
325 * ECX[12:31]. Solaris only stores RTMpCpuId() in ECX. On both systems
326 * RTMpCpuId() == RTMpCpuIdToSetIndex(RTMpCpuId()). RTCPUSET_MAX_CPUS is
327 * currently 64, 256 or 1024 in size, which lower than
328 * 4096, so there shouldn't be any range issues. */
329#define SUPGIPGETCPU_RDTSCP_MASK_MAX_SET_CPUS RT_BIT_32(1)
330/** Subtract the max IDT size from IDTR.LIMIT, extract the
331 * first RTCPUSET_MAX_CPUS and translate it via aiCpuFromCpuSetIdx.
332 *
333 * Darwin stores the RTMpCpuId() (== RTMpCpuIdToSetIndex(RTMpCpuId()))
334 * value in the IDT limit. The masking is a precaution against what linux
335 * does with RDTSCP. */
336#define SUPGIPGETCPU_IDTR_LIMIT_MASK_MAX_SET_CPUS RT_BIT_32(2)
337/* Linux also offers information via selector 0x78, but we'll settle for
338 RDTSCP for now. */
339/** @} */
340
341
342/**
343 * Global Information Page.
344 *
345 * This page contains useful information and can be mapped into any
346 * process or VM. It can be accessed thru the g_pSUPGlobalInfoPage
347 * pointer when a session is open.
348 */
349typedef struct SUPGLOBALINFOPAGE
350{
351 /** Magic (SUPGLOBALINFOPAGE_MAGIC). */
352 uint32_t u32Magic;
353 /** The GIP version. */
354 uint32_t u32Version;
355
356 /** The GIP update mode, see SUPGIPMODE. */
357 uint32_t u32Mode;
358 /** The number of entries in the CPU table.
359 * (This can work as RTMpGetArraySize().) */
360 uint16_t cCpus;
361 /** The size of the GIP in pages. */
362 uint16_t cPages;
363 /** The update frequency of the of the NanoTS. */
364 volatile uint32_t u32UpdateHz;
365 /** The update interval in nanoseconds. (10^9 / u32UpdateHz) */
366 volatile uint32_t u32UpdateIntervalNS;
367 /** The timestamp of the last time we update the update frequency. */
368 volatile uint64_t u64NanoTSLastUpdateHz;
369 /** The TSC frequency of the system. */
370 uint64_t u64CpuHz;
371 /** The set of online CPUs. */
372 RTCPUSET OnlineCpuSet;
373 /** The set of present CPUs. */
374 RTCPUSET PresentCpuSet;
375 /** The set of possible CPUs. */
376 RTCPUSET PossibleCpuSet;
377 /** The number of CPUs that are online. */
378 volatile uint16_t cOnlineCpus;
379 /** The number of CPUs present in the system. */
380 volatile uint16_t cPresentCpus;
381 /** The highest number of CPUs possible. */
382 uint16_t cPossibleCpus;
383 uint16_t u16Padding0;
384 /** The max CPU ID (RTMpGetMaxCpuId). */
385 RTCPUID idCpuMax;
386 /** The applicability of SUPGIPCPU::i64TscDelta. */
387 SUPGIPUSETSCDELTA enmUseTscDelta;
388 /** Mask of SUPGIPGETCPU_XXX values that indicates different ways that aCPU
389 * can be accessed from ring-3 and raw-mode context. */
390 uint32_t fGetGipCpu;
391 /** GIP flags, see SUPGIP_FLAGS_XXX. */
392 volatile uint32_t fFlags;
393
394 /** Padding / reserved space for future data. */
395 uint32_t au32Padding1[24];
396
397 /** Table indexed by the CPU APIC ID to get the CPU table index. */
398 uint16_t aiCpuFromApicId[256];
399 /** CPU set index to CPU table index. */
400 uint16_t aiCpuFromCpuSetIdx[RTCPUSET_MAX_CPUS];
401
402 /** Array of per-cpu data.
403 * This is index by ApicId via the aiCpuFromApicId table.
404 *
405 * The clock and frequency information is updated for all CPUs if @c u32Mode
406 * is SUPGIPMODE_ASYNC_TSC. If @c u32Mode is SUPGIPMODE_SYNC_TSC only the first
407 * entry is updated. If @c u32Mode is SUPGIPMODE_SYNC_TSC the TSC frequency in
408 * @c u64CpuHz is copied to all CPUs. */
409 SUPGIPCPU aCPUs[1];
410} SUPGLOBALINFOPAGE;
411AssertCompileMemberAlignment(SUPGLOBALINFOPAGE, u64NanoTSLastUpdateHz, 8);
412#if defined(RT_ARCH_SPARC) || defined(RT_ARCH_SPARC64)
413AssertCompileMemberAlignment(SUPGLOBALINFOPAGE, aCPUs, 32);
414#else
415AssertCompileMemberAlignment(SUPGLOBALINFOPAGE, aCPUs, 256);
416#endif
417
418/** Pointer to the global info page.
419 * @remark there is no const version of this typedef, see g_pSUPGlobalInfoPage for details. */
420typedef SUPGLOBALINFOPAGE *PSUPGLOBALINFOPAGE;
421
422
423/** The value of the SUPGLOBALINFOPAGE::u32Magic field. (Soryo Fuyumi) */
424#define SUPGLOBALINFOPAGE_MAGIC 0x19590106
425/** The GIP version.
426 * Upper 16 bits is the major version. Major version is only changed with
427 * incompatible changes in the GIP. */
428#define SUPGLOBALINFOPAGE_VERSION 0x00060001
429
430/**
431 * SUPGLOBALINFOPAGE::u32Mode values.
432 */
433typedef enum SUPGIPMODE
434{
435 /** The usual invalid null entry. */
436 SUPGIPMODE_INVALID = 0,
437 /** The TSC of the cores and cpus in the system is in sync. */
438 SUPGIPMODE_SYNC_TSC,
439 /** Each core has it's own TSC. */
440 SUPGIPMODE_ASYNC_TSC,
441 /** The TSC of the cores are non-stop and have a constant frequency. */
442 SUPGIPMODE_INVARIANT_TSC,
443 /** End of valid GIP mode values (exclusive). */
444 SUPGIPMODE_END,
445 /** The usual 32-bit hack. */
446 SUPGIPMODE_32BIT_HACK = 0x7fffffff
447} SUPGIPMODE;
448
449/** Pointer to the Global Information Page.
450 *
451 * This pointer is valid as long as SUPLib has a open session. Anyone using
452 * the page must treat this pointer as highly volatile and not trust it beyond
453 * one transaction.
454 *
455 * @remark The GIP page is read-only to everyone but the support driver and
456 * is actually mapped read only everywhere but in ring-0. However
457 * it is not marked 'const' as this might confuse compilers into
458 * thinking that values doesn't change even if members are marked
459 * as volatile. Thus, there is no PCSUPGLOBALINFOPAGE type.
460 */
461#if defined(IN_SUP_R3) || defined(IN_SUP_R0)
462extern DECLEXPORT(PSUPGLOBALINFOPAGE) g_pSUPGlobalInfoPage;
463
464#elif !defined(IN_RING0) || defined(RT_OS_WINDOWS) || defined(RT_OS_SOLARIS)
465extern DECLIMPORT(PSUPGLOBALINFOPAGE) g_pSUPGlobalInfoPage;
466
467#else /* IN_RING0 && !RT_OS_WINDOWS */
468# if !defined(__GNUC__) || defined(RT_OS_DARWIN) || !defined(RT_ARCH_AMD64)
469# define g_pSUPGlobalInfoPage (&g_SUPGlobalInfoPage)
470# else
471# define g_pSUPGlobalInfoPage (SUPGetGIPHlp())
472/** Workaround for ELF+GCC problem on 64-bit hosts.
473 * (GCC emits a mov with a R_X86_64_32 reloc, we need R_X86_64_64.) */
474DECLINLINE(PSUPGLOBALINFOPAGE) SUPGetGIPHlp(void)
475{
476 PSUPGLOBALINFOPAGE pGIP;
477 __asm__ __volatile__ ("movabs $g_SUPGlobalInfoPage,%0\n\t"
478 : "=a" (pGIP));
479 return pGIP;
480}
481# endif
482/** The GIP.
483 * We save a level of indirection by exporting the GIP instead of a variable
484 * pointing to it. */
485extern DECLIMPORT(SUPGLOBALINFOPAGE) g_SUPGlobalInfoPage;
486#endif
487
488/**
489 * Gets the GIP pointer.
490 *
491 * @returns Pointer to the GIP or NULL.
492 */
493SUPDECL(PSUPGLOBALINFOPAGE) SUPGetGIP(void);
494
495/** @name SUPGIP_FLAGS_XXX - SUPR3GipSetFlags flags.
496 * @{ */
497/** Enable GIP test mode. */
498#define SUPGIP_FLAGS_TESTING_ENABLE RT_BIT_32(0)
499/** Valid mask of flags that can be set through the ioctl. */
500#define SUPGIP_FLAGS_VALID_MASK RT_BIT_32(0)
501/** GIP test mode needs to be checked (e.g. when enabled or being disabled). */
502#define SUPGIP_FLAGS_TESTING RT_BIT_32(24)
503/** Prepare to start GIP test mode. */
504#define SUPGIP_FLAGS_TESTING_START RT_BIT_32(25)
505/** Prepare to stop GIP test mode. */
506#define SUPGIP_FLAGS_TESTING_STOP RT_BIT_32(26)
507/** @} */
508
509/** @internal */
510SUPDECL(uint64_t) SUPGetCpuHzFromGipForAsyncMode(PSUPGLOBALINFOPAGE pGip);
511SUPDECL(bool) SUPIsTscFreqCompatible(uint64_t uCpuHz, uint64_t *puGipCpuHz, bool fRelax);
512SUPDECL(bool) SUPIsTscFreqCompatibleEx(uint64_t uBaseCpuHz, uint64_t uCpuHz, bool fRelax);
513
514
515/**
516 * Gets the TSC frequency of the calling CPU.
517 *
518 * @returns TSC frequency, UINT64_MAX on failure (asserted).
519 * @param pGip The GIP pointer.
520 */
521DECLINLINE(uint64_t) SUPGetCpuHzFromGip(PSUPGLOBALINFOPAGE pGip)
522{
523 if (RT_LIKELY( pGip
524 && pGip->u32Magic == SUPGLOBALINFOPAGE_MAGIC))
525 {
526 switch (pGip->u32Mode)
527 {
528 case SUPGIPMODE_INVARIANT_TSC:
529 case SUPGIPMODE_SYNC_TSC:
530 return pGip->aCPUs[0].u64CpuHz;
531 case SUPGIPMODE_ASYNC_TSC:
532 return SUPGetCpuHzFromGipForAsyncMode(pGip);
533 default: break; /* shut up gcc */
534 }
535 }
536 AssertFailed();
537 return UINT64_MAX;
538}
539
540
541/**
542 * Gets the TSC frequency of the specified CPU.
543 *
544 * @returns TSC frequency, UINT64_MAX on failure (asserted).
545 * @param pGip The GIP pointer.
546 * @param iCpuSet The CPU set index of the CPU in question.
547 */
548DECLINLINE(uint64_t) SUPGetCpuHzFromGipBySetIndex(PSUPGLOBALINFOPAGE pGip, uint32_t iCpuSet)
549{
550 if (RT_LIKELY( pGip
551 && pGip->u32Magic == SUPGLOBALINFOPAGE_MAGIC))
552 {
553 switch (pGip->u32Mode)
554 {
555 case SUPGIPMODE_INVARIANT_TSC:
556 case SUPGIPMODE_SYNC_TSC:
557 return pGip->aCPUs[0].u64CpuHz;
558 case SUPGIPMODE_ASYNC_TSC:
559 if (RT_LIKELY(iCpuSet < RT_ELEMENTS(pGip->aiCpuFromCpuSetIdx)))
560 {
561 uint16_t iCpu = pGip->aiCpuFromCpuSetIdx[iCpuSet];
562 if (RT_LIKELY(iCpu < pGip->cCpus))
563 return pGip->aCPUs[iCpu].u64CpuHz;
564 }
565 break;
566 default: break; /* shut up gcc */
567 }
568 }
569 AssertFailed();
570 return UINT64_MAX;
571}
572
573
574#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
575
576/** @internal */
577SUPDECL(uint64_t) SUPReadTscWithDelta(PSUPGLOBALINFOPAGE pGip);
578
579/**
580 * Read the host TSC value and applies the TSC delta if appropriate.
581 *
582 * @returns the TSC value.
583 * @remarks Requires GIP to be initialized and valid.
584 */
585DECLINLINE(uint64_t) SUPReadTsc(void)
586{
587 PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
588 if (pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO)
589 return ASMReadTSC();
590 return SUPReadTscWithDelta(pGip);
591}
592
593#endif /* X86 || AMD64 */
594
595/** @internal */
596SUPDECL(uint64_t) SUPGetTscDeltaSlow(PSUPGLOBALINFOPAGE pGip);
597
598/**
599 * Gets the TSC delta for the current CPU.
600 *
601 * @returns The TSC delta value (will not return the special INT64_MAX value).
602 * @remarks Requires GIP to be initialized and valid.
603 */
604DECLINLINE(int64_t) SUPGetTscDelta(void)
605{
606 PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
607 if (pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO)
608 return 0;
609 return SUPGetTscDeltaSlow(pGip);
610}
611
612
613/**
614 * Gets the TSC delta for a given CPU.
615 *
616 * @returns The TSC delta value (will not return the special INT64_MAX value).
617 * @param iCpuSet The CPU set index of the CPU which TSC delta we want.
618 * @remarks Requires GIP to be initialized and valid.
619 */
620DECLINLINE(int64_t) SUPGetTscDeltaByCpuSetIndex(uint32_t iCpuSet)
621{
622 PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
623 if (pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO)
624 return 0;
625 if (RT_LIKELY(iCpuSet < RT_ELEMENTS(pGip->aiCpuFromCpuSetIdx)))
626 {
627 uint16_t iCpu = pGip->aiCpuFromCpuSetIdx[iCpuSet];
628 if (RT_LIKELY(iCpu < pGip->cCpus))
629 {
630 int64_t iTscDelta = pGip->aCPUs[iCpu].i64TSCDelta;
631 if (iTscDelta != INT64_MAX)
632 return iTscDelta;
633 }
634 }
635 AssertFailed();
636 return 0;
637}
638
639
640/**
641 * Checks if the TSC delta is available for a given CPU (if TSC-deltas are
642 * relevant).
643 *
644 * @returns true if it's okay to read the TSC, false otherwise.
645 *
646 * @param iCpuSet The CPU set index of the CPU which TSC delta we check.
647 * @remarks Requires GIP to be initialized and valid.
648 */
649DECLINLINE(bool) SUPIsTscDeltaAvailableForCpuSetIndex(uint32_t iCpuSet)
650{
651 PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
652 if (pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ROUGHLY_ZERO)
653 return true;
654 if (RT_LIKELY(iCpuSet < RT_ELEMENTS(pGip->aiCpuFromCpuSetIdx)))
655 {
656 uint16_t iCpu = pGip->aiCpuFromCpuSetIdx[iCpuSet];
657 if (RT_LIKELY(iCpu < pGip->cCpus))
658 {
659 int64_t iTscDelta = pGip->aCPUs[iCpu].i64TSCDelta;
660 if (iTscDelta != INT64_MAX)
661 return true;
662 }
663 }
664 return false;
665}
666
667
668/**
669 * Gets the descriptive GIP mode name.
670 *
671 * @returns The name.
672 * @param pGip Pointer to the GIP.
673 */
674DECLINLINE(const char *) SUPGetGIPModeName(PSUPGLOBALINFOPAGE pGip)
675{
676 AssertReturn(pGip, NULL);
677 switch (pGip->u32Mode)
678 {
679 case SUPGIPMODE_INVARIANT_TSC: return "Invariant";
680 case SUPGIPMODE_SYNC_TSC: return "Synchronous";
681 case SUPGIPMODE_ASYNC_TSC: return "Asynchronous";
682 case SUPGIPMODE_INVALID: return "Invalid";
683 default: return "???";
684 }
685}
686
687
688/**
689 * Gets the descriptive TSC-delta enum name.
690 *
691 * @returns The name.
692 * @param pGip Pointer to the GIP.
693 */
694DECLINLINE(const char *) SUPGetGIPTscDeltaModeName(PSUPGLOBALINFOPAGE pGip)
695{
696 AssertReturn(pGip, NULL);
697 switch (pGip->enmUseTscDelta)
698 {
699 case SUPGIPUSETSCDELTA_NOT_APPLICABLE: return "Not Applicable";
700 case SUPGIPUSETSCDELTA_ZERO_CLAIMED: return "Zero Claimed";
701 case SUPGIPUSETSCDELTA_PRACTICALLY_ZERO: return "Pratically Zero";
702 case SUPGIPUSETSCDELTA_ROUGHLY_ZERO: return "Roughly Zero";
703 case SUPGIPUSETSCDELTA_NOT_ZERO: return "Not Zero";
704 default: return "???";
705 }
706}
707
708
709/**
710 * Request for generic VMMR0Entry calls.
711 */
712typedef struct SUPVMMR0REQHDR
713{
714 /** The magic. (SUPVMMR0REQHDR_MAGIC) */
715 uint32_t u32Magic;
716 /** The size of the request. */
717 uint32_t cbReq;
718} SUPVMMR0REQHDR;
719/** Pointer to a ring-0 request header. */
720typedef SUPVMMR0REQHDR *PSUPVMMR0REQHDR;
721/** the SUPVMMR0REQHDR::u32Magic value (Ethan Iverson - The Bad Plus). */
722#define SUPVMMR0REQHDR_MAGIC UINT32_C(0x19730211)
723
724
725/** For the fast ioctl path.
726 * @{
727 */
728/** @see VMMR0_DO_RAW_RUN. */
729#define SUP_VMMR0_DO_RAW_RUN 0
730/** @see VMMR0_DO_HM_RUN. */
731#define SUP_VMMR0_DO_HM_RUN 1
732/** @see VMMR0_DO_NOP */
733#define SUP_VMMR0_DO_NOP 2
734/** @} */
735
736/** SUPR3QueryVTCaps capability flags
737 * @{
738 */
739/** AMD-V support. */
740#define SUPVTCAPS_AMD_V RT_BIT(0)
741/** VT-x support. */
742#define SUPVTCAPS_VT_X RT_BIT(1)
743/** Nested paging is supported. */
744#define SUPVTCAPS_NESTED_PAGING RT_BIT(2)
745/** VT-x: Unrestricted guest execution is supported. */
746#define SUPVTCAPS_VTX_UNRESTRICTED_GUEST RT_BIT(3)
747/** @} */
748
749/**
750 * Request for generic FNSUPR0SERVICEREQHANDLER calls.
751 */
752typedef struct SUPR0SERVICEREQHDR
753{
754 /** The magic. (SUPR0SERVICEREQHDR_MAGIC) */
755 uint32_t u32Magic;
756 /** The size of the request. */
757 uint32_t cbReq;
758} SUPR0SERVICEREQHDR;
759/** Pointer to a ring-0 service request header. */
760typedef SUPR0SERVICEREQHDR *PSUPR0SERVICEREQHDR;
761/** the SUPVMMR0REQHDR::u32Magic value (Esbjoern Svensson - E.S.P.). */
762#define SUPR0SERVICEREQHDR_MAGIC UINT32_C(0x19640416)
763
764
765/**
766 * Creates a single release event semaphore.
767 *
768 * @returns VBox status code.
769 * @param pSession The session handle of the caller.
770 * @param phEvent Where to return the handle to the event semaphore.
771 */
772SUPDECL(int) SUPSemEventCreate(PSUPDRVSESSION pSession, PSUPSEMEVENT phEvent);
773
774/**
775 * Closes a single release event semaphore handle.
776 *
777 * @returns VBox status code.
778 * @retval VINF_OBJECT_DESTROYED if the semaphore was destroyed.
779 * @retval VINF_SUCCESS if the handle was successfully closed but the semaphore
780 * object remained alive because of other references.
781 *
782 * @param pSession The session handle of the caller.
783 * @param hEvent The handle. Nil is quietly ignored.
784 */
785SUPDECL(int) SUPSemEventClose(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent);
786
787/**
788 * Signals a single release event semaphore.
789 *
790 * @returns VBox status code.
791 * @param pSession The session handle of the caller.
792 * @param hEvent The semaphore handle.
793 */
794SUPDECL(int) SUPSemEventSignal(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent);
795
796#ifdef IN_RING0
797/**
798 * Waits on a single release event semaphore, not interruptible.
799 *
800 * @returns VBox status code.
801 * @param pSession The session handle of the caller.
802 * @param hEvent The semaphore handle.
803 * @param cMillies The number of milliseconds to wait.
804 * @remarks Not available in ring-3.
805 */
806SUPDECL(int) SUPSemEventWait(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies);
807#endif
808
809/**
810 * Waits on a single release event semaphore, interruptible.
811 *
812 * @returns VBox status code.
813 * @param pSession The session handle of the caller.
814 * @param hEvent The semaphore handle.
815 * @param cMillies The number of milliseconds to wait.
816 */
817SUPDECL(int) SUPSemEventWaitNoResume(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies);
818
819/**
820 * Waits on a single release event semaphore, interruptible.
821 *
822 * @returns VBox status code.
823 * @param pSession The session handle of the caller.
824 * @param hEvent The semaphore handle.
825 * @param uNsTimeout The deadline given on the RTTimeNanoTS() clock.
826 */
827SUPDECL(int) SUPSemEventWaitNsAbsIntr(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint64_t uNsTimeout);
828
829/**
830 * Waits on a single release event semaphore, interruptible.
831 *
832 * @returns VBox status code.
833 * @param pSession The session handle of the caller.
834 * @param hEvent The semaphore handle.
835 * @param cNsTimeout The number of nanoseconds to wait.
836 */
837SUPDECL(int) SUPSemEventWaitNsRelIntr(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint64_t cNsTimeout);
838
839/**
840 * Gets the best timeout resolution that SUPSemEventWaitNsAbsIntr and
841 * SUPSemEventWaitNsAbsIntr can do.
842 *
843 * @returns The resolution in nanoseconds.
844 * @param pSession The session handle of the caller.
845 */
846SUPDECL(uint32_t) SUPSemEventGetResolution(PSUPDRVSESSION pSession);
847
848
849/**
850 * Creates a multiple release event semaphore.
851 *
852 * @returns VBox status code.
853 * @param pSession The session handle of the caller.
854 * @param phEventMulti Where to return the handle to the event semaphore.
855 */
856SUPDECL(int) SUPSemEventMultiCreate(PSUPDRVSESSION pSession, PSUPSEMEVENTMULTI phEventMulti);
857
858/**
859 * Closes a multiple release event semaphore handle.
860 *
861 * @returns VBox status code.
862 * @retval VINF_OBJECT_DESTROYED if the semaphore was destroyed.
863 * @retval VINF_SUCCESS if the handle was successfully closed but the semaphore
864 * object remained alive because of other references.
865 *
866 * @param pSession The session handle of the caller.
867 * @param hEventMulti The handle. Nil is quietly ignored.
868 */
869SUPDECL(int) SUPSemEventMultiClose(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
870
871/**
872 * Signals a multiple release event semaphore.
873 *
874 * @returns VBox status code.
875 * @param pSession The session handle of the caller.
876 * @param hEventMulti The semaphore handle.
877 */
878SUPDECL(int) SUPSemEventMultiSignal(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
879
880/**
881 * Resets a multiple release event semaphore.
882 *
883 * @returns VBox status code.
884 * @param pSession The session handle of the caller.
885 * @param hEventMulti The semaphore handle.
886 */
887SUPDECL(int) SUPSemEventMultiReset(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
888
889#ifdef IN_RING0
890/**
891 * Waits on a multiple release event semaphore, not interruptible.
892 *
893 * @returns VBox status code.
894 * @param pSession The session handle of the caller.
895 * @param hEventMulti The semaphore handle.
896 * @param cMillies The number of milliseconds to wait.
897 * @remarks Not available in ring-3.
898 */
899SUPDECL(int) SUPSemEventMultiWait(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies);
900#endif
901
902/**
903 * Waits on a multiple release event semaphore, interruptible.
904 *
905 * @returns VBox status code.
906 * @param pSession The session handle of the caller.
907 * @param hEventMulti The semaphore handle.
908 * @param cMillies The number of milliseconds to wait.
909 */
910SUPDECL(int) SUPSemEventMultiWaitNoResume(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies);
911
912/**
913 * Waits on a multiple release event semaphore, interruptible.
914 *
915 * @returns VBox status code.
916 * @param pSession The session handle of the caller.
917 * @param hEventMulti The semaphore handle.
918 * @param uNsTimeout The deadline given on the RTTimeNanoTS() clock.
919 */
920SUPDECL(int) SUPSemEventMultiWaitNsAbsIntr(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint64_t uNsTimeout);
921
922/**
923 * Waits on a multiple release event semaphore, interruptible.
924 *
925 * @returns VBox status code.
926 * @param pSession The session handle of the caller.
927 * @param hEventMulti The semaphore handle.
928 * @param cNsTimeout The number of nanoseconds to wait.
929 */
930SUPDECL(int) SUPSemEventMultiWaitNsRelIntr(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint64_t cNsTimeout);
931
932/**
933 * Gets the best timeout resolution that SUPSemEventMultiWaitNsAbsIntr and
934 * SUPSemEventMultiWaitNsRelIntr can do.
935 *
936 * @returns The resolution in nanoseconds.
937 * @param pSession The session handle of the caller.
938 */
939SUPDECL(uint32_t) SUPSemEventMultiGetResolution(PSUPDRVSESSION pSession);
940
941
942#ifdef IN_RING3
943
944/** @defgroup grp_sup_r3 SUP Host Context Ring-3 API
945 * @{
946 */
947
948/**
949 * Installs the support library.
950 *
951 * @returns VBox status code.
952 */
953SUPR3DECL(int) SUPR3Install(void);
954
955/**
956 * Uninstalls the support library.
957 *
958 * @returns VBox status code.
959 */
960SUPR3DECL(int) SUPR3Uninstall(void);
961
962/**
963 * Trusted main entry point.
964 *
965 * This is exported as "TrustedMain" by the dynamic libraries which contains the
966 * "real" application binary for which the hardened stub is built. The entry
967 * point is invoked upon successful initialization of the support library and
968 * runtime.
969 *
970 * @returns main kind of exit code.
971 * @param argc The argument count.
972 * @param argv The argument vector.
973 * @param envp The environment vector.
974 */
975typedef DECLCALLBACK(int) FNSUPTRUSTEDMAIN(int argc, char **argv, char **envp);
976/** Pointer to FNSUPTRUSTEDMAIN(). */
977typedef FNSUPTRUSTEDMAIN *PFNSUPTRUSTEDMAIN;
978
979/** Which operation failed. */
980typedef enum SUPINITOP
981{
982 /** Invalid. */
983 kSupInitOp_Invalid = 0,
984 /** Installation integrity error. */
985 kSupInitOp_Integrity,
986 /** Setuid related. */
987 kSupInitOp_RootCheck,
988 /** Driver related. */
989 kSupInitOp_Driver,
990 /** IPRT init related. */
991 kSupInitOp_IPRT,
992 /** Miscellaneous. */
993 kSupInitOp_Misc,
994 /** Place holder. */
995 kSupInitOp_End
996} SUPINITOP;
997
998/**
999 * Trusted error entry point, optional.
1000 *
1001 * This is exported as "TrustedError" by the dynamic libraries which contains
1002 * the "real" application binary for which the hardened stub is built. The
1003 * hardened main() must specify SUPSECMAIN_FLAGS_TRUSTED_ERROR when calling
1004 * SUPR3HardenedMain.
1005 *
1006 * @param pszWhere Where the error occurred (function name).
1007 * @param enmWhat Which operation went wrong.
1008 * @param rc The status code.
1009 * @param pszMsgFmt Error message format string.
1010 * @param va The message format arguments.
1011 */
1012typedef DECLCALLBACK(void) FNSUPTRUSTEDERROR(const char *pszWhere, SUPINITOP enmWhat, int rc,
1013 const char *pszMsgFmt, va_list va) RT_IPRT_FORMAT_ATTR(4, 0);
1014/** Pointer to FNSUPTRUSTEDERROR. */
1015typedef FNSUPTRUSTEDERROR *PFNSUPTRUSTEDERROR;
1016
1017/**
1018 * Secure main.
1019 *
1020 * This is used for the set-user-ID-on-execute binaries on unixy systems
1021 * and when using the open-vboxdrv-via-root-service setup on Windows.
1022 *
1023 * This function will perform the integrity checks of the VirtualBox
1024 * installation, open the support driver, open the root service (later),
1025 * and load the DLL corresponding to \a pszProgName and execute its main
1026 * function.
1027 *
1028 * @returns Return code appropriate for main().
1029 *
1030 * @param pszProgName The program name. This will be used to figure out which
1031 * DLL/SO/DYLIB to load and execute.
1032 * @param fFlags Flags.
1033 * @param argc The argument count.
1034 * @param argv The argument vector.
1035 * @param envp The environment vector.
1036 */
1037DECLHIDDEN(int) SUPR3HardenedMain(const char *pszProgName, uint32_t fFlags, int argc, char **argv, char **envp);
1038
1039/** @name SUPR3HardenedMain flags.
1040 * @{ */
1041/** Don't open the device. (Intended for VirtualBox without -startvm.) */
1042#define SUPSECMAIN_FLAGS_DONT_OPEN_DEV RT_BIT_32(0)
1043/** The hardened DLL has a "TrustedError" function (see FNSUPTRUSTEDERROR). */
1044#define SUPSECMAIN_FLAGS_TRUSTED_ERROR RT_BIT_32(1)
1045/** Hack for making VirtualBoxVM use VirtualBox.dylib on Mac OS X. */
1046#define SUPSECMAIN_FLAGS_OSX_VM_APP RT_BIT_32(2)
1047/** Program binary location mask. */
1048#define SUPSECMAIN_FLAGS_LOC_MASK UINT32_C(0x00000010)
1049/** Default binary location is the application binary directory. Does
1050 * not need to be given explicitly (it's 0). */
1051#define SUPSECMAIN_FLAGS_LOC_APP_BIN UINT32_C(0x00000000)
1052/** The binary is located in the testcase directory instead of the
1053 * default application binary directory. */
1054#define SUPSECMAIN_FLAGS_LOC_TESTCASE UINT32_C(0x00000010)
1055/** @} */
1056
1057/**
1058 * Initializes the support library.
1059 *
1060 * Each successful call to SUPR3Init() or SUPR3InitEx must be countered by a
1061 * call to SUPR3Term(false).
1062 *
1063 * @returns VBox status code.
1064 * @param ppSession Where to store the session handle. Defaults to NULL.
1065 */
1066SUPR3DECL(int) SUPR3Init(PSUPDRVSESSION *ppSession);
1067
1068/**
1069 * Initializes the support library, extended version.
1070 *
1071 * Each successful call to SUPR3Init() or SUPR3InitEx must be countered by a
1072 * call to SUPR3Term(false).
1073 *
1074 * @returns VBox status code.
1075 * @param fUnrestricted The desired access.
1076 * @param ppSession Where to store the session handle. Defaults to NULL.
1077 */
1078SUPR3DECL(int) SUPR3InitEx(bool fUnrestricted, PSUPDRVSESSION *ppSession);
1079
1080/**
1081 * Terminates the support library.
1082 *
1083 * @returns VBox status code.
1084 * @param fForced Forced termination. This means to ignore the
1085 * init call count and just terminated.
1086 */
1087#ifdef __cplusplus
1088SUPR3DECL(int) SUPR3Term(bool fForced = false);
1089#else
1090SUPR3DECL(int) SUPR3Term(int fForced);
1091#endif
1092
1093/**
1094 * Sets the ring-0 VM handle for use with fast IOCtls.
1095 *
1096 * @returns VBox status code.
1097 * @param pVMR0 The ring-0 VM handle.
1098 * NIL_RTR0PTR can be used to unset the handle when the
1099 * VM is about to be destroyed.
1100 */
1101SUPR3DECL(int) SUPR3SetVMForFastIOCtl(PVMR0 pVMR0);
1102
1103/**
1104 * Calls the HC R0 VMM entry point.
1105 * See VMMR0Entry() for more details.
1106 *
1107 * @returns error code specific to uFunction.
1108 * @param pVMR0 Pointer to the Ring-0 (Host Context) mapping of the VM structure.
1109 * @param idCpu The virtual CPU ID.
1110 * @param uOperation Operation to execute.
1111 * @param pvArg Argument.
1112 */
1113SUPR3DECL(int) SUPR3CallVMMR0(PVMR0 pVMR0, VMCPUID idCpu, unsigned uOperation, void *pvArg);
1114
1115/**
1116 * Variant of SUPR3CallVMMR0, except that this takes the fast ioclt path
1117 * regardsless of compile-time defaults.
1118 *
1119 * @returns VBox status code.
1120 * @param pVMR0 The ring-0 VM handle.
1121 * @param uOperation The operation; only the SUP_VMMR0_DO_* ones are valid.
1122 * @param idCpu The virtual CPU ID.
1123 */
1124SUPR3DECL(int) SUPR3CallVMMR0Fast(PVMR0 pVMR0, unsigned uOperation, VMCPUID idCpu);
1125
1126/**
1127 * Calls the HC R0 VMM entry point, in a safer but slower manner than
1128 * SUPR3CallVMMR0. When entering using this call the R0 components can call
1129 * into the host kernel (i.e. use the SUPR0 and RT APIs).
1130 *
1131 * See VMMR0Entry() for more details.
1132 *
1133 * @returns error code specific to uFunction.
1134 * @param pVMR0 Pointer to the Ring-0 (Host Context) mapping of the VM structure.
1135 * @param idCpu The virtual CPU ID.
1136 * @param uOperation Operation to execute.
1137 * @param u64Arg Constant argument.
1138 * @param pReqHdr Pointer to a request header. Optional.
1139 * This will be copied in and out of kernel space. There currently is a size
1140 * limit on this, just below 4KB.
1141 */
1142SUPR3DECL(int) SUPR3CallVMMR0Ex(PVMR0 pVMR0, VMCPUID idCpu, unsigned uOperation, uint64_t u64Arg, PSUPVMMR0REQHDR pReqHdr);
1143
1144/**
1145 * Calls a ring-0 service.
1146 *
1147 * The operation and the request packet is specific to the service.
1148 *
1149 * @returns error code specific to uFunction.
1150 * @param pszService The service name.
1151 * @param cchService The length of the service name.
1152 * @param uOperation The request number.
1153 * @param u64Arg Constant argument.
1154 * @param pReqHdr Pointer to a request header. Optional.
1155 * This will be copied in and out of kernel space. There currently is a size
1156 * limit on this, just below 4KB.
1157 */
1158SUPR3DECL(int) SUPR3CallR0Service(const char *pszService, size_t cchService, uint32_t uOperation, uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr);
1159
1160/** Which logger. */
1161typedef enum SUPLOGGER
1162{
1163 SUPLOGGER_DEBUG = 1,
1164 SUPLOGGER_RELEASE
1165} SUPLOGGER;
1166
1167/**
1168 * Changes the settings of the specified ring-0 logger.
1169 *
1170 * @returns VBox status code.
1171 * @param enmWhich Which logger.
1172 * @param pszFlags The flags settings.
1173 * @param pszGroups The groups settings.
1174 * @param pszDest The destination specificier.
1175 */
1176SUPR3DECL(int) SUPR3LoggerSettings(SUPLOGGER enmWhich, const char *pszFlags, const char *pszGroups, const char *pszDest);
1177
1178/**
1179 * Creates a ring-0 logger instance.
1180 *
1181 * @returns VBox status code.
1182 * @param enmWhich Which logger to create.
1183 * @param pszFlags The flags settings.
1184 * @param pszGroups The groups settings.
1185 * @param pszDest The destination specificier.
1186 */
1187SUPR3DECL(int) SUPR3LoggerCreate(SUPLOGGER enmWhich, const char *pszFlags, const char *pszGroups, const char *pszDest);
1188
1189/**
1190 * Destroys a ring-0 logger instance.
1191 *
1192 * @returns VBox status code.
1193 * @param enmWhich Which logger.
1194 */
1195SUPR3DECL(int) SUPR3LoggerDestroy(SUPLOGGER enmWhich);
1196
1197/**
1198 * Queries the paging mode of the host OS.
1199 *
1200 * @returns The paging mode.
1201 */
1202SUPR3DECL(SUPPAGINGMODE) SUPR3GetPagingMode(void);
1203
1204/**
1205 * Allocate zero-filled pages.
1206 *
1207 * Use this to allocate a number of pages suitable for seeding / locking.
1208 * Call SUPR3PageFree() to free the pages once done with them.
1209 *
1210 * @returns VBox status.
1211 * @param cPages Number of pages to allocate.
1212 * @param ppvPages Where to store the base pointer to the allocated pages.
1213 */
1214SUPR3DECL(int) SUPR3PageAlloc(size_t cPages, void **ppvPages);
1215
1216/**
1217 * Frees pages allocated with SUPR3PageAlloc().
1218 *
1219 * @returns VBox status.
1220 * @param pvPages Pointer returned by SUPR3PageAlloc().
1221 * @param cPages Number of pages that was allocated.
1222 */
1223SUPR3DECL(int) SUPR3PageFree(void *pvPages, size_t cPages);
1224
1225/**
1226 * Allocate non-zeroed, locked, pages with user and, optionally, kernel
1227 * mappings.
1228 *
1229 * Use SUPR3PageFreeEx() to free memory allocated with this function.
1230 *
1231 * @returns VBox status code.
1232 * @param cPages The number of pages to allocate.
1233 * @param fFlags Flags, reserved. Must be zero.
1234 * @param ppvPages Where to store the address of the user mapping.
1235 * @param pR0Ptr Where to store the address of the kernel mapping.
1236 * NULL if no kernel mapping is desired.
1237 * @param paPages Where to store the physical addresses of each page.
1238 * Optional.
1239 */
1240SUPR3DECL(int) SUPR3PageAllocEx(size_t cPages, uint32_t fFlags, void **ppvPages, PRTR0PTR pR0Ptr, PSUPPAGE paPages);
1241
1242/**
1243 * Maps a portion of a ring-3 only allocation into kernel space.
1244 *
1245 * @returns VBox status code.
1246 *
1247 * @param pvR3 The address SUPR3PageAllocEx return.
1248 * @param off Offset to start mapping at. Must be page aligned.
1249 * @param cb Number of bytes to map. Must be page aligned.
1250 * @param fFlags Flags, must be zero.
1251 * @param pR0Ptr Where to store the address on success.
1252 *
1253 */
1254SUPR3DECL(int) SUPR3PageMapKernel(void *pvR3, uint32_t off, uint32_t cb, uint32_t fFlags, PRTR0PTR pR0Ptr);
1255
1256/**
1257 * Changes the protection of
1258 *
1259 * @returns VBox status code.
1260 * @retval VERR_NOT_SUPPORTED if the OS doesn't allow us to change page level
1261 * protection. See also RTR0MemObjProtect.
1262 *
1263 * @param pvR3 The ring-3 address SUPR3PageAllocEx returned.
1264 * @param R0Ptr The ring-0 address SUPR3PageAllocEx returned if it
1265 * is desired that the corresponding ring-0 page
1266 * mappings should change protection as well. Pass
1267 * NIL_RTR0PTR if the ring-0 pages should remain
1268 * unaffected.
1269 * @param off Offset to start at which to start chagning the page
1270 * level protection. Must be page aligned.
1271 * @param cb Number of bytes to change. Must be page aligned.
1272 * @param fProt The new page level protection, either a combination
1273 * of RTMEM_PROT_READ, RTMEM_PROT_WRITE and
1274 * RTMEM_PROT_EXEC, or just RTMEM_PROT_NONE.
1275 */
1276SUPR3DECL(int) SUPR3PageProtect(void *pvR3, RTR0PTR R0Ptr, uint32_t off, uint32_t cb, uint32_t fProt);
1277
1278/**
1279 * Free pages allocated by SUPR3PageAllocEx.
1280 *
1281 * @returns VBox status code.
1282 * @param pvPages The address of the user mapping.
1283 * @param cPages The number of pages.
1284 */
1285SUPR3DECL(int) SUPR3PageFreeEx(void *pvPages, size_t cPages);
1286
1287/**
1288 * Allocated memory with page aligned memory with a contiguous and locked physical
1289 * memory backing below 4GB.
1290 *
1291 * @returns Pointer to the allocated memory (virtual address).
1292 * *pHCPhys is set to the physical address of the memory.
1293 * If ppvR0 isn't NULL, *ppvR0 is set to the ring-0 mapping.
1294 * The returned memory must be freed using SUPR3ContFree().
1295 * @returns NULL on failure.
1296 * @param cPages Number of pages to allocate.
1297 * @param pR0Ptr Where to store the ring-0 mapping of the allocation. (optional)
1298 * @param pHCPhys Where to store the physical address of the memory block.
1299 *
1300 * @remark This 2nd version of this API exists because we're not able to map the
1301 * ring-3 mapping executable on WIN64. This is a serious problem in regard to
1302 * the world switchers.
1303 */
1304SUPR3DECL(void *) SUPR3ContAlloc(size_t cPages, PRTR0PTR pR0Ptr, PRTHCPHYS pHCPhys);
1305
1306/**
1307 * Frees memory allocated with SUPR3ContAlloc().
1308 *
1309 * @returns VBox status code.
1310 * @param pv Pointer to the memory block which should be freed.
1311 * @param cPages Number of pages to be freed.
1312 */
1313SUPR3DECL(int) SUPR3ContFree(void *pv, size_t cPages);
1314
1315/**
1316 * Allocated non contiguous physical memory below 4GB.
1317 *
1318 * The memory isn't zeroed.
1319 *
1320 * @returns VBox status code.
1321 * @returns NULL on failure.
1322 * @param cPages Number of pages to allocate.
1323 * @param ppvPages Where to store the pointer to the allocated memory.
1324 * The pointer stored here on success must be passed to
1325 * SUPR3LowFree when the memory should be released.
1326 * @param ppvPagesR0 Where to store the ring-0 pointer to the allocated memory. optional.
1327 * @param paPages Where to store the physical addresses of the individual pages.
1328 */
1329SUPR3DECL(int) SUPR3LowAlloc(size_t cPages, void **ppvPages, PRTR0PTR ppvPagesR0, PSUPPAGE paPages);
1330
1331/**
1332 * Frees memory allocated with SUPR3LowAlloc().
1333 *
1334 * @returns VBox status code.
1335 * @param pv Pointer to the memory block which should be freed.
1336 * @param cPages Number of pages that was allocated.
1337 */
1338SUPR3DECL(int) SUPR3LowFree(void *pv, size_t cPages);
1339
1340/**
1341 * Load a module into R0 HC.
1342 *
1343 * This will verify the file integrity in a similar manner as
1344 * SUPR3HardenedVerifyFile before loading it.
1345 *
1346 * @returns VBox status code.
1347 * @param pszFilename The path to the image file.
1348 * @param pszModule The module name. Max 32 bytes.
1349 * @param ppvImageBase Where to store the image address.
1350 * @param pErrInfo Where to return extended error information.
1351 * Optional.
1352 */
1353SUPR3DECL(int) SUPR3LoadModule(const char *pszFilename, const char *pszModule, void **ppvImageBase, PRTERRINFO pErrInfo);
1354
1355/**
1356 * Load a module into R0 HC.
1357 *
1358 * This will verify the file integrity in a similar manner as
1359 * SUPR3HardenedVerifyFile before loading it.
1360 *
1361 * @returns VBox status code.
1362 * @param pszFilename The path to the image file.
1363 * @param pszModule The module name. Max 32 bytes.
1364 * @param pszSrvReqHandler The name of the service request handler entry
1365 * point. See FNSUPR0SERVICEREQHANDLER.
1366 * @param ppvImageBase Where to store the image address.
1367 */
1368SUPR3DECL(int) SUPR3LoadServiceModule(const char *pszFilename, const char *pszModule,
1369 const char *pszSrvReqHandler, void **ppvImageBase);
1370
1371/**
1372 * Frees a R0 HC module.
1373 *
1374 * @returns VBox status code.
1375 * @param pvImageBase The base address of the image to free.
1376 * @remark This will not actually 'free' the module, there are of course usage counting.
1377 */
1378SUPR3DECL(int) SUPR3FreeModule(void *pvImageBase);
1379
1380/**
1381 * Lock down the module loader interface.
1382 *
1383 * This will lock down the module loader interface. No new modules can be
1384 * loaded and all loaded modules can no longer be freed.
1385 *
1386 * @returns VBox status code.
1387 * @param pErrInfo Where to return extended error information.
1388 * Optional.
1389 */
1390SUPR3DECL(int) SUPR3LockDownLoader(PRTERRINFO pErrInfo);
1391
1392/**
1393 * Get the address of a symbol in a ring-0 module.
1394 *
1395 * @returns VBox status code.
1396 * @param pvImageBase The base address of the image to search.
1397 * @param pszSymbol Symbol name. If it's value is less than 64k it's treated like a
1398 * ordinal value rather than a string pointer.
1399 * @param ppvValue Where to store the symbol value.
1400 */
1401SUPR3DECL(int) SUPR3GetSymbolR0(void *pvImageBase, const char *pszSymbol, void **ppvValue);
1402
1403/**
1404 * Load R0 HC VMM code.
1405 *
1406 * @returns VBox status code.
1407 * @deprecated Use SUPR3LoadModule(pszFilename, "VMMR0.r0", &pvImageBase)
1408 */
1409SUPR3DECL(int) SUPR3LoadVMM(const char *pszFilename);
1410
1411/**
1412 * Unloads R0 HC VMM code.
1413 *
1414 * @returns VBox status code.
1415 * @deprecated Use SUPR3FreeModule().
1416 */
1417SUPR3DECL(int) SUPR3UnloadVMM(void);
1418
1419/**
1420 * Get the physical address of the GIP.
1421 *
1422 * @returns VBox status code.
1423 * @param pHCPhys Where to store the physical address of the GIP.
1424 */
1425SUPR3DECL(int) SUPR3GipGetPhys(PRTHCPHYS pHCPhys);
1426
1427/**
1428 * Initializes only the bits relevant for the SUPR3HardenedVerify* APIs.
1429 *
1430 * This is for users that don't necessarily need to initialize the whole of
1431 * SUPLib. There is no harm in calling this one more time.
1432 *
1433 * @returns VBox status code.
1434 * @remarks Currently not counted, so only call once.
1435 */
1436SUPR3DECL(int) SUPR3HardenedVerifyInit(void);
1437
1438/**
1439 * Reverses the effect of SUPR3HardenedVerifyInit if SUPR3InitEx hasn't been
1440 * called.
1441 *
1442 * Ignored if the support library was initialized using SUPR3Init or
1443 * SUPR3InitEx.
1444 *
1445 * @returns VBox status code.
1446 */
1447SUPR3DECL(int) SUPR3HardenedVerifyTerm(void);
1448
1449/**
1450 * Verifies the integrity of a file, and optionally opens it.
1451 *
1452 * The integrity check is for whether the file is suitable for loading into
1453 * the hypervisor or VM process. The integrity check may include verifying
1454 * the authenticode/elfsign/whatever signature of the file, which can take
1455 * a little while.
1456 *
1457 * @returns VBox status code. On failure it will have printed a LogRel message.
1458 *
1459 * @param pszFilename The file.
1460 * @param pszWhat For the LogRel on failure.
1461 * @param phFile Where to store the handle to the opened file. This is optional, pass NULL
1462 * if the file should not be opened.
1463 * @deprecated Write a new one.
1464 */
1465SUPR3DECL(int) SUPR3HardenedVerifyFile(const char *pszFilename, const char *pszWhat, PRTFILE phFile);
1466
1467/**
1468 * Verifies the integrity of a the current process, including the image
1469 * location and that the invocation was absolute.
1470 *
1471 * This must currently be called after initializing the runtime. The intended
1472 * audience is set-uid-to-root applications, root services and similar.
1473 *
1474 * @returns VBox status code. On failure
1475 * message.
1476 * @param pszArgv0 The first argument to main().
1477 * @param fInternal Set this to @c true if this is an internal
1478 * VirtualBox application. Otherwise pass @c false.
1479 * @param pErrInfo Where to return extended error information.
1480 */
1481SUPR3DECL(int) SUPR3HardenedVerifySelf(const char *pszArgv0, bool fInternal, PRTERRINFO pErrInfo);
1482
1483/**
1484 * Verifies the integrity of an installation directory.
1485 *
1486 * The integrity check verifies that the directory cannot be tampered with by
1487 * normal users on the system. On Unix this translates to root ownership and
1488 * no symbolic linking.
1489 *
1490 * @returns VBox status code. On failure a message will be stored in @a pszErr.
1491 *
1492 * @param pszDirPath The directory path.
1493 * @param fRecursive Whether the check should be recursive or
1494 * not. When set, all sub-directores will be checked,
1495 * including files (@a fCheckFiles is ignored).
1496 * @param fCheckFiles Whether to apply the same basic integrity check to
1497 * the files in the directory as the directory itself.
1498 * @param pErrInfo Where to return extended error information.
1499 * Optional.
1500 */
1501SUPR3DECL(int) SUPR3HardenedVerifyDir(const char *pszDirPath, bool fRecursive, bool fCheckFiles, PRTERRINFO pErrInfo);
1502
1503/**
1504 * Verifies the integrity of a plug-in module.
1505 *
1506 * This is similar to SUPR3HardenedLdrLoad, except it does not load the module
1507 * and that the module does not have to be shipped with VirtualBox.
1508 *
1509 * @returns VBox status code. On failure a message will be stored in @a pszErr.
1510 *
1511 * @param pszFilename The filename of the plug-in module (nothing can be
1512 * omitted here).
1513 * @param pErrInfo Where to return extended error information.
1514 * Optional.
1515 */
1516SUPR3DECL(int) SUPR3HardenedVerifyPlugIn(const char *pszFilename, PRTERRINFO pErrInfo);
1517
1518/**
1519 * Same as RTLdrLoad() but will verify the files it loads (hardened builds).
1520 *
1521 * Will add dll suffix if missing and try load the file.
1522 *
1523 * @returns iprt status code.
1524 * @param pszFilename Image filename. This must have a path.
1525 * @param phLdrMod Where to store the handle to the loaded module.
1526 * @param fFlags See RTLDRLOAD_FLAGS_XXX.
1527 * @param pErrInfo Where to return extended error information.
1528 * Optional.
1529 */
1530SUPR3DECL(int) SUPR3HardenedLdrLoad(const char *pszFilename, PRTLDRMOD phLdrMod, uint32_t fFlags, PRTERRINFO pErrInfo);
1531
1532/**
1533 * Same as RTLdrLoadAppPriv() but it will verify the files it loads (hardened
1534 * builds).
1535 *
1536 * Will add dll suffix to the file if missing, then look for it in the
1537 * architecture dependent application directory.
1538 *
1539 * @returns iprt status code.
1540 * @param pszFilename Image filename.
1541 * @param phLdrMod Where to store the handle to the loaded module.
1542 * @param fFlags See RTLDRLOAD_FLAGS_XXX.
1543 * @param pErrInfo Where to return extended error information.
1544 * Optional.
1545 */
1546SUPR3DECL(int) SUPR3HardenedLdrLoadAppPriv(const char *pszFilename, PRTLDRMOD phLdrMod, uint32_t fFlags, PRTERRINFO pErrInfo);
1547
1548/**
1549 * Same as RTLdrLoad() but will verify the files it loads (hardened builds).
1550 *
1551 * This differs from SUPR3HardenedLdrLoad() in that it can load modules from
1552 * extension packs and anything else safely installed on the system, provided
1553 * they pass the hardening tests.
1554 *
1555 * @returns iprt status code.
1556 * @param pszFilename The full path to the module, with extension.
1557 * @param phLdrMod Where to store the handle to the loaded module.
1558 * @param pErrInfo Where to return extended error information.
1559 * Optional.
1560 */
1561SUPR3DECL(int) SUPR3HardenedLdrLoadPlugIn(const char *pszFilename, PRTLDRMOD phLdrMod, PRTERRINFO pErrInfo);
1562
1563/**
1564 * Check if the host kernel can run in VMX root mode.
1565 *
1566 * @returns VINF_SUCCESS if supported, error code indicating why if not.
1567 */
1568SUPR3DECL(int) SUPR3QueryVTxSupported(void);
1569
1570/**
1571 * Return VT-x/AMD-V capabilities.
1572 *
1573 * @returns VINF_SUCCESS if supported, error code indicating why if not.
1574 * @param pfCaps Pointer to capability dword (out).
1575 * @todo Intended for main, which means we need to relax the privilege requires
1576 * when accessing certain vboxdrv functions.
1577 */
1578SUPR3DECL(int) SUPR3QueryVTCaps(uint32_t *pfCaps);
1579
1580/**
1581 * Open the tracer.
1582 *
1583 * @returns VBox status code.
1584 * @param uCookie Cookie identifying the tracer we expect to talk to.
1585 * @param uArg Tracer specific open argument.
1586 */
1587SUPR3DECL(int) SUPR3TracerOpen(uint32_t uCookie, uintptr_t uArg);
1588
1589/**
1590 * Closes the tracer.
1591 *
1592 * @returns VBox status code.
1593 */
1594SUPR3DECL(int) SUPR3TracerClose(void);
1595
1596/**
1597 * Perform an I/O request on the tracer.
1598 *
1599 * @returns VBox status.
1600 * @param uCmd The tracer command.
1601 * @param uArg The argument.
1602 * @param piRetVal Where to store the tracer return value.
1603 */
1604SUPR3DECL(int) SUPR3TracerIoCtl(uintptr_t uCmd, uintptr_t uArg, int32_t *piRetVal);
1605
1606/**
1607 * Registers the user module with the tracer.
1608 *
1609 * @returns VBox status code.
1610 * @param hModNative Native module handle. Pass ~(uintptr_t)0 if not
1611 * at hand.
1612 * @param pszModule The module name.
1613 * @param pVtgHdr The VTG header.
1614 * @param uVtgHdrAddr The address to which the VTG header is loaded
1615 * in the relevant execution context.
1616 * @param fFlags See SUP_TRACER_UMOD_FLAGS_XXX
1617 */
1618SUPR3DECL(int) SUPR3TracerRegisterModule(uintptr_t hModNative, const char *pszModule, struct VTGOBJHDR *pVtgHdr,
1619 RTUINTPTR uVtgHdrAddr, uint32_t fFlags);
1620
1621/**
1622 * Deregisters the user module.
1623 *
1624 * @returns VBox status code.
1625 * @param pVtgHdr The VTG header.
1626 */
1627SUPR3DECL(int) SUPR3TracerDeregisterModule(struct VTGOBJHDR *pVtgHdr);
1628
1629/**
1630 * Fire the probe.
1631 *
1632 * @param pVtgProbeLoc The probe location record.
1633 * @param uArg0 Raw probe argument 0.
1634 * @param uArg1 Raw probe argument 1.
1635 * @param uArg2 Raw probe argument 2.
1636 * @param uArg3 Raw probe argument 3.
1637 * @param uArg4 Raw probe argument 4.
1638 */
1639SUPDECL(void) SUPTracerFireProbe(struct VTGPROBELOC *pVtgProbeLoc, uintptr_t uArg0, uintptr_t uArg1, uintptr_t uArg2,
1640 uintptr_t uArg3, uintptr_t uArg4);
1641
1642/**
1643 * Attempts to read the value of an MSR.
1644 *
1645 * @returns VBox status code.
1646 * @param uMsr The MSR to read.
1647 * @param idCpu The CPU to read it on, NIL_RTCPUID if it doesn't
1648 * matter which CPU.
1649 * @param puValue Where to return the value.
1650 * @param pfGp Where to store the \#GP indicator for the read
1651 * operation.
1652 */
1653SUPR3DECL(int) SUPR3MsrProberRead(uint32_t uMsr, RTCPUID idCpu, uint64_t *puValue, bool *pfGp);
1654
1655/**
1656 * Attempts to write to an MSR.
1657 *
1658 * @returns VBox status code.
1659 * @param uMsr The MSR to write to.
1660 * @param idCpu The CPU to wrtie it on, NIL_RTCPUID if it
1661 * doesn't matter which CPU.
1662 * @param uValue The value to write.
1663 * @param pfGp Where to store the \#GP indicator for the write
1664 * operation.
1665 */
1666SUPR3DECL(int) SUPR3MsrProberWrite(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue, bool *pfGp);
1667
1668/**
1669 * Attempts to modify the value of an MSR.
1670 *
1671 * @returns VBox status code.
1672 * @param uMsr The MSR to modify.
1673 * @param idCpu The CPU to modify it on, NIL_RTCPUID if it
1674 * doesn't matter which CPU.
1675 * @param fAndMask The bits to keep in the current MSR value.
1676 * @param fOrMask The bits to set before writing.
1677 * @param pResult The result buffer.
1678 */
1679SUPR3DECL(int) SUPR3MsrProberModify(uint32_t uMsr, RTCPUID idCpu, uint64_t fAndMask, uint64_t fOrMask,
1680 PSUPMSRPROBERMODIFYRESULT pResult);
1681
1682/**
1683 * Attempts to modify the value of an MSR, extended version.
1684 *
1685 * @returns VBox status code.
1686 * @param uMsr The MSR to modify.
1687 * @param idCpu The CPU to modify it on, NIL_RTCPUID if it
1688 * doesn't matter which CPU.
1689 * @param fAndMask The bits to keep in the current MSR value.
1690 * @param fOrMask The bits to set before writing.
1691 * @param fFaster If set to @c true some cache/tlb invalidation is
1692 * skipped, otherwise behave like
1693 * SUPR3MsrProberModify.
1694 * @param pResult The result buffer.
1695 */
1696SUPR3DECL(int) SUPR3MsrProberModifyEx(uint32_t uMsr, RTCPUID idCpu, uint64_t fAndMask, uint64_t fOrMask, bool fFaster,
1697 PSUPMSRPROBERMODIFYRESULT pResult);
1698
1699/**
1700 * Resume built-in keyboard on MacBook Air and Pro hosts.
1701 *
1702 * @returns VBox status code.
1703 */
1704SUPR3DECL(int) SUPR3ResumeSuspendedKeyboards(void);
1705
1706/**
1707 * Measure the TSC-delta for the specified CPU.
1708 *
1709 * @returns VBox status code.
1710 * @param idCpu The CPU to measure the TSC-delta for.
1711 * @param fAsync Whether the measurement is asynchronous, returns
1712 * immediately after signalling a measurement
1713 * request.
1714 * @param fForce Whether to perform a measurement even if the
1715 * specified CPU has a (possibly) valid TSC delta.
1716 * @param cRetries Number of times to retry failed delta
1717 * measurements.
1718 * @param cMsWaitRetry Number of milliseconds to wait between retries.
1719 */
1720SUPR3DECL(int) SUPR3TscDeltaMeasure(RTCPUID idCpu, bool fAsync, bool fForce, uint8_t cRetries, uint8_t cMsWaitRetry);
1721
1722/**
1723 * Reads the delta-adjust TSC value.
1724 *
1725 * @returns VBox status code.
1726 * @param puTsc Where to store the read TSC value.
1727 * @param pidApic Where to store the APIC ID of the CPU where the TSC
1728 * was read (optional, can be NULL).
1729 */
1730SUPR3DECL(int) SUPR3ReadTsc(uint64_t *puTsc, uint16_t *pidApic);
1731
1732/**
1733 * Modifies the GIP flags.
1734 *
1735 * @returns VBox status code.
1736 * @param fOrMask The OR mask of the GIP flags, see SUPGIP_FLAGS_XXX.
1737 * @param fAndMask The AND mask of the GIP flags, see SUPGIP_FLAGS_XXX.
1738 */
1739SUPR3DECL(int) SUPR3GipSetFlags(uint32_t fOrMask, uint32_t fAndMask);
1740
1741/** @} */
1742#endif /* IN_RING3 */
1743
1744
1745/** @name User mode module flags (SUPR3TracerRegisterModule & SUP_IOCTL_TRACER_UMOD_REG).
1746 * @{ */
1747/** Executable image. */
1748#define SUP_TRACER_UMOD_FLAGS_EXE UINT32_C(1)
1749/** Shared library (DLL, DYLIB, SO, etc). */
1750#define SUP_TRACER_UMOD_FLAGS_SHARED UINT32_C(2)
1751/** Image type mask. */
1752#define SUP_TRACER_UMOD_FLAGS_TYPE_MASK UINT32_C(3)
1753/** @} */
1754
1755
1756#ifdef IN_RING0
1757/** @defgroup grp_sup_r0 SUP Host Context Ring-0 API
1758 * @{
1759 */
1760
1761/**
1762 * Security objectype.
1763 */
1764typedef enum SUPDRVOBJTYPE
1765{
1766 /** The usual invalid object. */
1767 SUPDRVOBJTYPE_INVALID = 0,
1768 /** A Virtual Machine instance. */
1769 SUPDRVOBJTYPE_VM,
1770 /** Internal network. */
1771 SUPDRVOBJTYPE_INTERNAL_NETWORK,
1772 /** Internal network interface. */
1773 SUPDRVOBJTYPE_INTERNAL_NETWORK_INTERFACE,
1774 /** Single release event semaphore. */
1775 SUPDRVOBJTYPE_SEM_EVENT,
1776 /** Multiple release event semaphore. */
1777 SUPDRVOBJTYPE_SEM_EVENT_MULTI,
1778 /** Raw PCI device. */
1779 SUPDRVOBJTYPE_RAW_PCI_DEVICE,
1780 /** The first invalid object type in this end. */
1781 SUPDRVOBJTYPE_END,
1782 /** The usual 32-bit type size hack. */
1783 SUPDRVOBJTYPE_32_BIT_HACK = 0x7ffffff
1784} SUPDRVOBJTYPE;
1785
1786/**
1787 * Object destructor callback.
1788 * This is called for reference counted objectes when the count reaches 0.
1789 *
1790 * @param pvObj The object pointer.
1791 * @param pvUser1 The first user argument.
1792 * @param pvUser2 The second user argument.
1793 */
1794typedef DECLCALLBACK(void) FNSUPDRVDESTRUCTOR(void *pvObj, void *pvUser1, void *pvUser2);
1795/** Pointer to a FNSUPDRVDESTRUCTOR(). */
1796typedef FNSUPDRVDESTRUCTOR *PFNSUPDRVDESTRUCTOR;
1797
1798SUPR0DECL(void *) SUPR0ObjRegister(PSUPDRVSESSION pSession, SUPDRVOBJTYPE enmType, PFNSUPDRVDESTRUCTOR pfnDestructor, void *pvUser1, void *pvUser2);
1799SUPR0DECL(int) SUPR0ObjAddRef(void *pvObj, PSUPDRVSESSION pSession);
1800SUPR0DECL(int) SUPR0ObjAddRefEx(void *pvObj, PSUPDRVSESSION pSession, bool fNoBlocking);
1801SUPR0DECL(int) SUPR0ObjRelease(void *pvObj, PSUPDRVSESSION pSession);
1802SUPR0DECL(int) SUPR0ObjVerifyAccess(void *pvObj, PSUPDRVSESSION pSession, const char *pszObjName);
1803
1804SUPR0DECL(int) SUPR0LockMem(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages);
1805SUPR0DECL(int) SUPR0UnlockMem(PSUPDRVSESSION pSession, RTR3PTR pvR3);
1806SUPR0DECL(int) SUPR0ContAlloc(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS pHCPhys);
1807SUPR0DECL(int) SUPR0ContFree(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
1808SUPR0DECL(int) SUPR0LowAlloc(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS paPages);
1809SUPR0DECL(int) SUPR0LowFree(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
1810SUPR0DECL(int) SUPR0MemAlloc(PSUPDRVSESSION pSession, uint32_t cb, PRTR0PTR ppvR0, PRTR3PTR ppvR3);
1811SUPR0DECL(int) SUPR0MemGetPhys(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, PSUPPAGE paPages);
1812SUPR0DECL(int) SUPR0MemFree(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
1813SUPR0DECL(int) SUPR0PageAllocEx(PSUPDRVSESSION pSession, uint32_t cPages, uint32_t fFlags, PRTR3PTR ppvR3, PRTR0PTR ppvR0, PRTHCPHYS paPages);
1814SUPR0DECL(int) SUPR0PageMapKernel(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t offSub, uint32_t cbSub, uint32_t fFlags, PRTR0PTR ppvR0);
1815SUPR0DECL(int) SUPR0PageProtect(PSUPDRVSESSION pSession, RTR3PTR pvR3, RTR0PTR pvR0, uint32_t offSub, uint32_t cbSub, uint32_t fProt);
1816SUPR0DECL(int) SUPR0PageFree(PSUPDRVSESSION pSession, RTR3PTR pvR3);
1817SUPR0DECL(int) SUPR0GipMap(PSUPDRVSESSION pSession, PRTR3PTR ppGipR3, PRTHCPHYS pHCPhysGip);
1818SUPR0DECL(int) SUPR0GetSvmUsability(bool fInitSvm);
1819SUPR0DECL(int) SUPR0GetVmxUsability(bool *pfIsSmxModeAmbiguous);
1820SUPR0DECL(int) SUPR0QueryVTCaps(PSUPDRVSESSION pSession, uint32_t *pfCaps);
1821SUPR0DECL(int) SUPR0GipUnmap(PSUPDRVSESSION pSession);
1822SUPR0DECL(SUPPAGINGMODE) SUPR0GetPagingMode(void);
1823SUPR0DECL(RTCCUINTREG) SUPR0ChangeCR4(RTCCUINTREG fOrMask, RTCCUINTREG fAndMask);
1824SUPR0DECL(int) SUPR0EnableVTx(bool fEnable);
1825SUPR0DECL(bool) SUPR0SuspendVTxOnCpu(void);
1826SUPR0DECL(void) SUPR0ResumeVTxOnCpu(bool fSuspended);
1827#define SUP_TSCDELTA_MEASURE_F_FORCE RT_BIT_32(0)
1828#define SUP_TSCDELTA_MEASURE_F_ASYNC RT_BIT_32(1)
1829#define SUP_TSCDELTA_MEASURE_F_VALID_MASK UINT32_C(0x00000003)
1830SUPR0DECL(int) SUPR0TscDeltaMeasureBySetIndex(PSUPDRVSESSION pSession, uint32_t iCpuSet, uint32_t fFlags,
1831 RTMSINTERVAL cMsWaitRetry, RTMSINTERVAL cMsWaitThread, uint32_t cTries);
1832
1833SUPR0DECL(void) SUPR0BadContext(PSUPDRVSESSION pSession, const char *pszFile, uint32_t uLine, const char *pszExpr);
1834
1835/**
1836 * Writes to the debugger and/or kernel log.
1837 *
1838 * The length of the formatted message is somewhat limited, so keep things short
1839 * and to the point.
1840 *
1841 * @returns Number of bytes written, mabye.
1842 * @param pszFormat IPRT format string.
1843 * @param ... Arguments referenced by the format string.
1844 */
1845SUPR0DECL(int) SUPR0Printf(const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(1, 2);
1846
1847/**
1848 * Returns configuration flags of the host kernel.
1849 *
1850 * @returns Combination of SUPKERNELFEATURES_XXX flags.
1851 */
1852SUPR0DECL(uint32_t) SUPR0GetKernelFeatures(void);
1853
1854
1855/** @name Absolute symbols
1856 * Take the address of these, don't try call them.
1857 * @{ */
1858SUPR0DECL(void) SUPR0AbsIs64bit(void);
1859SUPR0DECL(void) SUPR0Abs64bitKernelCS(void);
1860SUPR0DECL(void) SUPR0Abs64bitKernelSS(void);
1861SUPR0DECL(void) SUPR0Abs64bitKernelDS(void);
1862SUPR0DECL(void) SUPR0AbsKernelCS(void);
1863SUPR0DECL(void) SUPR0AbsKernelSS(void);
1864SUPR0DECL(void) SUPR0AbsKernelDS(void);
1865SUPR0DECL(void) SUPR0AbsKernelES(void);
1866SUPR0DECL(void) SUPR0AbsKernelFS(void);
1867SUPR0DECL(void) SUPR0AbsKernelGS(void);
1868/** @} */
1869
1870/**
1871 * Support driver component factory.
1872 *
1873 * Component factories are registered by drivers that provides services
1874 * such as the host network interface filtering and access to the host
1875 * TCP/IP stack.
1876 *
1877 * @remark Module dependencies and making sure that a component doesn't
1878 * get unloaded while in use, is the sole responsibility of the
1879 * driver/kext/whatever implementing the component.
1880 */
1881typedef struct SUPDRVFACTORY
1882{
1883 /** The (unique) name of the component factory. */
1884 char szName[56];
1885 /**
1886 * Queries a factory interface.
1887 *
1888 * The factory interface is specific to each component and will be be
1889 * found in the header(s) for the component alongside its UUID.
1890 *
1891 * @returns Pointer to the factory interfaces on success, NULL on failure.
1892 *
1893 * @param pSupDrvFactory Pointer to this structure.
1894 * @param pSession The SUPDRV session making the query.
1895 * @param pszInterfaceUuid The UUID of the factory interface.
1896 */
1897 DECLR0CALLBACKMEMBER(void *, pfnQueryFactoryInterface,(struct SUPDRVFACTORY const *pSupDrvFactory, PSUPDRVSESSION pSession, const char *pszInterfaceUuid));
1898} SUPDRVFACTORY;
1899/** Pointer to a support driver factory. */
1900typedef SUPDRVFACTORY *PSUPDRVFACTORY;
1901/** Pointer to a const support driver factory. */
1902typedef SUPDRVFACTORY const *PCSUPDRVFACTORY;
1903
1904SUPR0DECL(int) SUPR0ComponentRegisterFactory(PSUPDRVSESSION pSession, PCSUPDRVFACTORY pFactory);
1905SUPR0DECL(int) SUPR0ComponentDeregisterFactory(PSUPDRVSESSION pSession, PCSUPDRVFACTORY pFactory);
1906SUPR0DECL(int) SUPR0ComponentQueryFactory(PSUPDRVSESSION pSession, const char *pszName, const char *pszInterfaceUuid, void **ppvFactoryIf);
1907
1908
1909/** @name Tracing
1910 * @{ */
1911
1912/**
1913 * Tracer data associated with a provider.
1914 */
1915typedef union SUPDRVTRACERDATA
1916{
1917 /** Generic */
1918 uint64_t au64[2];
1919
1920 /** DTrace data. */
1921 struct
1922 {
1923 /** Provider ID. */
1924 uintptr_t idProvider;
1925 /** The number of trace points provided. */
1926 uint32_t volatile cProvidedProbes;
1927 /** Whether we've invalidated this bugger. */
1928 bool fZombie;
1929 } DTrace;
1930} SUPDRVTRACERDATA;
1931/** Pointer to the tracer data associated with a provider. */
1932typedef SUPDRVTRACERDATA *PSUPDRVTRACERDATA;
1933
1934/**
1935 * Probe location info for ring-0.
1936 *
1937 * Since we cannot trust user tracepoint modules, we need to duplicate the probe
1938 * ID and enabled flag in ring-0.
1939 */
1940typedef struct SUPDRVPROBELOC
1941{
1942 /** The probe ID. */
1943 uint32_t idProbe;
1944 /** Whether it's enabled or not. */
1945 bool fEnabled;
1946} SUPDRVPROBELOC;
1947/** Pointer to a ring-0 probe location record. */
1948typedef SUPDRVPROBELOC *PSUPDRVPROBELOC;
1949
1950/**
1951 * Probe info for ring-0.
1952 *
1953 * Since we cannot trust user tracepoint modules, we need to duplicate the
1954 * probe enable count.
1955 */
1956typedef struct SUPDRVPROBEINFO
1957{
1958 /** The number of times this probe has been enabled. */
1959 uint32_t volatile cEnabled;
1960} SUPDRVPROBEINFO;
1961/** Pointer to a ring-0 probe info record. */
1962typedef SUPDRVPROBEINFO *PSUPDRVPROBEINFO;
1963
1964/**
1965 * Support driver tracepoint provider core.
1966 */
1967typedef struct SUPDRVVDTPROVIDERCORE
1968{
1969 /** The tracer data member. */
1970 SUPDRVTRACERDATA TracerData;
1971 /** Pointer to the provider name (a copy that's always available). */
1972 const char *pszName;
1973 /** Pointer to the module name (a copy that's always available). */
1974 const char *pszModName;
1975
1976 /** The provider descriptor. */
1977 struct VTGDESCPROVIDER *pDesc;
1978 /** The VTG header. */
1979 struct VTGOBJHDR *pHdr;
1980
1981 /** The size of the entries in the pvProbeLocsEn table. */
1982 uint8_t cbProbeLocsEn;
1983 /** The actual module bit count (corresponds to cbProbeLocsEn). */
1984 uint8_t cBits;
1985 /** Set if this is a Umod, otherwise clear. */
1986 bool fUmod;
1987 /** Explicit alignment padding (paranoia). */
1988 uint8_t abAlignment[ARCH_BITS == 32 ? 1 : 5];
1989
1990 /** The probe locations used for descriptive purposes. */
1991 struct VTGPROBELOC const *paProbeLocsRO;
1992 /** Pointer to the probe location array where the enable flag needs
1993 * flipping. For kernel providers, this will always be SUPDRVPROBELOC,
1994 * while user providers can either be 32-bit or 64-bit. Use
1995 * cbProbeLocsEn to calculate the address of an entry. */
1996 void *pvProbeLocsEn;
1997 /** Pointer to the probe array containing the enabled counts. */
1998 uint32_t *pacProbeEnabled;
1999
2000 /** The ring-0 probe location info for user tracepoint modules.
2001 * This is NULL if fUmod is false. */
2002 PSUPDRVPROBELOC paR0ProbeLocs;
2003 /** The ring-0 probe info for user tracepoint modules.
2004 * This is NULL if fUmod is false. */
2005 PSUPDRVPROBEINFO paR0Probes;
2006
2007} SUPDRVVDTPROVIDERCORE;
2008/** Pointer to a tracepoint provider core structure. */
2009typedef SUPDRVVDTPROVIDERCORE *PSUPDRVVDTPROVIDERCORE;
2010
2011/** Pointer to a tracer registration record. */
2012typedef struct SUPDRVTRACERREG const *PCSUPDRVTRACERREG;
2013/**
2014 * Support driver tracer registration record.
2015 */
2016typedef struct SUPDRVTRACERREG
2017{
2018 /** Magic value (SUPDRVTRACERREG_MAGIC). */
2019 uint32_t u32Magic;
2020 /** Version (SUPDRVTRACERREG_VERSION). */
2021 uint32_t u32Version;
2022
2023 /**
2024 * Fire off a kernel probe.
2025 *
2026 * @param pVtgProbeLoc The probe location record.
2027 * @param uArg0 The first raw probe argument.
2028 * @param uArg1 The second raw probe argument.
2029 * @param uArg2 The third raw probe argument.
2030 * @param uArg3 The fourth raw probe argument.
2031 * @param uArg4 The fifth raw probe argument.
2032 *
2033 * @remarks SUPR0TracerFireProbe will do a tail jump thru this member, so
2034 * no extra stack frames will be added.
2035 * @remarks This does not take a 'this' pointer argument because it doesn't map
2036 * well onto VTG or DTrace.
2037 *
2038 */
2039 DECLR0CALLBACKMEMBER(void, pfnProbeFireKernel, (struct VTGPROBELOC *pVtgProbeLoc, uintptr_t uArg0, uintptr_t uArg1, uintptr_t uArg2,
2040 uintptr_t uArg3, uintptr_t uArg4));
2041
2042 /**
2043 * Fire off a user-mode probe.
2044 *
2045 * @param pThis Pointer to the registration record.
2046 *
2047 * @param pVtgProbeLoc The probe location record.
2048 * @param pSession The user session.
2049 * @param pCtx The usermode context info.
2050 * @param pVtgHdr The VTG header (read-only).
2051 * @param pProbeLocRO The read-only probe location record .
2052 */
2053 DECLR0CALLBACKMEMBER(void, pfnProbeFireUser, (PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, PCSUPDRVTRACERUSRCTX pCtx,
2054 struct VTGOBJHDR const *pVtgHdr, struct VTGPROBELOC const *pProbeLocRO));
2055
2056 /**
2057 * Opens up the tracer.
2058 *
2059 * @returns VBox status code.
2060 * @param pThis Pointer to the registration record.
2061 * @param pSession The session doing the opening.
2062 * @param uCookie A cookie (magic) unique to the tracer, so it can
2063 * fend off incompatible clients.
2064 * @param uArg Tracer specific argument.
2065 * @param puSessionData Pointer to the session data variable. This must be
2066 * set to a non-zero value on success.
2067 */
2068 DECLR0CALLBACKMEMBER(int, pfnTracerOpen, (PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uint32_t uCookie, uintptr_t uArg,
2069 uintptr_t *puSessionData));
2070
2071 /**
2072 * I/O control style tracer communication method.
2073 *
2074 *
2075 * @returns VBox status code.
2076 * @param pThis Pointer to the registration record.
2077 * @param pSession The session.
2078 * @param uSessionData The session data value.
2079 * @param uCmd The tracer specific command.
2080 * @param uArg The tracer command specific argument.
2081 * @param piRetVal The tracer specific return value.
2082 */
2083 DECLR0CALLBACKMEMBER(int, pfnTracerIoCtl, (PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uintptr_t uSessionData,
2084 uintptr_t uCmd, uintptr_t uArg, int32_t *piRetVal));
2085
2086 /**
2087 * Cleans up data the tracer has associated with a session.
2088 *
2089 * @param pThis Pointer to the registration record.
2090 * @param pSession The session handle.
2091 * @param uSessionData The data assoicated with the session.
2092 */
2093 DECLR0CALLBACKMEMBER(void, pfnTracerClose, (PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uintptr_t uSessionData));
2094
2095 /**
2096 * Registers a provider.
2097 *
2098 * @returns VBox status code.
2099 * @param pThis Pointer to the registration record.
2100 * @param pCore The provider core data.
2101 *
2102 * @todo Kernel vs. Userland providers.
2103 */
2104 DECLR0CALLBACKMEMBER(int, pfnProviderRegister, (PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore));
2105
2106 /**
2107 * Attempts to deregisters a provider.
2108 *
2109 * @returns VINF_SUCCESS or VERR_TRY_AGAIN. If the latter, the provider
2110 * should be made as harmless as possible before returning as the
2111 * VTG object and associated code will be unloaded upon return.
2112 *
2113 * @param pThis Pointer to the registration record.
2114 * @param pCore The provider core data.
2115 */
2116 DECLR0CALLBACKMEMBER(int, pfnProviderDeregister, (PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore));
2117
2118 /**
2119 * Make another attempt at unregister a busy provider.
2120 *
2121 * @returns VINF_SUCCESS or VERR_TRY_AGAIN.
2122 * @param pThis Pointer to the registration record.
2123 * @param pCore The provider core data.
2124 */
2125 DECLR0CALLBACKMEMBER(int, pfnProviderDeregisterZombie, (PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore));
2126
2127 /** End marker (SUPDRVTRACERREG_MAGIC). */
2128 uintptr_t uEndMagic;
2129} SUPDRVTRACERREG;
2130
2131/** Tracer magic (Kenny Garrett). */
2132#define SUPDRVTRACERREG_MAGIC UINT32_C(0x19601009)
2133/** Tracer registration structure version. */
2134#define SUPDRVTRACERREG_VERSION RT_MAKE_U32(0, 1)
2135
2136/** Pointer to a trace helper structure. */
2137typedef struct SUPDRVTRACERHLP const *PCSUPDRVTRACERHLP;
2138/**
2139 * Helper structure.
2140 */
2141typedef struct SUPDRVTRACERHLP
2142{
2143 /** The structure version (SUPDRVTRACERHLP_VERSION). */
2144 uintptr_t uVersion;
2145
2146 /** @todo ... */
2147
2148 /** End marker (SUPDRVTRACERHLP_VERSION) */
2149 uintptr_t uEndVersion;
2150} SUPDRVTRACERHLP;
2151/** Tracer helper structure version. */
2152#define SUPDRVTRACERHLP_VERSION RT_MAKE_U32(0, 1)
2153
2154SUPR0DECL(int) SUPR0TracerRegisterImpl(void *hMod, PSUPDRVSESSION pSession, PCSUPDRVTRACERREG pReg, PCSUPDRVTRACERHLP *ppHlp);
2155SUPR0DECL(int) SUPR0TracerDeregisterImpl(void *hMod, PSUPDRVSESSION pSession);
2156SUPR0DECL(int) SUPR0TracerRegisterDrv(PSUPDRVSESSION pSession, struct VTGOBJHDR *pVtgHdr, const char *pszName);
2157SUPR0DECL(void) SUPR0TracerDeregisterDrv(PSUPDRVSESSION pSession);
2158SUPR0DECL(int) SUPR0TracerRegisterModule(void *hMod, struct VTGOBJHDR *pVtgHdr);
2159SUPR0DECL(void) SUPR0TracerFireProbe(struct VTGPROBELOC *pVtgProbeLoc, uintptr_t uArg0, uintptr_t uArg1, uintptr_t uArg2,
2160 uintptr_t uArg3, uintptr_t uArg4);
2161SUPR0DECL(void) SUPR0TracerUmodProbeFire(PSUPDRVSESSION pSession, PSUPDRVTRACERUSRCTX pCtx);
2162/** @} */
2163
2164
2165/**
2166 * Service request callback function.
2167 *
2168 * @returns VBox status code.
2169 * @param pSession The caller's session.
2170 * @param u64Arg 64-bit integer argument.
2171 * @param pReqHdr The request header. Input / Output. Optional.
2172 */
2173typedef DECLCALLBACK(int) FNSUPR0SERVICEREQHANDLER(PSUPDRVSESSION pSession, uint32_t uOperation,
2174 uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr);
2175/** Pointer to a FNR0SERVICEREQHANDLER(). */
2176typedef R0PTRTYPE(FNSUPR0SERVICEREQHANDLER *) PFNSUPR0SERVICEREQHANDLER;
2177
2178
2179/** @defgroup grp_sup_r0_idc The IDC Interface
2180 * @{
2181 */
2182
2183/** The current SUPDRV IDC version.
2184 * This follows the usual high word / low word rules, i.e. high word is the
2185 * major number and it signifies incompatible interface changes. */
2186#define SUPDRV_IDC_VERSION UINT32_C(0x00010000)
2187
2188/**
2189 * Inter-Driver Communication Handle.
2190 */
2191typedef union SUPDRVIDCHANDLE
2192{
2193 /** Padding for opaque usage.
2194 * Must be greater or equal in size than the private struct. */
2195 void *apvPadding[4];
2196#ifdef SUPDRVIDCHANDLEPRIVATE_DECLARED
2197 /** The private view. */
2198 struct SUPDRVIDCHANDLEPRIVATE s;
2199#endif
2200} SUPDRVIDCHANDLE;
2201/** Pointer to a handle. */
2202typedef SUPDRVIDCHANDLE *PSUPDRVIDCHANDLE;
2203
2204SUPR0DECL(int) SUPR0IdcOpen(PSUPDRVIDCHANDLE pHandle, uint32_t uReqVersion, uint32_t uMinVersion,
2205 uint32_t *puSessionVersion, uint32_t *puDriverVersion, uint32_t *puDriverRevision);
2206SUPR0DECL(int) SUPR0IdcCall(PSUPDRVIDCHANDLE pHandle, uint32_t iReq, void *pvReq, uint32_t cbReq);
2207SUPR0DECL(int) SUPR0IdcClose(PSUPDRVIDCHANDLE pHandle);
2208SUPR0DECL(PSUPDRVSESSION) SUPR0IdcGetSession(PSUPDRVIDCHANDLE pHandle);
2209SUPR0DECL(int) SUPR0IdcComponentRegisterFactory(PSUPDRVIDCHANDLE pHandle, PCSUPDRVFACTORY pFactory);
2210SUPR0DECL(int) SUPR0IdcComponentDeregisterFactory(PSUPDRVIDCHANDLE pHandle, PCSUPDRVFACTORY pFactory);
2211
2212/** @} */
2213
2214/** @name Ring-0 module entry points.
2215 *
2216 * These can be exported by ring-0 modules SUP are told to load.
2217 *
2218 * @{ */
2219DECLEXPORT(int) ModuleInit(void *hMod);
2220DECLEXPORT(void) ModuleTerm(void *hMod);
2221/** @} */
2222
2223
2224/** @} */
2225#endif
2226
2227
2228/** @name Trust Anchors and Certificates
2229 * @{ */
2230
2231/**
2232 * Trust anchor table entry (in generated Certificates.cpp).
2233 */
2234typedef struct SUPTAENTRY
2235{
2236 /** Pointer to the raw bytes. */
2237 const unsigned char *pch;
2238 /** Number of bytes. */
2239 unsigned cb;
2240} SUPTAENTRY;
2241/** Pointer to a trust anchor table entry. */
2242typedef SUPTAENTRY const *PCSUPTAENTRY;
2243
2244/** Macro for simplifying generating the trust anchor tables. */
2245#define SUPTAENTRY_GEN(a_abTA) { &a_abTA[0], sizeof(a_abTA) }
2246
2247/** All certificates we know. */
2248extern SUPTAENTRY const g_aSUPAllTAs[];
2249/** Number of entries in g_aSUPAllTAs. */
2250extern unsigned const g_cSUPAllTAs;
2251
2252/** Software publisher certificate roots (Authenticode). */
2253extern SUPTAENTRY const g_aSUPSpcRootTAs[];
2254/** Number of entries in g_aSUPSpcRootTAs. */
2255extern unsigned const g_cSUPSpcRootTAs;
2256
2257/** Kernel root certificates used by Windows. */
2258extern SUPTAENTRY const g_aSUPNtKernelRootTAs[];
2259/** Number of entries in g_aSUPNtKernelRootTAs. */
2260extern unsigned const g_cSUPNtKernelRootTAs;
2261
2262/** Timestamp root certificates trusted by Windows. */
2263extern SUPTAENTRY const g_aSUPTimestampTAs[];
2264/** Number of entries in g_aSUPTimestampTAs. */
2265extern unsigned const g_cSUPTimestampTAs;
2266
2267/** TAs we trust (the build certificate, Oracle VirtualBox). */
2268extern SUPTAENTRY const g_aSUPTrustedTAs[];
2269/** Number of entries in g_aSUPTrustedTAs. */
2270extern unsigned const g_cSUPTrustedTAs;
2271
2272/** Supplemental certificates, like cross signing certificates. */
2273extern SUPTAENTRY const g_aSUPSupplementalTAs[];
2274/** Number of entries in g_aSUPTrustedTAs. */
2275extern unsigned const g_cSUPSupplementalTAs;
2276
2277/** The build certificate. */
2278extern const unsigned char g_abSUPBuildCert[];
2279/** The size of the build certificate. */
2280extern const unsigned g_cbSUPBuildCert;
2281
2282/** @} */
2283
2284
2285/** @} */
2286
2287RT_C_DECLS_END
2288
2289#endif
2290
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette