VirtualBox

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

Last change on this file since 93256 was 93115, checked in by vboxsync, 3 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 58.2 KB
Line 
1/* $Id: SUPDrvIOC.h 93115 2022-01-01 11:31:46Z vboxsync $ */
2/** @file
3 * VirtualBox Support Driver - IOCtl definitions.
4 */
5
6/*
7 * Copyright (C) 2006-2022 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27#ifndef VBOX_INCLUDED_SRC_Support_SUPDrvIOC_h
28#define VBOX_INCLUDED_SRC_Support_SUPDrvIOC_h
29#ifndef RT_WITHOUT_PRAGMA_ONCE
30# pragma once
31#endif
32
33#include <iprt/types.h>
34#include <VBox/sup.h>
35
36/*
37 * IOCtl numbers.
38 * We're using the Win32 type of numbers here, thus the macros below.
39 * The SUP_IOCTL_FLAG macro is used to separate requests from 32-bit
40 * and 64-bit processes.
41 */
42#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_SPARC64) || defined(RT_ARCH_ARM64)
43# define SUP_IOCTL_FLAG 128
44#elif defined(RT_ARCH_X86) || defined(RT_ARCH_SPARC) || defined(RT_ARCH_ARM32)
45# define SUP_IOCTL_FLAG 0
46#else
47# error "dunno which arch this is!"
48#endif
49
50#ifdef RT_OS_WINDOWS
51# ifndef CTL_CODE
52# include <iprt/win/windows.h>
53# endif
54 /* Automatic buffering, size not encoded. */
55# define SUP_CTL_CODE_SIZE(Function, Size) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) | SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
56# define SUP_CTL_CODE_BIG(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) | SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
57# define SUP_CTL_CODE_FAST(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) | SUP_IOCTL_FLAG, METHOD_NEITHER, FILE_WRITE_ACCESS)
58# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
59
60# define SUP_NT_STATUS_BASE UINT32_C(0xe9860000) /**< STATUS_SEVERITY_ERROR + C-bit + facility 0x986. */
61# define SUP_NT_STATUS_IS_VBOX(a_rcNt) ( ((uint32_t)(a_rcNt) & 0xffff0000) == SUP_NT_STATUS_BASE )
62# define SUP_NT_STATUS_TO_VBOX(a_rcNt) ( (int)((uint32_t)(a_rcNt) | UINT32_C(0xffff0000)) )
63
64/** NT device name for system access. */
65# define SUPDRV_NT_DEVICE_NAME_SYS L"\\Device\\VBoxDrv"
66/** NT device name for user access. */
67# define SUPDRV_NT_DEVICE_NAME_USR L"\\Device\\VBoxDrvU"
68# ifdef VBOX_WITH_HARDENING
69/** NT device name for hardened stub access. */
70# define SUPDRV_NT_DEVICE_NAME_STUB L"\\Device\\VBoxDrvStub"
71/** NT device name for getting error information for failed VBoxDrv or
72 * VBoxDrvStub open. */
73# define SUPDRV_NT_DEVICE_NAME_ERROR_INFO L"\\Device\\VBoxDrvErrorInfo"
74# endif
75
76
77#elif defined(RT_OS_SOLARIS)
78 /* No automatic buffering, size limited to 255 bytes. */
79# include <sys/ioccom.h>
80# define SUP_CTL_CODE_SIZE(Function, Size) _IOWRN('V', (Function) | SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
81# define SUP_CTL_CODE_BIG(Function) _IOWRN('V', (Function) | SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
82# define SUP_CTL_CODE_FAST(Function) _IO( 'V', (Function) | SUP_IOCTL_FLAG)
83# define SUP_CTL_CODE_NO_SIZE(uIOCtl) ((uintptr_t)(uIOCtl))
84
85#elif defined(RT_OS_OS2)
86 /* No automatic buffering, size not encoded. */
87# define SUP_CTL_CATEGORY 0xc0
88# define SUP_CTL_CODE_SIZE(Function, Size) ((unsigned char)(Function))
89# define SUP_CTL_CODE_BIG(Function) ((unsigned char)(Function))
90# define SUP_CTL_CATEGORY_FAST 0xc1
91# define SUP_CTL_CODE_FAST(Function) ((unsigned char)(Function))
92# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
93
94#elif defined(RT_OS_LINUX)
95 /* No automatic buffering, size limited to 16KB. */
96# include <linux/ioctl.h>
97# define SUP_CTL_CODE_SIZE(Function, Size) _IOC(_IOC_READ | _IOC_WRITE, 'V', (Function) | SUP_IOCTL_FLAG, (Size))
98# define SUP_CTL_CODE_BIG(Function) _IO('V', (Function) | SUP_IOCTL_FLAG)
99# define SUP_CTL_CODE_FAST(Function) _IO('V', (Function) | SUP_IOCTL_FLAG)
100# define SUP_CTL_CODE_NO_SIZE(uIOCtl) ((uIOCtl) & ~IOCSIZE_MASK)
101
102#elif defined(RT_OS_L4)
103 /* Implemented in suplib, no worries. */
104# define SUP_CTL_CODE_SIZE(Function, Size) (Function)
105# define SUP_CTL_CODE_BIG(Function) (Function)
106# define SUP_CTL_CODE_FAST(Function) (Function)
107# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
108
109#else /* BSD Like */
110 /* Automatic buffering, size limited to 4KB on *BSD and 8KB on Darwin - commands the limit, 4KB. */
111# include <sys/ioccom.h>
112# define SUP_CTL_CODE_SIZE(Function, Size) _IOC(IOC_INOUT, 'V', (Function) | SUP_IOCTL_FLAG, (Size))
113# define SUP_CTL_CODE_BIG(Function) _IO('V', (Function) | SUP_IOCTL_FLAG)
114# define SUP_CTL_CODE_FAST(Function) _IO('V', (Function) | SUP_IOCTL_FLAG)
115# define SUP_CTL_CODE_NO_SIZE(uIOCtl) ( (uIOCtl) & ~_IOC(0,0,0,IOCPARM_MASK) )
116#endif
117
118/** @name Fast path I/O control codes.
119 * @note These must run parallel to SUP_VMMR0_DO_XXX
120 * @note Implementations ASSUMES up to 32 I/O controls codes in the fast range.
121 * @{ */
122/** Fast path IOCtl: VMMR0_DO_HM_RUN */
123#define SUP_IOCTL_FAST_DO_HM_RUN SUP_CTL_CODE_FAST(64)
124/** Fast path IOCtl: VMMR0_DO_NEM_RUN */
125#define SUP_IOCTL_FAST_DO_NEM_RUN SUP_CTL_CODE_FAST(65)
126/** Just a NOP call for profiling the latency of a fast ioctl call to VMMR0. */
127#define SUP_IOCTL_FAST_DO_NOP SUP_CTL_CODE_FAST(66)
128/** First fast path IOCtl number. */
129#define SUP_IOCTL_FAST_DO_FIRST SUP_IOCTL_FAST_DO_HM_RUN
130/** @} */
131
132
133#ifdef RT_OS_DARWIN
134/** Cookie used to fend off some unwanted clients to the IOService. */
135# define SUP_DARWIN_IOSERVICE_COOKIE 0x64726962 /* 'bird' */
136#endif
137
138
139/*******************************************************************************
140* Structures and Typedefs *
141*******************************************************************************/
142#ifdef RT_ARCH_AMD64
143# pragma pack(8) /* paranoia. */
144#elif defined(RT_ARCH_X86)
145# pragma pack(4) /* paranoia. */
146#endif
147
148
149/**
150 * Common In/Out header.
151 */
152typedef struct SUPREQHDR
153{
154 /** Cookie. */
155 uint32_t u32Cookie;
156 /** Session cookie. */
157 uint32_t u32SessionCookie;
158 /** The size of the input. */
159 uint32_t cbIn;
160 /** The size of the output. */
161 uint32_t cbOut;
162 /** Flags. See SUPREQHDR_FLAGS_* for details and values. */
163 uint32_t fFlags;
164 /** The VBox status code of the operation, out direction only. */
165 int32_t rc;
166} SUPREQHDR;
167/** Pointer to a IOC header. */
168typedef SUPREQHDR *PSUPREQHDR;
169
170/** @name SUPREQHDR::fFlags values
171 * @{ */
172/** Masks out the magic value. */
173#define SUPREQHDR_FLAGS_MAGIC_MASK UINT32_C(0xff0000ff)
174/** The generic mask. */
175#define SUPREQHDR_FLAGS_GEN_MASK UINT32_C(0x0000ff00)
176/** The request specific mask. */
177#define SUPREQHDR_FLAGS_REQ_MASK UINT32_C(0x00ff0000)
178
179/** There is extra input that needs copying on some platforms. */
180#define SUPREQHDR_FLAGS_EXTRA_IN UINT32_C(0x00000100)
181/** There is extra output that needs copying on some platforms. */
182#define SUPREQHDR_FLAGS_EXTRA_OUT UINT32_C(0x00000200)
183
184/** The magic value. */
185#define SUPREQHDR_FLAGS_MAGIC UINT32_C(0x42000042)
186/** The default value. Use this when no special stuff is requested. */
187#define SUPREQHDR_FLAGS_DEFAULT SUPREQHDR_FLAGS_MAGIC
188/** @} */
189
190
191/** @name SUP_IOCTL_COOKIE
192 * @{
193 */
194/** Negotiate cookie. */
195#define SUP_IOCTL_COOKIE SUP_CTL_CODE_SIZE(1, SUP_IOCTL_COOKIE_SIZE)
196/** The request size. */
197#define SUP_IOCTL_COOKIE_SIZE sizeof(SUPCOOKIE)
198/** The SUPREQHDR::cbIn value. */
199#define SUP_IOCTL_COOKIE_SIZE_IN sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.In)
200/** The SUPREQHDR::cbOut value. */
201#define SUP_IOCTL_COOKIE_SIZE_OUT sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.Out)
202/** SUPCOOKIE_IN magic word. */
203#define SUPCOOKIE_MAGIC "The Magic Word!"
204/** The initial cookie. */
205#define SUPCOOKIE_INITIAL_COOKIE 0x69726f74 /* 'tori' */
206
207/** Current interface version.
208 * The upper 16-bit is the major version, the lower the minor version.
209 * When incompatible changes are made, the upper major number has to be changed.
210 *
211 * Update rules:
212 * -# Only update the major number when incompatible changes have been made to
213 * the IOC interface or the ABI provided via the functions returned by
214 * SUPQUERYFUNCS.
215 * -# When adding new features (new IOC number, new flags, new exports, ++)
216 * only update the minor number and change SUPLib.cpp to require the
217 * new IOC version.
218 * -# When incrementing the major number, clear the minor part and reset
219 * any IOC version requirements in SUPLib.cpp.
220 * -# When increment the major number, execute all pending work.
221 *
222 * @todo Pending work on next major version change:
223 * - nothing
224 */
225#define SUPDRV_IOC_VERSION 0x00330002
226
227/** SUP_IOCTL_COOKIE. */
228typedef struct SUPCOOKIE
229{
230 /** The header.
231 * u32Cookie must be set to SUPCOOKIE_INITIAL_COOKIE.
232 * u32SessionCookie should be set to some random value. */
233 SUPREQHDR Hdr;
234 union
235 {
236 struct
237 {
238 /** Magic word. */
239 char szMagic[16];
240 /** The requested interface version number. */
241 uint32_t u32ReqVersion;
242 /** The minimum interface version number. */
243 uint32_t u32MinVersion;
244 } In;
245 struct
246 {
247 /** Cookie. */
248 uint32_t u32Cookie;
249 /** Session cookie. */
250 uint32_t u32SessionCookie;
251 /** Interface version for this session. */
252 uint32_t u32SessionVersion;
253 /** The actual interface version in the driver. */
254 uint32_t u32DriverVersion;
255 /** Number of functions available for the SUP_IOCTL_QUERY_FUNCS request. */
256 uint32_t cFunctions;
257 /** Session handle. */
258 R0PTRTYPE(PSUPDRVSESSION) pSession;
259 } Out;
260 } u;
261} SUPCOOKIE, *PSUPCOOKIE;
262/** @} */
263
264
265/** @name SUP_IOCTL_QUERY_FUNCS
266 * Query SUPR0 functions.
267 * @{
268 */
269#define SUP_IOCTL_QUERY_FUNCS(cFuncs) SUP_CTL_CODE_BIG(2)
270#define SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs) RT_UOFFSETOF_DYN(SUPQUERYFUNCS, u.Out.aFunctions[(cFuncs)])
271#define SUP_IOCTL_QUERY_FUNCS_SIZE_IN sizeof(SUPREQHDR)
272#define SUP_IOCTL_QUERY_FUNCS_SIZE_OUT(cFuncs) SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs)
273
274/** A function. */
275typedef struct SUPFUNC
276{
277 /** Name - mangled. */
278 char szName[47];
279 /** For internal checking. Ignore. */
280 uint8_t cArgs;
281 /** Address. */
282 RTR0PTR pfn;
283} SUPFUNC, *PSUPFUNC;
284
285typedef struct SUPQUERYFUNCS
286{
287 /** The header. */
288 SUPREQHDR Hdr;
289 union
290 {
291 struct
292 {
293 /** Number of functions returned. */
294 uint32_t cFunctions;
295 /** Array of functions. */
296 SUPFUNC aFunctions[1];
297 } Out;
298 } u;
299} SUPQUERYFUNCS, *PSUPQUERYFUNCS;
300/** @} */
301
302
303/** @name SUP_IOCTL_LDR_OPEN
304 * Open an image.
305 * @{
306 */
307#define SUP_IOCTL_LDR_OPEN SUP_CTL_CODE_SIZE(3, SUP_IOCTL_LDR_OPEN_SIZE)
308#define SUP_IOCTL_LDR_OPEN_SIZE sizeof(SUPLDROPEN)
309#define SUP_IOCTL_LDR_OPEN_SIZE_IN sizeof(SUPLDROPEN)
310#define SUP_IOCTL_LDR_OPEN_SIZE_OUT (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDROPEN, u.Out))
311typedef struct SUPLDROPEN
312{
313 /** The header. */
314 SUPREQHDR Hdr;
315 union
316 {
317 struct
318 {
319 /** Size of the image we'll be loading (including all tables).
320 * Zero if the caller does not wish to prepare loading anything, then
321 * cbImageBits must be zero too ofc. */
322 uint32_t cbImageWithEverything;
323 /** The size of the image bits. (Less or equal to cbImageWithTabs.)
324 * Zero if the caller does not wish to prepare loading anything. */
325 uint32_t cbImageBits;
326 /** Image name.
327 * This is the NAME of the image, not the file name. It is used
328 * to share code with other processes. (Max len is 32 chars!) */
329 char szName[32];
330 /** Image file name.
331 * This can be used to load the image using a native loader. */
332 char szFilename[260];
333 } In;
334 struct
335 {
336 /** The base address of the image. */
337 RTR0PTR pvImageBase;
338 /** Indicate whether or not the image requires loading. */
339 bool fNeedsLoading;
340 /** Indicates that we're using the native ring-0 loader. */
341 bool fNativeLoader;
342 } Out;
343 } u;
344} SUPLDROPEN, *PSUPLDROPEN;
345/** @} */
346
347
348/** @name SUP_IOCTL_LDR_LOAD
349 * Upload the image bits.
350 * @{
351 */
352#define SUP_IOCTL_LDR_LOAD SUP_CTL_CODE_BIG(4)
353#define SUP_IOCTL_LDR_LOAD_SIZE(cbImage) RT_MAX(RT_UOFFSETOF_DYN(SUPLDRLOAD, u.In.abImage[cbImage]), SUP_IOCTL_LDR_LOAD_SIZE_OUT)
354#define SUP_IOCTL_LDR_LOAD_SIZE_IN(cbImage) RT_UOFFSETOF_DYN(SUPLDRLOAD, u.In.abImage[cbImage])
355#define SUP_IOCTL_LDR_LOAD_SIZE_OUT (RT_UOFFSETOF(SUPLDRLOAD, u.Out.szError) + RT_SIZEOFMEMB(SUPLDRLOAD, u.Out.szError))
356
357/**
358 * Module initialization callback function.
359 * This is called once after the module has been loaded.
360 *
361 * @returns 0 on success.
362 * @returns Appropriate error code on failure.
363 * @param hMod Image handle for use in APIs.
364 */
365typedef DECLCALLBACKTYPE(int, FNR0MODULEINIT,(void *hMod));
366/** Pointer to a FNR0MODULEINIT(). */
367typedef R0PTRTYPE(FNR0MODULEINIT *) PFNR0MODULEINIT;
368
369/**
370 * Module termination callback function.
371 * This is called once right before the module is being unloaded.
372 *
373 * @param hMod Image handle for use in APIs.
374 */
375typedef DECLCALLBACKTYPE(void, FNR0MODULETERM,(void *hMod));
376/** Pointer to a FNR0MODULETERM(). */
377typedef R0PTRTYPE(FNR0MODULETERM *) PFNR0MODULETERM;
378
379/**
380 * Symbol table entry.
381 */
382typedef struct SUPLDRSYM
383{
384 /** Offset into of the string table. */
385 uint32_t offName;
386 /** Offset of the symbol relative to the image load address.
387 * @remarks When used inside the SUPDrv to calculate real addresses, it
388 * must be cast to int32_t for the sake of native loader support
389 * on Solaris. (The loader puts the and data in different
390 * memory areans, and the text one is generally higher.) */
391 uint32_t offSymbol;
392} SUPLDRSYM;
393/** Pointer to a symbol table entry. */
394typedef SUPLDRSYM *PSUPLDRSYM;
395/** Pointer to a const symbol table entry. */
396typedef SUPLDRSYM const *PCSUPLDRSYM;
397
398#define SUPLDR_PROT_READ 1 /**< Grant read access (RTMEM_PROT_READ). */
399#define SUPLDR_PROT_WRITE 2 /**< Grant write access (RTMEM_PROT_WRITE). */
400#define SUPLDR_PROT_EXEC 4 /**< Grant execute access (RTMEM_PROT_EXEC). */
401
402/**
403 * A segment table entry - chiefly for conveying memory protection.
404 */
405typedef struct SUPLDRSEG
406{
407 /** The RVA of the segment. */
408 uint32_t off;
409 /** The size of the segment. */
410 uint32_t cb : 28;
411 /** The segment protection (SUPLDR_PROT_XXX). */
412 uint32_t fProt : 3;
413 /** MBZ. */
414 uint32_t fUnused;
415} SUPLDRSEG;
416/** Pointer to a segment table entry. */
417typedef SUPLDRSEG *PSUPLDRSEG;
418/** Pointer to a const segment table entry. */
419typedef SUPLDRSEG const *PCSUPLDRSEG;
420
421/**
422 * SUPLDRLOAD::u::In::EP type.
423 */
424typedef enum SUPLDRLOADEP
425{
426 SUPLDRLOADEP_NOTHING = 0,
427 SUPLDRLOADEP_VMMR0,
428 SUPLDRLOADEP_SERVICE,
429 SUPLDRLOADEP_32BIT_HACK = 0x7fffffff
430} SUPLDRLOADEP;
431
432typedef struct SUPLDRLOAD
433{
434 /** The header. */
435 SUPREQHDR Hdr;
436 union
437 {
438 struct
439 {
440 /** The address of module initialization function. Similar to _DLL_InitTerm(hmod, 0). */
441 RTR0PTR pfnModuleInit;
442 /** The address of module termination function. Similar to _DLL_InitTerm(hmod, 1). */
443 RTR0PTR pfnModuleTerm;
444 /** Special entry points. */
445 union
446 {
447 /** SUPLDRLOADEP_VMMR0. */
448 struct
449 {
450 /** Address of VMMR0EntryFast function. */
451 RTR0PTR pvVMMR0EntryFast;
452 /** Address of VMMR0EntryEx function. */
453 RTR0PTR pvVMMR0EntryEx;
454 } VMMR0;
455 /** SUPLDRLOADEP_SERVICE. */
456 struct
457 {
458 /** The service request handler.
459 * (PFNR0SERVICEREQHANDLER isn't defined yet.) */
460 RTR0PTR pfnServiceReq;
461 /** Reserved, must be NIL. */
462 RTR0PTR apvReserved[3];
463 } Service;
464 } EP;
465 /** Address. */
466 RTR0PTR pvImageBase;
467 /** Entry point type. */
468 SUPLDRLOADEP eEPType;
469 /** The size of the image bits (starting at offset 0 and
470 * approaching offSymbols). */
471 uint32_t cbImageBits;
472 /** The offset of the symbol table (SUPLDRSYM array). */
473 uint32_t offSymbols;
474 /** The number of entries in the symbol table. */
475 uint32_t cSymbols;
476 /** The offset of the string table. */
477 uint32_t offStrTab;
478 /** Size of the string table. */
479 uint32_t cbStrTab;
480 /** Offset to the segment table (SUPLDRSEG array). */
481 uint32_t offSegments;
482 /** Number of segments. */
483 uint32_t cSegments;
484 /** Size of image data in achImage. */
485 uint32_t cbImageWithEverything;
486 /** Flags (SUPLDRLOAD_F_XXX). */
487 uint32_t fFlags;
488 /** The image data. */
489 uint8_t abImage[1];
490 } In;
491 struct
492 {
493 /** Magic value indicating whether extended error information is
494 * present or not (SUPLDRLOAD_ERROR_MAGIC). */
495 uint64_t uErrorMagic;
496 /** Extended error information. */
497 char szError[2048];
498 } Out;
499 } u;
500} SUPLDRLOAD, *PSUPLDRLOAD;
501/** Magic value that indicates that there is a valid error information string
502 * present on SUP_IOCTL_LDR_LOAD failure.
503 * @remarks The value is choosen to be an unlikely init and term address. */
504#define SUPLDRLOAD_ERROR_MAGIC UINT64_C(0xabcdefef0feddcb9)
505/** The module depends on VMMR0. */
506#define SUPLDRLOAD_F_DEP_VMMR0 RT_BIT_32(0)
507/** Valid flag mask. */
508#define SUPLDRLOAD_F_VALID_MASK UINT32_C(0x00000001)
509/** @} */
510
511
512/** @name SUP_IOCTL_LDR_FREE
513 * Free an image.
514 * @{
515 */
516#define SUP_IOCTL_LDR_FREE SUP_CTL_CODE_SIZE(5, SUP_IOCTL_LDR_FREE_SIZE)
517#define SUP_IOCTL_LDR_FREE_SIZE sizeof(SUPLDRFREE)
518#define SUP_IOCTL_LDR_FREE_SIZE_IN sizeof(SUPLDRFREE)
519#define SUP_IOCTL_LDR_FREE_SIZE_OUT sizeof(SUPREQHDR)
520typedef struct SUPLDRFREE
521{
522 /** The header. */
523 SUPREQHDR Hdr;
524 union
525 {
526 struct
527 {
528 /** Address. */
529 RTR0PTR pvImageBase;
530 } In;
531 } u;
532} SUPLDRFREE, *PSUPLDRFREE;
533/** @} */
534
535
536/** @name SUP_IOCTL_LDR_LOCK_DOWN
537 * Lock down the image loader interface.
538 * @{
539 */
540#define SUP_IOCTL_LDR_LOCK_DOWN SUP_CTL_CODE_SIZE(38, SUP_IOCTL_LDR_LOCK_DOWN_SIZE)
541#define SUP_IOCTL_LDR_LOCK_DOWN_SIZE sizeof(SUPREQHDR)
542#define SUP_IOCTL_LDR_LOCK_DOWN_SIZE_IN sizeof(SUPREQHDR)
543#define SUP_IOCTL_LDR_LOCK_DOWN_SIZE_OUT sizeof(SUPREQHDR)
544/** @} */
545
546
547/** @name SUP_IOCTL_LDR_GET_SYMBOL
548 * Get address of a symbol within an image.
549 * @{
550 */
551#define SUP_IOCTL_LDR_GET_SYMBOL SUP_CTL_CODE_SIZE(6, SUP_IOCTL_LDR_GET_SYMBOL_SIZE)
552#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE sizeof(SUPLDRGETSYMBOL)
553#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_IN sizeof(SUPLDRGETSYMBOL)
554#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_OUT (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDRGETSYMBOL, u.Out))
555typedef struct SUPLDRGETSYMBOL
556{
557 /** The header. */
558 SUPREQHDR Hdr;
559 union
560 {
561 struct
562 {
563 /** Address. */
564 RTR0PTR pvImageBase;
565 /** The symbol name. */
566 char szSymbol[64];
567 } In;
568 struct
569 {
570 /** The symbol address. */
571 RTR0PTR pvSymbol;
572 } Out;
573 } u;
574} SUPLDRGETSYMBOL, *PSUPLDRGETSYMBOL;
575/** @} */
576
577
578/** @name SUP_IOCTL_CALL_VMMR0
579 * Call the R0 VMM Entry point.
580 * @{
581 */
582#define SUP_IOCTL_CALL_VMMR0(cbReq) SUP_CTL_CODE_SIZE(7, SUP_IOCTL_CALL_VMMR0_SIZE(cbReq))
583#define SUP_IOCTL_CALL_VMMR0_NO_SIZE() SUP_CTL_CODE_SIZE(7, 0)
584#define SUP_IOCTL_CALL_VMMR0_SIZE(cbReq) RT_UOFFSETOF_DYN(SUPCALLVMMR0, abReqPkt[cbReq])
585#define SUP_IOCTL_CALL_VMMR0_SIZE_IN(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
586#define SUP_IOCTL_CALL_VMMR0_SIZE_OUT(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
587typedef struct SUPCALLVMMR0
588{
589 /** The header. */
590 SUPREQHDR Hdr;
591 union
592 {
593 struct
594 {
595 /** The VM handle. */
596 PVMR0 pVMR0;
597 /** VCPU id. */
598 uint32_t idCpu;
599 /** Which operation to execute. */
600 uint32_t uOperation;
601 /** Argument to use when no request packet is supplied. */
602 uint64_t u64Arg;
603 } In;
604 } u;
605 /** The VMMR0Entry request packet. */
606 uint8_t abReqPkt[1];
607} SUPCALLVMMR0, *PSUPCALLVMMR0;
608/** @} */
609
610
611/** @name SUP_IOCTL_CALL_VMMR0_BIG
612 * Version of SUP_IOCTL_CALL_VMMR0 for dealing with large requests.
613 * @{
614 */
615#define SUP_IOCTL_CALL_VMMR0_BIG SUP_CTL_CODE_BIG(27)
616#define SUP_IOCTL_CALL_VMMR0_BIG_SIZE(cbReq) RT_UOFFSETOF_DYN(SUPCALLVMMR0, abReqPkt[cbReq])
617#define SUP_IOCTL_CALL_VMMR0_BIG_SIZE_IN(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
618#define SUP_IOCTL_CALL_VMMR0_BIG_SIZE_OUT(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
619/** @} */
620
621
622/** @name SUP_IOCTL_LOW_ALLOC
623 * Allocate memory below 4GB (physically).
624 * @{
625 */
626#define SUP_IOCTL_LOW_ALLOC SUP_CTL_CODE_BIG(8)
627#define SUP_IOCTL_LOW_ALLOC_SIZE(cPages) ((uint32_t)RT_UOFFSETOF_DYN(SUPLOWALLOC, u.Out.aPages[cPages]))
628#define SUP_IOCTL_LOW_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLOWALLOC, u.In))
629#define SUP_IOCTL_LOW_ALLOC_SIZE_OUT(cPages) SUP_IOCTL_LOW_ALLOC_SIZE(cPages)
630typedef struct SUPLOWALLOC
631{
632 /** The header. */
633 SUPREQHDR Hdr;
634 union
635 {
636 struct
637 {
638 /** Number of pages to allocate. */
639 uint32_t cPages;
640 } In;
641 struct
642 {
643 /** The ring-3 address of the allocated memory. */
644 RTR3PTR pvR3;
645 /** The ring-0 address of the allocated memory. */
646 RTR0PTR pvR0;
647 /** Array of pages. */
648 RTHCPHYS aPages[1];
649 } Out;
650 } u;
651} SUPLOWALLOC, *PSUPLOWALLOC;
652/** @} */
653
654
655/** @name SUP_IOCTL_LOW_FREE
656 * Free low memory.
657 * @{
658 */
659#define SUP_IOCTL_LOW_FREE SUP_CTL_CODE_SIZE(9, SUP_IOCTL_LOW_FREE_SIZE)
660#define SUP_IOCTL_LOW_FREE_SIZE sizeof(SUPLOWFREE)
661#define SUP_IOCTL_LOW_FREE_SIZE_IN sizeof(SUPLOWFREE)
662#define SUP_IOCTL_LOW_FREE_SIZE_OUT sizeof(SUPREQHDR)
663typedef struct SUPLOWFREE
664{
665 /** The header. */
666 SUPREQHDR Hdr;
667 union
668 {
669 struct
670 {
671 /** The ring-3 address of the memory to free. */
672 RTR3PTR pvR3;
673 } In;
674 } u;
675} SUPLOWFREE, *PSUPLOWFREE;
676/** @} */
677
678
679/** @name SUP_IOCTL_PAGE_ALLOC_EX
680 * Allocate memory and map it into kernel and/or user space. The memory is of
681 * course locked. The result should be freed using SUP_IOCTL_PAGE_FREE.
682 *
683 * @remarks Allocations without a kernel mapping may fail with
684 * VERR_NOT_SUPPORTED on some platforms.
685 *
686 * @{
687 */
688#define SUP_IOCTL_PAGE_ALLOC_EX SUP_CTL_CODE_BIG(10)
689#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages) RT_UOFFSETOF_DYN(SUPPAGEALLOCEX, u.Out.aPages[cPages])
690#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGEALLOCEX, u.In))
691#define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_OUT(cPages) SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages)
692typedef struct SUPPAGEALLOCEX
693{
694 /** The header. */
695 SUPREQHDR Hdr;
696 union
697 {
698 struct
699 {
700 /** Number of pages to allocate */
701 uint32_t cPages;
702 /** Whether it should have kernel mapping. */
703 bool fKernelMapping;
704 /** Whether it should have a user mapping. */
705 bool fUserMapping;
706 /** Reserved. Must be false. */
707 bool fReserved0;
708 /** Reserved. Must be false. */
709 bool fReserved1;
710 } In;
711 struct
712 {
713 /** Returned ring-3 address. */
714 RTR3PTR pvR3;
715 /** Returned ring-0 address. */
716 RTR0PTR pvR0;
717 /** The physical addresses of the allocated pages. */
718 RTHCPHYS aPages[1];
719 } Out;
720 } u;
721} SUPPAGEALLOCEX, *PSUPPAGEALLOCEX;
722/** @} */
723
724
725/** @name SUP_IOCTL_PAGE_MAP_KERNEL
726 * Maps a portion of memory allocated by SUP_IOCTL_PAGE_ALLOC_EX /
727 * SUPR0PageAllocEx into kernel space for use by a device or similar.
728 *
729 * The mapping will be freed together with the ring-3 mapping when
730 * SUP_IOCTL_PAGE_FREE or SUPR0PageFree is called.
731 *
732 * @remarks Not necessarily supported on all platforms.
733 *
734 * @{
735 */
736#define SUP_IOCTL_PAGE_MAP_KERNEL SUP_CTL_CODE_SIZE(11, SUP_IOCTL_PAGE_MAP_KERNEL_SIZE)
737#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE sizeof(SUPPAGEMAPKERNEL)
738#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_IN sizeof(SUPPAGEMAPKERNEL)
739#define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_OUT sizeof(SUPPAGEMAPKERNEL)
740typedef struct SUPPAGEMAPKERNEL
741{
742 /** The header. */
743 SUPREQHDR Hdr;
744 union
745 {
746 struct
747 {
748 /** The pointer of to the previously allocated memory. */
749 RTR3PTR pvR3;
750 /** The offset to start mapping from. */
751 uint32_t offSub;
752 /** Size of the section to map. */
753 uint32_t cbSub;
754 /** Flags reserved for future fun. */
755 uint32_t fFlags;
756 } In;
757 struct
758 {
759 /** The ring-0 address corresponding to pvR3 + offSub. */
760 RTR0PTR pvR0;
761 } Out;
762 } u;
763} SUPPAGEMAPKERNEL, *PSUPPAGEMAPKERNEL;
764/** @} */
765
766
767/** @name SUP_IOCTL_PAGE_PROTECT
768 * Changes the page level protection of the user and/or kernel mappings of
769 * memory previously allocated by SUPR0PageAllocEx.
770 *
771 * @remarks Not necessarily supported on all platforms.
772 *
773 * @{
774 */
775#define SUP_IOCTL_PAGE_PROTECT SUP_CTL_CODE_SIZE(12, SUP_IOCTL_PAGE_PROTECT_SIZE)
776#define SUP_IOCTL_PAGE_PROTECT_SIZE sizeof(SUPPAGEPROTECT)
777#define SUP_IOCTL_PAGE_PROTECT_SIZE_IN sizeof(SUPPAGEPROTECT)
778#define SUP_IOCTL_PAGE_PROTECT_SIZE_OUT sizeof(SUPPAGEPROTECT)
779typedef struct SUPPAGEPROTECT
780{
781 /** The header. */
782 SUPREQHDR Hdr;
783 union
784 {
785 struct
786 {
787 /** The pointer of to the previously allocated memory.
788 * Pass NIL_RTR3PTR if the ring-0 mapping should remain unaffected. */
789 RTR3PTR pvR3;
790 /** The pointer of to the previously allocated memory.
791 * Pass NIL_RTR0PTR if the ring-0 mapping should remain unaffected. */
792 RTR0PTR pvR0;
793 /** The offset to start changing protection at. */
794 uint32_t offSub;
795 /** Size of the portion that should be changed. */
796 uint32_t cbSub;
797 /** Protection flags, RTMEM_PROT_*. */
798 uint32_t fProt;
799 } In;
800 } u;
801} SUPPAGEPROTECT, *PSUPPAGEPROTECT;
802/** @} */
803
804
805/** @name SUP_IOCTL_PAGE_FREE
806 * Free memory allocated with SUP_IOCTL_PAGE_ALLOC_EX.
807 * @{
808 */
809#define SUP_IOCTL_PAGE_FREE SUP_CTL_CODE_SIZE(13, SUP_IOCTL_PAGE_FREE_SIZE_IN)
810#define SUP_IOCTL_PAGE_FREE_SIZE sizeof(SUPPAGEFREE)
811#define SUP_IOCTL_PAGE_FREE_SIZE_IN sizeof(SUPPAGEFREE)
812#define SUP_IOCTL_PAGE_FREE_SIZE_OUT sizeof(SUPREQHDR)
813typedef struct SUPPAGEFREE
814{
815 /** The header. */
816 SUPREQHDR Hdr;
817 union
818 {
819 struct
820 {
821 /** Address of memory range to free. */
822 RTR3PTR pvR3;
823 } In;
824 } u;
825} SUPPAGEFREE, *PSUPPAGEFREE;
826/** @} */
827
828
829
830
831/** @name SUP_IOCTL_PAGE_LOCK
832 * Pin down physical pages.
833 * @{
834 */
835#define SUP_IOCTL_PAGE_LOCK SUP_CTL_CODE_BIG(14)
836#define SUP_IOCTL_PAGE_LOCK_SIZE(cPages) (RT_MAX((size_t)SUP_IOCTL_PAGE_LOCK_SIZE_IN, (size_t)SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages)))
837#define SUP_IOCTL_PAGE_LOCK_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGELOCK, u.In))
838#define SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages) RT_UOFFSETOF_DYN(SUPPAGELOCK, u.Out.aPages[cPages])
839typedef struct SUPPAGELOCK
840{
841 /** The header. */
842 SUPREQHDR Hdr;
843 union
844 {
845 struct
846 {
847 /** Start of page range. Must be PAGE aligned. */
848 RTR3PTR pvR3;
849 /** The range size given as a page count. */
850 uint32_t cPages;
851 } In;
852
853 struct
854 {
855 /** Array of pages. */
856 RTHCPHYS aPages[1];
857 } Out;
858 } u;
859} SUPPAGELOCK, *PSUPPAGELOCK;
860/** @} */
861
862
863/** @name SUP_IOCTL_PAGE_UNLOCK
864 * Unpin physical pages.
865 * @{ */
866#define SUP_IOCTL_PAGE_UNLOCK SUP_CTL_CODE_SIZE(15, SUP_IOCTL_PAGE_UNLOCK_SIZE)
867#define SUP_IOCTL_PAGE_UNLOCK_SIZE sizeof(SUPPAGEUNLOCK)
868#define SUP_IOCTL_PAGE_UNLOCK_SIZE_IN sizeof(SUPPAGEUNLOCK)
869#define SUP_IOCTL_PAGE_UNLOCK_SIZE_OUT sizeof(SUPREQHDR)
870typedef struct SUPPAGEUNLOCK
871{
872 /** The header. */
873 SUPREQHDR Hdr;
874 union
875 {
876 struct
877 {
878 /** Start of page range of a range previously pinned. */
879 RTR3PTR pvR3;
880 } In;
881 } u;
882} SUPPAGEUNLOCK, *PSUPPAGEUNLOCK;
883/** @} */
884
885
886/** @name SUP_IOCTL_CONT_ALLOC
887 * Allocate continuous memory.
888 * @{
889 */
890#define SUP_IOCTL_CONT_ALLOC SUP_CTL_CODE_SIZE(16, SUP_IOCTL_CONT_ALLOC_SIZE)
891#define SUP_IOCTL_CONT_ALLOC_SIZE sizeof(SUPCONTALLOC)
892#define SUP_IOCTL_CONT_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCONTALLOC, u.In))
893#define SUP_IOCTL_CONT_ALLOC_SIZE_OUT sizeof(SUPCONTALLOC)
894typedef struct SUPCONTALLOC
895{
896 /** The header. */
897 SUPREQHDR Hdr;
898 union
899 {
900 struct
901 {
902 /** The allocation size given as a page count. */
903 uint32_t cPages;
904 } In;
905
906 struct
907 {
908 /** The address of the ring-0 mapping of the allocated memory. */
909 RTR0PTR pvR0;
910 /** The address of the ring-3 mapping of the allocated memory. */
911 RTR3PTR pvR3;
912 /** The physical address of the allocation. */
913 RTHCPHYS HCPhys;
914 } Out;
915 } u;
916} SUPCONTALLOC, *PSUPCONTALLOC;
917/** @} */
918
919
920/** @name SUP_IOCTL_CONT_FREE Input.
921 * @{
922 */
923/** Free continuous memory. */
924#define SUP_IOCTL_CONT_FREE SUP_CTL_CODE_SIZE(17, SUP_IOCTL_CONT_FREE_SIZE)
925#define SUP_IOCTL_CONT_FREE_SIZE sizeof(SUPCONTFREE)
926#define SUP_IOCTL_CONT_FREE_SIZE_IN sizeof(SUPCONTFREE)
927#define SUP_IOCTL_CONT_FREE_SIZE_OUT sizeof(SUPREQHDR)
928typedef struct SUPCONTFREE
929{
930 /** The header. */
931 SUPREQHDR Hdr;
932 union
933 {
934 struct
935 {
936 /** The ring-3 address of the memory to free. */
937 RTR3PTR pvR3;
938 } In;
939 } u;
940} SUPCONTFREE, *PSUPCONTFREE;
941/** @} */
942
943
944/** @name SUP_IOCTL_GET_PAGING_MODE
945 * Get the host paging mode.
946 * @{
947 */
948#define SUP_IOCTL_GET_PAGING_MODE SUP_CTL_CODE_SIZE(18, SUP_IOCTL_GET_PAGING_MODE_SIZE)
949#define SUP_IOCTL_GET_PAGING_MODE_SIZE sizeof(SUPGETPAGINGMODE)
950#define SUP_IOCTL_GET_PAGING_MODE_SIZE_IN sizeof(SUPREQHDR)
951#define SUP_IOCTL_GET_PAGING_MODE_SIZE_OUT sizeof(SUPGETPAGINGMODE)
952typedef struct SUPGETPAGINGMODE
953{
954 /** The header. */
955 SUPREQHDR Hdr;
956 union
957 {
958 struct
959 {
960 /** The paging mode. */
961 SUPPAGINGMODE enmMode;
962 } Out;
963 } u;
964} SUPGETPAGINGMODE, *PSUPGETPAGINGMODE;
965/** @} */
966
967
968/** @name SUP_IOCTL_SET_VM_FOR_FAST
969 * Set the VM handle for doing fast call ioctl calls.
970 * @{
971 */
972#define SUP_IOCTL_SET_VM_FOR_FAST SUP_CTL_CODE_SIZE(19, SUP_IOCTL_SET_VM_FOR_FAST_SIZE)
973#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE sizeof(SUPSETVMFORFAST)
974#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_IN sizeof(SUPSETVMFORFAST)
975#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_OUT sizeof(SUPREQHDR)
976typedef struct SUPSETVMFORFAST
977{
978 /** The header. */
979 SUPREQHDR Hdr;
980 union
981 {
982 struct
983 {
984 /** The ring-0 VM handle (pointer). */
985 PVMR0 pVMR0;
986 } In;
987 } u;
988} SUPSETVMFORFAST, *PSUPSETVMFORFAST;
989/** @} */
990
991
992/** @name SUP_IOCTL_GIP_MAP
993 * Map the GIP into user space.
994 * @{
995 */
996#define SUP_IOCTL_GIP_MAP SUP_CTL_CODE_SIZE(20, SUP_IOCTL_GIP_MAP_SIZE)
997#define SUP_IOCTL_GIP_MAP_SIZE sizeof(SUPGIPMAP)
998#define SUP_IOCTL_GIP_MAP_SIZE_IN sizeof(SUPREQHDR)
999#define SUP_IOCTL_GIP_MAP_SIZE_OUT sizeof(SUPGIPMAP)
1000typedef struct SUPGIPMAP
1001{
1002 /** The header. */
1003 SUPREQHDR Hdr;
1004 union
1005 {
1006 struct
1007 {
1008 /** The physical address of the GIP. */
1009 RTHCPHYS HCPhysGip;
1010 /** Pointer to the read-only usermode GIP mapping for this session. */
1011 R3PTRTYPE(PSUPGLOBALINFOPAGE) pGipR3;
1012 /** Pointer to the supervisor mode GIP mapping. */
1013 R0PTRTYPE(PSUPGLOBALINFOPAGE) pGipR0;
1014 } Out;
1015 } u;
1016} SUPGIPMAP, *PSUPGIPMAP;
1017/** @} */
1018
1019
1020/** @name SUP_IOCTL_GIP_UNMAP
1021 * Unmap the GIP.
1022 * @{
1023 */
1024#define SUP_IOCTL_GIP_UNMAP SUP_CTL_CODE_SIZE(21, SUP_IOCTL_GIP_UNMAP_SIZE)
1025#define SUP_IOCTL_GIP_UNMAP_SIZE sizeof(SUPGIPUNMAP)
1026#define SUP_IOCTL_GIP_UNMAP_SIZE_IN sizeof(SUPGIPUNMAP)
1027#define SUP_IOCTL_GIP_UNMAP_SIZE_OUT sizeof(SUPGIPUNMAP)
1028typedef struct SUPGIPUNMAP
1029{
1030 /** The header. */
1031 SUPREQHDR Hdr;
1032} SUPGIPUNMAP, *PSUPGIPUNMAP;
1033/** @} */
1034
1035
1036/** @name SUP_IOCTL_CALL_SERVICE
1037 * Call the a ring-0 service.
1038 *
1039 * @todo Might have to convert this to a big request, just like
1040 * SUP_IOCTL_CALL_VMMR0
1041 * @{
1042 */
1043#define SUP_IOCTL_CALL_SERVICE(cbReq) SUP_CTL_CODE_SIZE(22, SUP_IOCTL_CALL_SERVICE_SIZE(cbReq))
1044#define SUP_IOCTL_CALL_SERVICE_NO_SIZE() SUP_CTL_CODE_SIZE(22, 0)
1045#define SUP_IOCTL_CALL_SERVICE_SIZE(cbReq) RT_UOFFSETOF_DYN(SUPCALLSERVICE, abReqPkt[cbReq])
1046#define SUP_IOCTL_CALL_SERVICE_SIZE_IN(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
1047#define SUP_IOCTL_CALL_SERVICE_SIZE_OUT(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
1048typedef struct SUPCALLSERVICE
1049{
1050 /** The header. */
1051 SUPREQHDR Hdr;
1052 union
1053 {
1054 struct
1055 {
1056 /** The service name. */
1057 char szName[28];
1058 /** Which operation to execute. */
1059 uint32_t uOperation;
1060 /** Argument to use when no request packet is supplied. */
1061 uint64_t u64Arg;
1062 } In;
1063 } u;
1064 /** The request packet passed to SUP. */
1065 uint8_t abReqPkt[1];
1066} SUPCALLSERVICE, *PSUPCALLSERVICE;
1067/** @} */
1068
1069
1070/** @name SUP_IOCTL_LOGGER_SETTINGS
1071 * Changes the ring-0 release or debug logger settings.
1072 * @{
1073 */
1074#define SUP_IOCTL_LOGGER_SETTINGS(cbStrTab) SUP_CTL_CODE_SIZE(23, SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab))
1075#define SUP_IOCTL_LOGGER_SETTINGS_NO_SIZE() SUP_CTL_CODE_SIZE(23, 0)
1076#define SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab) RT_UOFFSETOF_DYN(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
1077#define SUP_IOCTL_LOGGER_SETTINGS_SIZE_IN(cbStrTab) RT_UOFFSETOF_DYN(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
1078#define SUP_IOCTL_LOGGER_SETTINGS_SIZE_OUT sizeof(SUPREQHDR)
1079typedef struct SUPLOGGERSETTINGS
1080{
1081 /** The header. */
1082 SUPREQHDR Hdr;
1083 union
1084 {
1085 struct
1086 {
1087 /** Which logger. */
1088 uint32_t fWhich;
1089 /** What to do with it. */
1090 uint32_t fWhat;
1091 /** Offset of the flags setting string. */
1092 uint32_t offFlags;
1093 /** Offset of the groups setting string. */
1094 uint32_t offGroups;
1095 /** Offset of the destination setting string. */
1096 uint32_t offDestination;
1097 /** The string table. */
1098 char szStrings[1];
1099 } In;
1100 } u;
1101} SUPLOGGERSETTINGS, *PSUPLOGGERSETTINGS;
1102
1103/** Debug logger. */
1104#define SUPLOGGERSETTINGS_WHICH_DEBUG 0
1105/** Release logger. */
1106#define SUPLOGGERSETTINGS_WHICH_RELEASE 1
1107
1108/** Change the settings. */
1109#define SUPLOGGERSETTINGS_WHAT_SETTINGS 0
1110/** Create the logger instance. */
1111#define SUPLOGGERSETTINGS_WHAT_CREATE 1
1112/** Destroy the logger instance. */
1113#define SUPLOGGERSETTINGS_WHAT_DESTROY 2
1114
1115/** @} */
1116
1117
1118/** @name Semaphore Types
1119 * @{ */
1120#define SUP_SEM_TYPE_EVENT 0
1121#define SUP_SEM_TYPE_EVENT_MULTI 1
1122/** @} */
1123
1124
1125/** @name SUP_IOCTL_SEM_OP2
1126 * Semaphore operations.
1127 * @remarks This replaces the old SUP_IOCTL_SEM_OP interface.
1128 * @{
1129 */
1130#define SUP_IOCTL_SEM_OP2 SUP_CTL_CODE_SIZE(24, SUP_IOCTL_SEM_OP2_SIZE)
1131#define SUP_IOCTL_SEM_OP2_SIZE sizeof(SUPSEMOP2)
1132#define SUP_IOCTL_SEM_OP2_SIZE_IN sizeof(SUPSEMOP2)
1133#define SUP_IOCTL_SEM_OP2_SIZE_OUT sizeof(SUPREQHDR)
1134typedef struct SUPSEMOP2
1135{
1136 /** The header. */
1137 SUPREQHDR Hdr;
1138 union
1139 {
1140 struct
1141 {
1142 /** The semaphore type. */
1143 uint32_t uType;
1144 /** The semaphore handle. */
1145 uint32_t hSem;
1146 /** The operation. */
1147 uint32_t uOp;
1148 /** Reserved, must be zero. */
1149 uint32_t uReserved;
1150 /** The number of milliseconds to wait if it's a wait operation. */
1151 union
1152 {
1153 /** Absolute timeout (RTTime[System]NanoTS).
1154 * Used by SUPSEMOP2_WAIT_NS_ABS. */
1155 uint64_t uAbsNsTimeout;
1156 /** Relative nanosecond timeout.
1157 * Used by SUPSEMOP2_WAIT_NS_REL. */
1158 uint64_t cRelNsTimeout;
1159 /** Relative millisecond timeout.
1160 * Used by SUPSEMOP2_WAIT_MS_REL. */
1161 uint32_t cRelMsTimeout;
1162 /** Generic 64-bit accessor.
1163 * ASSUMES little endian! */
1164 uint64_t u64;
1165 } uArg;
1166 } In;
1167 } u;
1168} SUPSEMOP2, *PSUPSEMOP2;
1169
1170/** Wait for a number of milliseconds. */
1171#define SUPSEMOP2_WAIT_MS_REL 0
1172/** Wait until the specified deadline is reached. */
1173#define SUPSEMOP2_WAIT_NS_ABS 1
1174/** Wait for a number of nanoseconds. */
1175#define SUPSEMOP2_WAIT_NS_REL 2
1176/** Signal the semaphore. */
1177#define SUPSEMOP2_SIGNAL 3
1178/** Reset the semaphore (only applicable to SUP_SEM_TYPE_EVENT_MULTI). */
1179#define SUPSEMOP2_RESET 4
1180/** Close the semaphore handle. */
1181#define SUPSEMOP2_CLOSE 5
1182/** @} */
1183
1184
1185/** @name SUP_IOCTL_SEM_OP3
1186 * Semaphore operations.
1187 * @{
1188 */
1189#define SUP_IOCTL_SEM_OP3 SUP_CTL_CODE_SIZE(25, SUP_IOCTL_SEM_OP3_SIZE)
1190#define SUP_IOCTL_SEM_OP3_SIZE sizeof(SUPSEMOP3)
1191#define SUP_IOCTL_SEM_OP3_SIZE_IN sizeof(SUPSEMOP3)
1192#define SUP_IOCTL_SEM_OP3_SIZE_OUT sizeof(SUPSEMOP3)
1193typedef struct SUPSEMOP3
1194{
1195 /** The header. */
1196 SUPREQHDR Hdr;
1197 union
1198 {
1199 struct
1200 {
1201 /** The semaphore type. */
1202 uint32_t uType;
1203 /** The semaphore handle. */
1204 uint32_t hSem;
1205 /** The operation. */
1206 uint32_t uOp;
1207 /** Reserved, must be zero. */
1208 uint32_t u32Reserved;
1209 /** Reserved for future use. */
1210 uint64_t u64Reserved;
1211 } In;
1212 union
1213 {
1214 /** The handle of the created semaphore.
1215 * Used by SUPSEMOP3_CREATE. */
1216 uint32_t hSem;
1217 /** The semaphore resolution in nano seconds.
1218 * Used by SUPSEMOP3_GET_RESOLUTION. */
1219 uint32_t cNsResolution;
1220 /** The 32-bit view. */
1221 uint32_t u32;
1222 /** Reserved some space for later expansion. */
1223 uint64_t u64Reserved;
1224 } Out;
1225 } u;
1226} SUPSEMOP3, *PSUPSEMOP3;
1227
1228/** Get the wait resolution. */
1229#define SUPSEMOP3_CREATE 0
1230/** Get the wait resolution. */
1231#define SUPSEMOP3_GET_RESOLUTION 1
1232/** @} */
1233
1234
1235/** @name SUP_IOCTL_VT_CAPS
1236 * Get the VT-x/AMD-V capabilities.
1237 *
1238 * @todo Intended for main, which means we need to relax the privilege requires
1239 * when accessing certain vboxdrv functions.
1240 *
1241 * @{
1242 */
1243#define SUP_IOCTL_VT_CAPS SUP_CTL_CODE_SIZE(26, SUP_IOCTL_VT_CAPS_SIZE)
1244#define SUP_IOCTL_VT_CAPS_SIZE sizeof(SUPVTCAPS)
1245#define SUP_IOCTL_VT_CAPS_SIZE_IN sizeof(SUPREQHDR)
1246#define SUP_IOCTL_VT_CAPS_SIZE_OUT sizeof(SUPVTCAPS)
1247typedef struct SUPVTCAPS
1248{
1249 /** The header. */
1250 SUPREQHDR Hdr;
1251 union
1252 {
1253 struct
1254 {
1255 /** The VT capability dword. */
1256 uint32_t fCaps;
1257 } Out;
1258 } u;
1259} SUPVTCAPS, *PSUPVTCAPS;
1260/** @} */
1261
1262
1263/** @name SUP_IOCTL_TRACER_OPEN
1264 * Open the tracer.
1265 *
1266 * Should be matched by an SUP_IOCTL_TRACER_CLOSE call.
1267 *
1268 * @{
1269 */
1270#define SUP_IOCTL_TRACER_OPEN SUP_CTL_CODE_SIZE(28, SUP_IOCTL_TRACER_OPEN_SIZE)
1271#define SUP_IOCTL_TRACER_OPEN_SIZE sizeof(SUPTRACEROPEN)
1272#define SUP_IOCTL_TRACER_OPEN_SIZE_IN sizeof(SUPTRACEROPEN)
1273#define SUP_IOCTL_TRACER_OPEN_SIZE_OUT sizeof(SUPREQHDR)
1274typedef struct SUPTRACEROPEN
1275{
1276 /** The header. */
1277 SUPREQHDR Hdr;
1278 union
1279 {
1280 struct
1281 {
1282 /** Tracer cookie. Used to make sure we only open a matching tracer. */
1283 uint32_t uCookie;
1284 /** Tracer specific argument. */
1285 RTHCUINTPTR uArg;
1286 } In;
1287 } u;
1288} SUPTRACEROPEN, *PSUPTRACEROPEN;
1289/** @} */
1290
1291
1292/** @name SUP_IOCTL_TRACER_CLOSE
1293 * Close the tracer.
1294 *
1295 * Must match a SUP_IOCTL_TRACER_OPEN call.
1296 *
1297 * @{
1298 */
1299#define SUP_IOCTL_TRACER_CLOSE SUP_CTL_CODE_SIZE(29, SUP_IOCTL_TRACER_CLOSE_SIZE)
1300#define SUP_IOCTL_TRACER_CLOSE_SIZE sizeof(SUPREQHDR)
1301#define SUP_IOCTL_TRACER_CLOSE_SIZE_IN sizeof(SUPREQHDR)
1302#define SUP_IOCTL_TRACER_CLOSE_SIZE_OUT sizeof(SUPREQHDR)
1303/** @} */
1304
1305
1306/** @name SUP_IOCTL_TRACER_IOCTL
1307 * Speak UNIX ioctl() with the tracer.
1308 *
1309 * The session must have opened the tracer prior to issuing this request.
1310 *
1311 * @{
1312 */
1313#define SUP_IOCTL_TRACER_IOCTL SUP_CTL_CODE_SIZE(30, SUP_IOCTL_TRACER_IOCTL_SIZE)
1314#define SUP_IOCTL_TRACER_IOCTL_SIZE sizeof(SUPTRACERIOCTL)
1315#define SUP_IOCTL_TRACER_IOCTL_SIZE_IN sizeof(SUPTRACERIOCTL)
1316#define SUP_IOCTL_TRACER_IOCTL_SIZE_OUT (RT_UOFFSETOF(SUPTRACERIOCTL, u.Out.iRetVal) + sizeof(int32_t))
1317typedef struct SUPTRACERIOCTL
1318{
1319 /** The header. */
1320 SUPREQHDR Hdr;
1321 union
1322 {
1323 struct
1324 {
1325 /** The command. */
1326 RTHCUINTPTR uCmd;
1327 /** Argument to the command. */
1328 RTHCUINTPTR uArg;
1329 } In;
1330
1331 struct
1332 {
1333 /** The return value. */
1334 int32_t iRetVal;
1335 } Out;
1336 } u;
1337} SUPTRACERIOCTL, *PSUPTRACERIOCTL;
1338/** @} */
1339
1340
1341/** @name SUP_IOCTL_TRACER_UMOD_REG
1342 * Registers tracepoints in a user mode module.
1343 *
1344 * @{
1345 */
1346#define SUP_IOCTL_TRACER_UMOD_REG SUP_CTL_CODE_SIZE(31, SUP_IOCTL_TRACER_UMOD_REG_SIZE)
1347#define SUP_IOCTL_TRACER_UMOD_REG_SIZE sizeof(SUPTRACERUMODREG)
1348#define SUP_IOCTL_TRACER_UMOD_REG_SIZE_IN sizeof(SUPTRACERUMODREG)
1349#define SUP_IOCTL_TRACER_UMOD_REG_SIZE_OUT sizeof(SUPREQHDR)
1350typedef struct SUPTRACERUMODREG
1351{
1352 /** The header. */
1353 SUPREQHDR Hdr;
1354 union
1355 {
1356 struct
1357 {
1358 /** The address at which the VTG header actually resides.
1359 * This will differ from R3PtrVtgHdr for raw-mode context
1360 * modules. */
1361 RTUINTPTR uVtgHdrAddr;
1362 /** The ring-3 pointer of the VTG header. */
1363 RTR3PTR R3PtrVtgHdr;
1364 /** The ring-3 pointer of the probe location string table. */
1365 RTR3PTR R3PtrStrTab;
1366 /** The size of the string table. */
1367 uint32_t cbStrTab;
1368 /** Future flags, MBZ. */
1369 uint32_t fFlags;
1370 /** The module name. */
1371 char szName[64];
1372 } In;
1373 } u;
1374} SUPTRACERUMODREG, *PSUPTRACERUMODREG;
1375/** @} */
1376
1377
1378/** @name SUP_IOCTL_TRACER_UMOD_DEREG
1379 * Deregisters tracepoints in a user mode module.
1380 *
1381 * @{
1382 */
1383#define SUP_IOCTL_TRACER_UMOD_DEREG SUP_CTL_CODE_SIZE(32, SUP_IOCTL_TRACER_UMOD_DEREG_SIZE)
1384#define SUP_IOCTL_TRACER_UMOD_DEREG_SIZE sizeof(SUPTRACERUMODDEREG)
1385#define SUP_IOCTL_TRACER_UMOD_DEREG_SIZE_IN sizeof(SUPTRACERUMODDEREG)
1386#define SUP_IOCTL_TRACER_UMOD_DEREG_SIZE_OUT sizeof(SUPREQHDR)
1387typedef struct SUPTRACERUMODDEREG
1388{
1389 /** The header. */
1390 SUPREQHDR Hdr;
1391 union
1392 {
1393 struct
1394 {
1395 /** Pointer to the VTG header. */
1396 RTR3PTR pVtgHdr;
1397 } In;
1398 } u;
1399} SUPTRACERUMODDEREG, *PSUPTRACERUMODDEREG;
1400/** @} */
1401
1402
1403/** @name SUP_IOCTL_TRACER_UMOD_FIRE_PROBE
1404 * Fire a probe in a user tracepoint module.
1405 *
1406 * @{
1407 */
1408#define SUP_IOCTL_TRACER_UMOD_FIRE_PROBE SUP_CTL_CODE_SIZE(33, SUP_IOCTL_TRACER_UMOD_FIRE_PROBE_SIZE)
1409#define SUP_IOCTL_TRACER_UMOD_FIRE_PROBE_SIZE sizeof(SUPTRACERUMODFIREPROBE)
1410#define SUP_IOCTL_TRACER_UMOD_FIRE_PROBE_SIZE_IN sizeof(SUPTRACERUMODFIREPROBE)
1411#define SUP_IOCTL_TRACER_UMOD_FIRE_PROBE_SIZE_OUT sizeof(SUPREQHDR)
1412typedef struct SUPTRACERUMODFIREPROBE
1413{
1414 /** The header. */
1415 SUPREQHDR Hdr;
1416 union
1417 {
1418 SUPDRVTRACERUSRCTX In;
1419 } u;
1420} SUPTRACERUMODFIREPROBE, *PSUPTRACERUMODFIREPROBE;
1421/** @} */
1422
1423
1424/** @name SUP_IOCTL_MSR_PROBER
1425 * MSR probing interface, not available in normal builds.
1426 *
1427 * @{
1428 */
1429#define SUP_IOCTL_MSR_PROBER SUP_CTL_CODE_SIZE(34, SUP_IOCTL_MSR_PROBER_SIZE)
1430#define SUP_IOCTL_MSR_PROBER_SIZE sizeof(SUPMSRPROBER)
1431#define SUP_IOCTL_MSR_PROBER_SIZE_IN sizeof(SUPMSRPROBER)
1432#define SUP_IOCTL_MSR_PROBER_SIZE_OUT sizeof(SUPMSRPROBER)
1433
1434typedef enum SUPMSRPROBEROP
1435{
1436 SUPMSRPROBEROP_INVALID = 0, /**< The customary invalid zero value. */
1437 SUPMSRPROBEROP_READ, /**< Read an MSR. */
1438 SUPMSRPROBEROP_WRITE, /**< Write a value to an MSR (use with care!). */
1439 SUPMSRPROBEROP_MODIFY, /**< Read-modify-restore-flushall. */
1440 SUPMSRPROBEROP_MODIFY_FASTER, /**< Read-modify-restore, skip the flushing. */
1441 SUPMSRPROBEROP_END, /**< End of valid values. */
1442 SUPMSRPROBEROP_32BIT_HACK = 0x7fffffff /**< The customary 32-bit type hack. */
1443} SUPMSRPROBEROP;
1444
1445typedef struct SUPMSRPROBER
1446{
1447 /** The header. */
1448 SUPREQHDR Hdr;
1449
1450 /** Input/output union. */
1451 union
1452 {
1453 /** Inputs. */
1454 struct
1455 {
1456 /** The operation. */
1457 SUPMSRPROBEROP enmOp;
1458 /** The MSR to test. */
1459 uint32_t uMsr;
1460 /** The CPU to perform the operation on.
1461 * Use UINT32_MAX to indicate that any CPU will do. */
1462 uint32_t idCpu;
1463 /** Alignment padding. */
1464 uint32_t u32Padding;
1465 /** Operation specific arguments. */
1466 union
1467 {
1468 /* SUPMSRPROBEROP_READ takes no extra arguments. */
1469
1470 /** For SUPMSRPROBEROP_WRITE. */
1471 struct
1472 {
1473 /** The value to write. */
1474 uint64_t uToWrite;
1475 } Write;
1476
1477 /** For SUPMSRPROBEROP_MODIFY and SUPMSRPROBEROP_MODIFY_FASTER. */
1478 struct
1479 {
1480 /** The value to AND the current MSR value with to construct the value to
1481 * write. This applied first. */
1482 uint64_t fAndMask;
1483 /** The value to OR the result of the above mentioned AND operation with
1484 * attempting to modify the MSR. */
1485 uint64_t fOrMask;
1486 } Modify;
1487
1488 /** Reserve space for the future. */
1489 uint64_t auPadding[3];
1490 } uArgs;
1491 } In;
1492
1493 /** Outputs. */
1494 struct
1495 {
1496 /** Operation specific results. */
1497 union
1498 {
1499 /** For SUPMSRPROBEROP_READ. */
1500 struct
1501 {
1502 /** The value we've read. */
1503 uint64_t uValue;
1504 /** Set if we GPed while reading it. */
1505 bool fGp;
1506 } Read;
1507
1508 /** For SUPMSRPROBEROP_WRITE. */
1509 struct
1510 {
1511 /** Set if we GPed while writing it. */
1512 bool fGp;
1513 } Write;
1514
1515 /** For SUPMSRPROBEROP_MODIFY and SUPMSRPROBEROP_MODIFY_FASTER. */
1516 SUPMSRPROBERMODIFYRESULT Modify;
1517
1518 /** Size padding/aligning. */
1519 uint64_t auPadding[5];
1520 } uResults;
1521 } Out;
1522 } u;
1523} SUPMSRPROBER, *PSUPMSRPROBER;
1524AssertCompileMemberAlignment(SUPMSRPROBER, u, 8);
1525AssertCompileMemberAlignment(SUPMSRPROBER, u.In.uArgs, 8);
1526AssertCompileMembersSameSizeAndOffset(SUPMSRPROBER, u.In, SUPMSRPROBER, u.Out);
1527/** @} */
1528
1529/** @name SUP_IOCTL_RESUME_SUSPENDED_KBDS
1530 * Resume suspended keyboard devices if any found in the system.
1531 *
1532 * @{
1533 */
1534#define SUP_IOCTL_RESUME_SUSPENDED_KBDS SUP_CTL_CODE_SIZE(35, SUP_IOCTL_RESUME_SUSPENDED_KBDS_SIZE)
1535#define SUP_IOCTL_RESUME_SUSPENDED_KBDS_SIZE sizeof(SUPREQHDR)
1536#define SUP_IOCTL_RESUME_SUSPENDED_KBDS_SIZE_IN sizeof(SUPREQHDR)
1537#define SUP_IOCTL_RESUME_SUSPENDED_KBDS_SIZE_OUT sizeof(SUPREQHDR)
1538/** @} */
1539
1540
1541/** @name SUP_IOCTL_TSC_DELTA_MEASURE
1542 * Measure the TSC-delta between the specified CPU and the master TSC.
1543 *
1544 * To call this I/O control, the client must first have mapped the GIP.
1545 *
1546 * @{
1547 */
1548#define SUP_IOCTL_TSC_DELTA_MEASURE SUP_CTL_CODE_SIZE(36, SUP_IOCTL_TSC_DELTA_MEASURE_SIZE)
1549#define SUP_IOCTL_TSC_DELTA_MEASURE_SIZE sizeof(SUPTSCDELTAMEASURE)
1550#define SUP_IOCTL_TSC_DELTA_MEASURE_SIZE_IN sizeof(SUPTSCDELTAMEASURE)
1551#define SUP_IOCTL_TSC_DELTA_MEASURE_SIZE_OUT sizeof(SUPREQHDR)
1552typedef struct SUPTSCDELTAMEASURE
1553{
1554 /** The header. */
1555 SUPREQHDR Hdr;
1556
1557 /** Input/output union. */
1558 union
1559 {
1560 struct
1561 {
1562 /** Which CPU to take the TSC-delta measurement for. */
1563 RTCPUID idCpu;
1564 /** Number of times to retry on failure (specify 0 for default). */
1565 uint8_t cRetries;
1566 /** Number of milliseconds to wait before each retry. */
1567 uint8_t cMsWaitRetry;
1568 /** Whether to force taking a measurement if one exists already. */
1569 bool fForce;
1570 /** Whether to do the measurement asynchronously (if possible). */
1571 bool fAsync;
1572 } In;
1573 } u;
1574} SUPTSCDELTAMEASURE, *PSUPTSCDELTAMEASURE;
1575AssertCompileMemberAlignment(SUPTSCDELTAMEASURE, u, 8);
1576AssertCompileSize(SUPTSCDELTAMEASURE, 6*4 + 4+1+1+1+1);
1577/** @} */
1578
1579
1580/** @name SUP_IOCTL_TSC_READ
1581 * Reads the TSC and apply TSC-delta if applicable, determining the delta if
1582 * necessary (i64TSCDelta = INT64_MAX).
1583 *
1584 * This latter function is the primary use case of this I/O control. To call
1585 * this I/O control, the client must first have mapped the GIP.
1586 *
1587 * @{
1588 */
1589#define SUP_IOCTL_TSC_READ SUP_CTL_CODE_SIZE(37, SUP_IOCTL_TSC_READ_SIZE)
1590#define SUP_IOCTL_TSC_READ_SIZE sizeof(SUPTSCREAD)
1591#define SUP_IOCTL_TSC_READ_SIZE_IN sizeof(SUPREQHDR)
1592#define SUP_IOCTL_TSC_READ_SIZE_OUT sizeof(SUPTSCREAD)
1593typedef struct SUPTSCREAD
1594{
1595 /** The header. */
1596 SUPREQHDR Hdr;
1597
1598 /** Input/output union. */
1599 union
1600 {
1601 struct
1602 {
1603 /** The TSC after applying the relevant delta. */
1604 uint64_t u64AdjustedTsc;
1605 /** The APIC Id of the CPU where the TSC was read. */
1606 uint16_t idApic;
1607 /** Explicit alignment padding. */
1608 uint16_t auPadding[3];
1609 } Out;
1610 } u;
1611} SUPTSCREAD, *PSUPTSCREAD;
1612AssertCompileMemberAlignment(SUPTSCREAD, u, 8);
1613AssertCompileSize(SUPTSCREAD, 6*4 + 2*8);
1614/** @} */
1615
1616
1617/** @name SUP_IOCTL_GIP_SET_FLAGS
1618 * Set GIP flags.
1619 *
1620 * @{
1621 */
1622#define SUP_IOCTL_GIP_SET_FLAGS SUP_CTL_CODE_SIZE(39, SUP_IOCTL_GIP_SET_FLAGS_SIZE)
1623#define SUP_IOCTL_GIP_SET_FLAGS_SIZE sizeof(SUPGIPSETFLAGS)
1624#define SUP_IOCTL_GIP_SET_FLAGS_SIZE_IN sizeof(SUPGIPSETFLAGS)
1625#define SUP_IOCTL_GIP_SET_FLAGS_SIZE_OUT sizeof(SUPREQHDR)
1626typedef struct SUPGIPSETFLAGS
1627{
1628 /** The header. */
1629 SUPREQHDR Hdr;
1630 union
1631 {
1632 struct
1633 {
1634 /** The AND flags mask, see SUPGIP_FLAGS_XXX. */
1635 uint32_t fAndMask;
1636 /** The OR flags mask, see SUPGIP_FLAGS_XXX. */
1637 uint32_t fOrMask;
1638 } In;
1639 } u;
1640} SUPGIPSETFLAGS, *PSUPGIPSETFLAGS;
1641/** @} */
1642
1643
1644/** @name SUP_IOCTL_UCODE_REV
1645 * Get the CPU microcode revision.
1646 *
1647 * @{
1648 */
1649#define SUP_IOCTL_UCODE_REV SUP_CTL_CODE_SIZE(40, SUP_IOCTL_UCODE_REV_SIZE)
1650#define SUP_IOCTL_UCODE_REV_SIZE sizeof(SUPUCODEREV)
1651#define SUP_IOCTL_UCODE_REV_SIZE_IN sizeof(SUPREQHDR)
1652#define SUP_IOCTL_UCODE_REV_SIZE_OUT sizeof(SUPUCODEREV)
1653typedef struct SUPUCODEREV
1654{
1655 /** The header. */
1656 SUPREQHDR Hdr;
1657 union
1658 {
1659 struct
1660 {
1661 /** The microcode revision dword. */
1662 uint32_t MicrocodeRev;
1663 } Out;
1664 } u;
1665} SUPUCODEREV, *PSUPUCODEREV;
1666/** @} */
1667
1668
1669/** @name SUP_IOCTL_HWVIRT_MSRS
1670 * Get hardware-virtualization MSRs.
1671 *
1672 * This queries a lot more information than merely VT-x/AMD-V basic capabilities
1673 * provided by SUP_IOCTL_VT_CAPS.
1674 *
1675 * @{
1676 */
1677#define SUP_IOCTL_GET_HWVIRT_MSRS SUP_CTL_CODE_SIZE(41, SUP_IOCTL_GET_HWVIRT_MSRS_SIZE)
1678#define SUP_IOCTL_GET_HWVIRT_MSRS_SIZE sizeof(SUPGETHWVIRTMSRS)
1679#define SUP_IOCTL_GET_HWVIRT_MSRS_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPGETHWVIRTMSRS, u.In))
1680#define SUP_IOCTL_GET_HWVIRT_MSRS_SIZE_OUT sizeof(SUPGETHWVIRTMSRS)
1681
1682typedef struct SUPGETHWVIRTMSRS
1683{
1684 /** The header. */
1685 SUPREQHDR Hdr;
1686 union
1687 {
1688 struct
1689 {
1690 /** Whether to force re-querying of MSRs. */
1691 bool fForce;
1692 /** Reserved. Must be false. */
1693 bool fReserved0;
1694 /** Reserved. Must be false. */
1695 bool fReserved1;
1696 /** Reserved. Must be false. */
1697 bool fReserved2;
1698 } In;
1699
1700 struct
1701 {
1702 /** Hardware-virtualization MSRs. */
1703 SUPHWVIRTMSRS HwvirtMsrs;
1704 } Out;
1705 } u;
1706} SUPGETHWVIRTMSRS, *PSUPGETHWVIRTMSRS;
1707/** @} */
1708
1709
1710#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
1711# pragma pack() /* paranoia */
1712#endif
1713
1714#endif /* !VBOX_INCLUDED_SRC_Support_SUPDrvIOC_h */
1715
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