VirtualBox

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

Last change on this file since 68529 was 68529, checked in by vboxsync, 7 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use