VirtualBox

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

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

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use