VirtualBox

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

Last change on this file since 56733 was 56733, checked in by vboxsync, 10 years ago

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

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