[3537] | 1 | /* $Revision: 18191 $ */
|
---|
[1] | 2 | /** @file
|
---|
[3537] | 3 | * VirtualBox Support Driver - IOCtl definitions.
|
---|
[1] | 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[8155] | 7 | * Copyright (C) 2006-2007 Sun Microsystems, Inc.
|
---|
[1] | 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
|
---|
[5999] | 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.
|
---|
[8155] | 25 | *
|
---|
| 26 | * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
|
---|
| 27 | * Clara, CA 95054 USA or visit http://www.sun.com if you need
|
---|
| 28 | * additional information or have any questions.
|
---|
[1] | 29 | */
|
---|
| 30 |
|
---|
[10256] | 31 | #ifndef ___SUPDrvIOC_h___
|
---|
| 32 | #define ___SUPDrvIOC_h___
|
---|
[1] | 33 |
|
---|
| 34 | /*
|
---|
| 35 | * Basic types.
|
---|
| 36 | */
|
---|
| 37 | #include <iprt/stdint.h>
|
---|
| 38 |
|
---|
| 39 | /*
|
---|
| 40 | * IOCtl numbers.
|
---|
| 41 | * We're using the Win32 type of numbers here, thus the macros below.
|
---|
| 42 | * The SUP_IOCTL_FLAG macro is used to separate requests from 32-bit
|
---|
| 43 | * and 64-bit processes.
|
---|
| 44 | */
|
---|
[3672] | 45 | #ifdef RT_ARCH_AMD64
|
---|
[1] | 46 | # define SUP_IOCTL_FLAG 128
|
---|
[3672] | 47 | #elif defined(RT_ARCH_X86)
|
---|
[1] | 48 | # define SUP_IOCTL_FLAG 0
|
---|
| 49 | #else
|
---|
| 50 | # error "dunno which arch this is!"
|
---|
| 51 | #endif
|
---|
| 52 |
|
---|
[3672] | 53 | #ifdef RT_OS_WINDOWS
|
---|
[1] | 54 | # ifndef CTL_CODE
|
---|
[4800] | 55 | # include <Windows.h>
|
---|
[1] | 56 | # endif
|
---|
[4800] | 57 | /* Automatic buffering, size not encoded. */
|
---|
| 58 | # define SUP_CTL_CODE_SIZE(Function, Size) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) | SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
|
---|
| 59 | # define SUP_CTL_CODE_BIG(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) | SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
|
---|
| 60 | # define SUP_CTL_CODE_FAST(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) | SUP_IOCTL_FLAG, METHOD_NEITHER, FILE_WRITE_ACCESS)
|
---|
| 61 | # define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
|
---|
[1] | 62 |
|
---|
[4800] | 63 | #elif defined(RT_OS_SOLARIS)
|
---|
| 64 | /* No automatic buffering, size limited to 255 bytes. */
|
---|
| 65 | # include <sys/ioccom.h>
|
---|
| 66 | # define SUP_CTL_CODE_SIZE(Function, Size) _IOWRN('V', (Function) | SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
|
---|
[4824] | 67 | # define SUP_CTL_CODE_BIG(Function) _IOWRN('V', (Function) | SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
|
---|
[4800] | 68 | # define SUP_CTL_CODE_FAST(Function) _IO( 'V', (Function) | SUP_IOCTL_FLAG)
|
---|
| 69 | # define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
|
---|
| 70 |
|
---|
[3672] | 71 | #elif defined(RT_OS_OS2)
|
---|
[4800] | 72 | /* No automatic buffering, size not encoded. */
|
---|
| 73 | # define SUP_CTL_CATEGORY 0xc0
|
---|
| 74 | # define SUP_CTL_CODE_SIZE(Function, Size) ((unsigned char)(Function))
|
---|
| 75 | # define SUP_CTL_CODE_BIG(Function) ((unsigned char)(Function))
|
---|
| 76 | # define SUP_CTL_CATEGORY_FAST 0xc1
|
---|
| 77 | # define SUP_CTL_CODE_FAST(Function) ((unsigned char)(Function))
|
---|
| 78 | # define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
|
---|
[1] | 79 |
|
---|
[3672] | 80 | #elif defined(RT_OS_LINUX)
|
---|
[4800] | 81 | /* No automatic buffering, size limited to 16KB. */
|
---|
| 82 | # include <linux/ioctl.h>
|
---|
| 83 | # define SUP_CTL_CODE_SIZE(Function, Size) _IOC(_IOC_READ | _IOC_WRITE, 'V', (Function) | SUP_IOCTL_FLAG, (Size))
|
---|
| 84 | # define SUP_CTL_CODE_BIG(Function) _IO('V', (Function) | SUP_IOCTL_FLAG)
|
---|
| 85 | # define SUP_CTL_CODE_FAST(Function) _IO('V', (Function) | SUP_IOCTL_FLAG)
|
---|
| 86 | # define SUP_CTL_CODE_NO_SIZE(uIOCtl) ((uIOCtl) & ~IOCSIZE_MASK)
|
---|
[1] | 87 |
|
---|
[3672] | 88 | #elif defined(RT_OS_L4)
|
---|
[4800] | 89 | /* Implemented in suplib, no worries. */
|
---|
| 90 | # define SUP_CTL_CODE_SIZE(Function, Size) (Function)
|
---|
| 91 | # define SUP_CTL_CODE_BIG(Function) (Function)
|
---|
| 92 | # define SUP_CTL_CODE_FAST(Function) (Function)
|
---|
| 93 | # define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
|
---|
[3512] | 94 |
|
---|
[4800] | 95 | #else /* BSD Like */
|
---|
| 96 | /* Automatic buffering, size limited to 4KB on *BSD and 8KB on Darwin - commands the limit, 4KB. */
|
---|
[1] | 97 | # include <sys/ioccom.h>
|
---|
[4800] | 98 | # define SUP_CTL_CODE_SIZE(Function, Size) _IOC(IOC_INOUT, 'V', (Function) | SUP_IOCTL_FLAG, (Size))
|
---|
| 99 | # define SUP_CTL_CODE_BIG(Function) _IO('V', (Function) | SUP_IOCTL_FLAG)
|
---|
| 100 | # define SUP_CTL_CODE_FAST(Function) _IO('V', (Function) | SUP_IOCTL_FLAG)
|
---|
| 101 | # define SUP_CTL_CODE_NO_SIZE(uIOCtl) ( (uIOCtl) & ~_IOC(0,0,0,IOCPARM_MASK) )
|
---|
[1] | 102 | #endif
|
---|
| 103 |
|
---|
[397] | 104 | /** Fast path IOCtl: VMMR0_DO_RAW_RUN */
|
---|
[4800] | 105 | #define SUP_IOCTL_FAST_DO_RAW_RUN SUP_CTL_CODE_FAST(64)
|
---|
[397] | 106 | /** Fast path IOCtl: VMMR0_DO_HWACC_RUN */
|
---|
[4800] | 107 | #define SUP_IOCTL_FAST_DO_HWACC_RUN SUP_CTL_CODE_FAST(65)
|
---|
[397] | 108 | /** Just a NOP call for profiling the latency of a fast ioctl call to VMMR0. */
|
---|
[4800] | 109 | #define SUP_IOCTL_FAST_DO_NOP SUP_CTL_CODE_FAST(66)
|
---|
[1] | 110 |
|
---|
| 111 |
|
---|
[4800] | 112 |
|
---|
[1] | 113 | /*******************************************************************************
|
---|
| 114 | * Structures and Typedefs *
|
---|
| 115 | *******************************************************************************/
|
---|
[3672] | 116 | #ifdef RT_ARCH_AMD64
|
---|
[1] | 117 | # pragma pack(8) /* paranoia. */
|
---|
| 118 | #else
|
---|
| 119 | # pragma pack(4) /* paranoia. */
|
---|
| 120 | #endif
|
---|
| 121 |
|
---|
[4800] | 122 |
|
---|
[1] | 123 | /**
|
---|
[4800] | 124 | * Common In/Out header.
|
---|
[1] | 125 | */
|
---|
[4800] | 126 | typedef struct SUPREQHDR
|
---|
[1] | 127 | {
|
---|
[4800] | 128 | /** Cookie. */
|
---|
| 129 | uint32_t u32Cookie;
|
---|
| 130 | /** Session cookie. */
|
---|
| 131 | uint32_t u32SessionCookie;
|
---|
| 132 | /** The size of the input. */
|
---|
| 133 | uint32_t cbIn;
|
---|
| 134 | /** The size of the output. */
|
---|
| 135 | uint32_t cbOut;
|
---|
| 136 | /** Flags. See SUPREQHDR_FLAGS_* for details and values. */
|
---|
| 137 | uint32_t fFlags;
|
---|
| 138 | /** The VBox status code of the operation, out direction only. */
|
---|
| 139 | int32_t rc;
|
---|
| 140 | } SUPREQHDR;
|
---|
| 141 | /** Pointer to a IOC header. */
|
---|
| 142 | typedef SUPREQHDR *PSUPREQHDR;
|
---|
[1] | 143 |
|
---|
[4800] | 144 | /** @name SUPREQHDR::fFlags values
|
---|
| 145 | * @{ */
|
---|
| 146 | /** Masks out the magic value. */
|
---|
| 147 | #define SUPREQHDR_FLAGS_MAGIC_MASK UINT32_C(0xff0000ff)
|
---|
| 148 | /** The generic mask. */
|
---|
| 149 | #define SUPREQHDR_FLAGS_GEN_MASK UINT32_C(0x0000ff00)
|
---|
| 150 | /** The request specific mask. */
|
---|
| 151 | #define SUPREQHDR_FLAGS_REQ_MASK UINT32_C(0x00ff0000)
|
---|
[1193] | 152 |
|
---|
[4800] | 153 | /** There is extra input that needs copying on some platforms. */
|
---|
| 154 | #define SUPREQHDR_FLAGS_EXTRA_IN UINT32_C(0x00000100)
|
---|
| 155 | /** There is extra output that needs copying on some platforms. */
|
---|
| 156 | #define SUPREQHDR_FLAGS_EXTRA_OUT UINT32_C(0x00000200)
|
---|
| 157 |
|
---|
| 158 | /** The magic value. */
|
---|
| 159 | #define SUPREQHDR_FLAGS_MAGIC UINT32_C(0x42000042)
|
---|
| 160 | /** The default value. Use this when no special stuff is requested. */
|
---|
| 161 | #define SUPREQHDR_FLAGS_DEFAULT SUPREQHDR_FLAGS_MAGIC
|
---|
| 162 | /** @} */
|
---|
| 163 |
|
---|
| 164 |
|
---|
| 165 | /** @name SUP_IOCTL_COOKIE
|
---|
| 166 | * @{
|
---|
| 167 | */
|
---|
| 168 | /** Negotiate cookie. */
|
---|
| 169 | #define SUP_IOCTL_COOKIE SUP_CTL_CODE_SIZE(1, SUP_IOCTL_COOKIE_SIZE)
|
---|
| 170 | /** The request size. */
|
---|
| 171 | #define SUP_IOCTL_COOKIE_SIZE sizeof(SUPCOOKIE)
|
---|
| 172 | /** The SUPREQHDR::cbIn value. */
|
---|
| 173 | #define SUP_IOCTL_COOKIE_SIZE_IN sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.In)
|
---|
| 174 | /** The SUPREQHDR::cbOut value. */
|
---|
| 175 | #define SUP_IOCTL_COOKIE_SIZE_OUT sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.Out)
|
---|
[1840] | 176 | /** SUPCOOKIE_IN magic word. */
|
---|
[4800] | 177 | #define SUPCOOKIE_MAGIC "The Magic Word!"
|
---|
| 178 | /** The initial cookie. */
|
---|
| 179 | #define SUPCOOKIE_INITIAL_COOKIE 0x69726f74 /* 'tori' */
|
---|
| 180 |
|
---|
[1840] | 181 | /** Current interface version.
|
---|
| 182 | * The upper 16-bit is the major version, the the lower the minor version.
|
---|
[14575] | 183 | * When incompatible changes are made, the upper major number has to be changed.
|
---|
| 184 | *
|
---|
| 185 | * @todo Pending work on next major version change:
|
---|
| 186 | * - Eliminate supdrvPageWasLockedByPageAlloc and supdrvPageGetPhys.
|
---|
| 187 | * - Remove SUPR0PageAlloc in favor of SUPR0PageAllocEx, removing
|
---|
| 188 | * and renaming the related IOCtls too.
|
---|
| 189 | */
|
---|
[15838] | 190 | #define SUPDRV_IOC_VERSION 0x000a0009
|
---|
[1840] | 191 |
|
---|
[4800] | 192 | /** SUP_IOCTL_COOKIE. */
|
---|
| 193 | typedef struct SUPCOOKIE
|
---|
[1] | 194 | {
|
---|
[4800] | 195 | /** The header.
|
---|
| 196 | * u32Cookie must be set to SUPCOOKIE_INITIAL_COOKIE.
|
---|
| 197 | * u32SessionCookie should be set to some random value. */
|
---|
| 198 | SUPREQHDR Hdr;
|
---|
| 199 | union
|
---|
| 200 | {
|
---|
| 201 | struct
|
---|
| 202 | {
|
---|
| 203 | /** Magic word. */
|
---|
| 204 | char szMagic[16];
|
---|
| 205 | /** The requested interface version number. */
|
---|
| 206 | uint32_t u32ReqVersion;
|
---|
| 207 | /** The minimum interface version number. */
|
---|
| 208 | uint32_t u32MinVersion;
|
---|
| 209 | } In;
|
---|
| 210 | struct
|
---|
| 211 | {
|
---|
| 212 | /** Cookie. */
|
---|
| 213 | uint32_t u32Cookie;
|
---|
| 214 | /** Session cookie. */
|
---|
| 215 | uint32_t u32SessionCookie;
|
---|
| 216 | /** Interface version for this session. */
|
---|
| 217 | uint32_t u32SessionVersion;
|
---|
| 218 | /** The actual interface version in the driver. */
|
---|
| 219 | uint32_t u32DriverVersion;
|
---|
| 220 | /** Number of functions available for the SUP_IOCTL_QUERY_FUNCS request. */
|
---|
| 221 | uint32_t cFunctions;
|
---|
| 222 | /** Session handle. */
|
---|
| 223 | R0PTRTYPE(PSUPDRVSESSION) pSession;
|
---|
| 224 | } Out;
|
---|
| 225 | } u;
|
---|
| 226 | } SUPCOOKIE, *PSUPCOOKIE;
|
---|
| 227 | /** @} */
|
---|
[1] | 228 |
|
---|
| 229 |
|
---|
[4800] | 230 | /** @name SUP_IOCTL_QUERY_FUNCS
|
---|
| 231 | * Query SUPR0 functions.
|
---|
| 232 | * @{
|
---|
| 233 | */
|
---|
| 234 | #define SUP_IOCTL_QUERY_FUNCS(cFuncs) SUP_CTL_CODE_SIZE(2, SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs))
|
---|
[13061] | 235 | #define SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs) RT_UOFFSETOF(SUPQUERYFUNCS, u.Out.aFunctions[(cFuncs)])
|
---|
[4800] | 236 | #define SUP_IOCTL_QUERY_FUNCS_SIZE_IN sizeof(SUPREQHDR)
|
---|
| 237 | #define SUP_IOCTL_QUERY_FUNCS_SIZE_OUT(cFuncs) SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs)
|
---|
[1840] | 238 |
|
---|
[4800] | 239 | /** A function. */
|
---|
[1] | 240 | typedef struct SUPFUNC
|
---|
| 241 | {
|
---|
| 242 | /** Name - mangled. */
|
---|
[1840] | 243 | char szName[32];
|
---|
[1] | 244 | /** Address. */
|
---|
[1840] | 245 | RTR0PTR pfn;
|
---|
[1] | 246 | } SUPFUNC, *PSUPFUNC;
|
---|
| 247 |
|
---|
[4800] | 248 | typedef struct SUPQUERYFUNCS
|
---|
[1] | 249 | {
|
---|
[4800] | 250 | /** The header. */
|
---|
| 251 | SUPREQHDR Hdr;
|
---|
| 252 | union
|
---|
| 253 | {
|
---|
| 254 | struct
|
---|
| 255 | {
|
---|
| 256 | /** Number of functions returned. */
|
---|
| 257 | uint32_t cFunctions;
|
---|
| 258 | /** Array of functions. */
|
---|
| 259 | SUPFUNC aFunctions[1];
|
---|
| 260 | } Out;
|
---|
| 261 | } u;
|
---|
| 262 | } SUPQUERYFUNCS, *PSUPQUERYFUNCS;
|
---|
| 263 | /** @} */
|
---|
[1] | 264 |
|
---|
| 265 |
|
---|
[4800] | 266 | /** @name SUP_IOCTL_IDT_INSTALL
|
---|
| 267 | * Install IDT patch for calling processor.
|
---|
| 268 | * @{
|
---|
| 269 | */
|
---|
| 270 | #define SUP_IOCTL_IDT_INSTALL SUP_CTL_CODE_SIZE(3, SUP_IOCTL_IDT_INSTALL_SIZE)
|
---|
| 271 | #define SUP_IOCTL_IDT_INSTALL_SIZE sizeof(SUPIDTINSTALL)
|
---|
| 272 | #define SUP_IOCTL_IDT_INSTALL_SIZE_IN sizeof(SUPREQHDR)
|
---|
| 273 | #define SUP_IOCTL_IDT_INSTALL_SIZE_OUT sizeof(SUPIDTINSTALL)
|
---|
| 274 | typedef struct SUPIDTINSTALL
|
---|
[1] | 275 | {
|
---|
[4800] | 276 | /** The header. */
|
---|
| 277 | SUPREQHDR Hdr;
|
---|
| 278 | union
|
---|
| 279 | {
|
---|
| 280 | struct
|
---|
| 281 | {
|
---|
| 282 | /** The IDT entry number. */
|
---|
| 283 | uint8_t u8Idt;
|
---|
| 284 | } Out;
|
---|
| 285 | } u;
|
---|
| 286 | } SUPIDTINSTALL, *PSUPIDTINSTALL;
|
---|
| 287 | /** @} */
|
---|
[1] | 288 |
|
---|
| 289 |
|
---|
[4800] | 290 | /** @name SUP_IOCTL_IDT_REMOVE
|
---|
| 291 | * Remove IDT patch for calling processor.
|
---|
| 292 | * @{
|
---|
| 293 | */
|
---|
| 294 | #define SUP_IOCTL_IDT_REMOVE SUP_CTL_CODE_SIZE(4, SUP_IOCTL_IDT_REMOVE_SIZE)
|
---|
| 295 | #define SUP_IOCTL_IDT_REMOVE_SIZE sizeof(SUPIDTREMOVE)
|
---|
| 296 | #define SUP_IOCTL_IDT_REMOVE_SIZE_IN sizeof(SUPIDTREMOVE)
|
---|
| 297 | #define SUP_IOCTL_IDT_REMOVE_SIZE_OUT sizeof(SUPIDTREMOVE)
|
---|
| 298 | typedef struct SUPIDTREMOVE
|
---|
[1] | 299 | {
|
---|
[4800] | 300 | /** The header. */
|
---|
| 301 | SUPREQHDR Hdr;
|
---|
| 302 | } SUPIDTREMOVE, *PSUPIDTREMOVE;
|
---|
| 303 | /** @}*/
|
---|
[1] | 304 |
|
---|
| 305 |
|
---|
[4800] | 306 | /** @name SUP_IOCTL_LDR_OPEN
|
---|
| 307 | * Open an image.
|
---|
| 308 | * @{
|
---|
| 309 | */
|
---|
| 310 | #define SUP_IOCTL_LDR_OPEN SUP_CTL_CODE_SIZE(5, SUP_IOCTL_LDR_OPEN_SIZE)
|
---|
| 311 | #define SUP_IOCTL_LDR_OPEN_SIZE sizeof(SUPLDROPEN)
|
---|
| 312 | #define SUP_IOCTL_LDR_OPEN_SIZE_IN sizeof(SUPLDROPEN)
|
---|
| 313 | #define SUP_IOCTL_LDR_OPEN_SIZE_OUT (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDROPEN, u.Out))
|
---|
| 314 | typedef struct SUPLDROPEN
|
---|
[1] | 315 | {
|
---|
[4800] | 316 | /** The header. */
|
---|
| 317 | SUPREQHDR Hdr;
|
---|
| 318 | union
|
---|
| 319 | {
|
---|
| 320 | struct
|
---|
| 321 | {
|
---|
| 322 | /** Size of the image we'll be loading. */
|
---|
| 323 | uint32_t cbImage;
|
---|
| 324 | /** Image name.
|
---|
| 325 | * This is the NAME of the image, not the file name. It is used
|
---|
| 326 | * to share code with other processes. (Max len is 32 chars!) */
|
---|
| 327 | char szName[32];
|
---|
| 328 | } In;
|
---|
| 329 | struct
|
---|
| 330 | {
|
---|
| 331 | /** The base address of the image. */
|
---|
| 332 | RTR0PTR pvImageBase;
|
---|
| 333 | /** Indicate whether or not the image requires loading. */
|
---|
| 334 | bool fNeedsLoading;
|
---|
| 335 | } Out;
|
---|
| 336 | } u;
|
---|
| 337 | } SUPLDROPEN, *PSUPLDROPEN;
|
---|
| 338 | /** @} */
|
---|
[1] | 339 |
|
---|
| 340 |
|
---|
[4800] | 341 | /** @name SUP_IOCTL_LDR_LOAD
|
---|
| 342 | * Upload the image bits.
|
---|
| 343 | * @{
|
---|
| 344 | */
|
---|
| 345 | #define SUP_IOCTL_LDR_LOAD SUP_CTL_CODE_BIG(6)
|
---|
[13061] | 346 | #define SUP_IOCTL_LDR_LOAD_SIZE(cbImage) RT_UOFFSETOF(SUPLDRLOAD, u.In.achImage[cbImage])
|
---|
| 347 | #define SUP_IOCTL_LDR_LOAD_SIZE_IN(cbImage) RT_UOFFSETOF(SUPLDRLOAD, u.In.achImage[cbImage])
|
---|
[4800] | 348 | #define SUP_IOCTL_LDR_LOAD_SIZE_OUT sizeof(SUPREQHDR)
|
---|
[1] | 349 |
|
---|
| 350 | /**
|
---|
| 351 | * Module initialization callback function.
|
---|
| 352 | * This is called once after the module has been loaded.
|
---|
| 353 | *
|
---|
| 354 | * @returns 0 on success.
|
---|
| 355 | * @returns Appropriate error code on failure.
|
---|
| 356 | */
|
---|
| 357 | typedef DECLCALLBACK(int) FNR0MODULEINIT(void);
|
---|
| 358 | /** Pointer to a FNR0MODULEINIT(). */
|
---|
[1840] | 359 | typedef R0PTRTYPE(FNR0MODULEINIT *) PFNR0MODULEINIT;
|
---|
[1] | 360 |
|
---|
| 361 | /**
|
---|
| 362 | * Module termination callback function.
|
---|
| 363 | * This is called once right before the module is being unloaded.
|
---|
| 364 | */
|
---|
| 365 | typedef DECLCALLBACK(void) FNR0MODULETERM(void);
|
---|
| 366 | /** Pointer to a FNR0MODULETERM(). */
|
---|
[1840] | 367 | typedef R0PTRTYPE(FNR0MODULETERM *) PFNR0MODULETERM;
|
---|
[1] | 368 |
|
---|
| 369 | /**
|
---|
| 370 | * Symbol table entry.
|
---|
| 371 | */
|
---|
| 372 | typedef struct SUPLDRSYM
|
---|
| 373 | {
|
---|
| 374 | /** Offset into of the string table. */
|
---|
| 375 | uint32_t offName;
|
---|
| 376 | /** Offset of the symbol relative to the image load address. */
|
---|
| 377 | uint32_t offSymbol;
|
---|
[10377] | 378 | } SUPLDRSYM;
|
---|
| 379 | /** Pointer to a symbol table entry. */
|
---|
| 380 | typedef SUPLDRSYM *PSUPLDRSYM;
|
---|
| 381 | /** Pointer to a const symbol table entry. */
|
---|
| 382 | typedef SUPLDRSYM const *PCSUPLDRSYM;
|
---|
[1] | 383 |
|
---|
[4806] | 384 | /**
|
---|
| 385 | * SUPLDRLOAD::u::In::EP type.
|
---|
| 386 | */
|
---|
| 387 | typedef enum SUPLDRLOADEP
|
---|
| 388 | {
|
---|
| 389 | SUPLDRLOADEP_NOTHING = 0,
|
---|
| 390 | SUPLDRLOADEP_VMMR0,
|
---|
[14332] | 391 | SUPLDRLOADEP_SERVICE,
|
---|
[4806] | 392 | SUPLDRLOADEP_32BIT_HACK = 0x7fffffff
|
---|
| 393 | } SUPLDRLOADEP;
|
---|
| 394 |
|
---|
[4800] | 395 | typedef struct SUPLDRLOAD
|
---|
[1] | 396 | {
|
---|
[4800] | 397 | /** The header. */
|
---|
| 398 | SUPREQHDR Hdr;
|
---|
[1] | 399 | union
|
---|
| 400 | {
|
---|
| 401 | struct
|
---|
| 402 | {
|
---|
[4800] | 403 | /** The address of module initialization function. Similar to _DLL_InitTerm(hmod, 0). */
|
---|
| 404 | PFNR0MODULEINIT pfnModuleInit;
|
---|
| 405 | /** The address of module termination function. Similar to _DLL_InitTerm(hmod, 1). */
|
---|
| 406 | PFNR0MODULETERM pfnModuleTerm;
|
---|
| 407 | /** Special entry points. */
|
---|
| 408 | union
|
---|
| 409 | {
|
---|
[14332] | 410 | /** SUPLDRLOADEP_VMMR0. */
|
---|
[4800] | 411 | struct
|
---|
| 412 | {
|
---|
| 413 | /** The module handle (i.e. address). */
|
---|
[14332] | 414 | RTR0PTR pvVMMR0;
|
---|
[4811] | 415 | /** Address of VMMR0EntryInt function. */
|
---|
[14332] | 416 | RTR0PTR pvVMMR0EntryInt;
|
---|
[4811] | 417 | /** Address of VMMR0EntryFast function. */
|
---|
[14332] | 418 | RTR0PTR pvVMMR0EntryFast;
|
---|
[4811] | 419 | /** Address of VMMR0EntryEx function. */
|
---|
[14332] | 420 | RTR0PTR pvVMMR0EntryEx;
|
---|
[4800] | 421 | } VMMR0;
|
---|
[14332] | 422 | /** SUPLDRLOADEP_SERVICE. */
|
---|
| 423 | struct
|
---|
| 424 | {
|
---|
| 425 | /** The service request handler.
|
---|
| 426 | * (PFNR0SERVICEREQHANDLER isn't defined yet.) */
|
---|
| 427 | RTR0PTR pfnServiceReq;
|
---|
| 428 | /** Reserved, must be NIL. */
|
---|
| 429 | RTR0PTR apvReserved[3];
|
---|
| 430 | } Service;
|
---|
[4800] | 431 | } EP;
|
---|
| 432 | /** Address. */
|
---|
| 433 | RTR0PTR pvImageBase;
|
---|
| 434 | /** Entry point type. */
|
---|
[4806] | 435 | SUPLDRLOADEP eEPType;
|
---|
[4800] | 436 | /** The offset of the symbol table. */
|
---|
| 437 | uint32_t offSymbols;
|
---|
| 438 | /** The number of entries in the symbol table. */
|
---|
| 439 | uint32_t cSymbols;
|
---|
| 440 | /** The offset of the string table. */
|
---|
| 441 | uint32_t offStrTab;
|
---|
| 442 | /** Size of the string table. */
|
---|
| 443 | uint32_t cbStrTab;
|
---|
| 444 | /** Size of image (including string and symbol tables). */
|
---|
| 445 | uint32_t cbImage;
|
---|
| 446 | /** The image data. */
|
---|
| 447 | char achImage[1];
|
---|
| 448 | } In;
|
---|
| 449 | } u;
|
---|
| 450 | } SUPLDRLOAD, *PSUPLDRLOAD;
|
---|
| 451 | /** @} */
|
---|
[1] | 452 |
|
---|
| 453 |
|
---|
[4800] | 454 | /** @name SUP_IOCTL_LDR_FREE
|
---|
| 455 | * Free an image.
|
---|
| 456 | * @{
|
---|
| 457 | */
|
---|
| 458 | #define SUP_IOCTL_LDR_FREE SUP_CTL_CODE_SIZE(7, SUP_IOCTL_LDR_FREE_SIZE)
|
---|
| 459 | #define SUP_IOCTL_LDR_FREE_SIZE sizeof(SUPLDRFREE)
|
---|
| 460 | #define SUP_IOCTL_LDR_FREE_SIZE_IN sizeof(SUPLDRFREE)
|
---|
| 461 | #define SUP_IOCTL_LDR_FREE_SIZE_OUT sizeof(SUPREQHDR)
|
---|
| 462 | typedef struct SUPLDRFREE
|
---|
| 463 | {
|
---|
| 464 | /** The header. */
|
---|
| 465 | SUPREQHDR Hdr;
|
---|
| 466 | union
|
---|
| 467 | {
|
---|
| 468 | struct
|
---|
| 469 | {
|
---|
| 470 | /** Address. */
|
---|
| 471 | RTR0PTR pvImageBase;
|
---|
| 472 | } In;
|
---|
| 473 | } u;
|
---|
| 474 | } SUPLDRFREE, *PSUPLDRFREE;
|
---|
| 475 | /** @} */
|
---|
[1840] | 476 |
|
---|
[4800] | 477 |
|
---|
| 478 | /** @name SUP_IOCTL_LDR_GET_SYMBOL
|
---|
| 479 | * Get address of a symbol within an image.
|
---|
| 480 | * @{
|
---|
| 481 | */
|
---|
| 482 | #define SUP_IOCTL_LDR_GET_SYMBOL SUP_CTL_CODE_SIZE(8, SUP_IOCTL_LDR_GET_SYMBOL_SIZE)
|
---|
| 483 | #define SUP_IOCTL_LDR_GET_SYMBOL_SIZE sizeof(SUPLDRGETSYMBOL)
|
---|
| 484 | #define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_IN sizeof(SUPLDRGETSYMBOL)
|
---|
| 485 | #define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_OUT (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDRGETSYMBOL, u.Out))
|
---|
| 486 | typedef struct SUPLDRGETSYMBOL
|
---|
[1] | 487 | {
|
---|
[4800] | 488 | /** The header. */
|
---|
| 489 | SUPREQHDR Hdr;
|
---|
| 490 | union
|
---|
| 491 | {
|
---|
| 492 | struct
|
---|
| 493 | {
|
---|
| 494 | /** Address. */
|
---|
| 495 | RTR0PTR pvImageBase;
|
---|
| 496 | /** The symbol name. */
|
---|
| 497 | char szSymbol[64];
|
---|
| 498 | } In;
|
---|
| 499 | struct
|
---|
| 500 | {
|
---|
| 501 | /** The symbol address. */
|
---|
| 502 | RTR0PTR pvSymbol;
|
---|
| 503 | } Out;
|
---|
| 504 | } u;
|
---|
| 505 | } SUPLDRGETSYMBOL, *PSUPLDRGETSYMBOL;
|
---|
| 506 | /** @} */
|
---|
[1] | 507 |
|
---|
| 508 |
|
---|
[4800] | 509 | /** @name SUP_IOCTL_CALL_VMMR0
|
---|
| 510 | * Call the R0 VMM Entry point.
|
---|
| 511 | *
|
---|
| 512 | * @todo Might have to convert this to a big request...
|
---|
| 513 | * @{
|
---|
| 514 | */
|
---|
| 515 | #define SUP_IOCTL_CALL_VMMR0(cbReq) SUP_CTL_CODE_SIZE(9, SUP_IOCTL_CALL_VMMR0_SIZE(cbReq))
|
---|
[13061] | 516 | #define SUP_IOCTL_CALL_VMMR0_SIZE(cbReq) RT_UOFFSETOF(SUPCALLVMMR0, abReqPkt[cbReq])
|
---|
[4800] | 517 | #define SUP_IOCTL_CALL_VMMR0_SIZE_IN(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
|
---|
| 518 | #define SUP_IOCTL_CALL_VMMR0_SIZE_OUT(cbReq) SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
|
---|
| 519 | typedef struct SUPCALLVMMR0
|
---|
[1] | 520 | {
|
---|
[4800] | 521 | /** The header. */
|
---|
| 522 | SUPREQHDR Hdr;
|
---|
| 523 | union
|
---|
| 524 | {
|
---|
| 525 | struct
|
---|
| 526 | {
|
---|
| 527 | /** The VM handle. */
|
---|
| 528 | PVMR0 pVMR0;
|
---|
| 529 | /** Which operation to execute. */
|
---|
| 530 | uint32_t uOperation;
|
---|
| 531 | #if R0_ARCH_BITS == 64
|
---|
| 532 | /** Alignment. */
|
---|
| 533 | uint32_t u32Reserved;
|
---|
| 534 | #endif
|
---|
| 535 | /** Argument to use when no request packet is supplied. */
|
---|
[4811] | 536 | uint64_t u64Arg;
|
---|
[4800] | 537 | } In;
|
---|
| 538 | } u;
|
---|
| 539 | /** The VMMR0Entry request packet. */
|
---|
| 540 | uint8_t abReqPkt[1];
|
---|
| 541 | } SUPCALLVMMR0, *PSUPCALLVMMR0;
|
---|
| 542 | /** @} */
|
---|
[1] | 543 |
|
---|
[4800] | 544 |
|
---|
| 545 | /** @name SUP_IOCTL_LOW_ALLOC
|
---|
| 546 | * Allocate memory below 4GB (physically).
|
---|
| 547 | * @{
|
---|
| 548 | */
|
---|
| 549 | #define SUP_IOCTL_LOW_ALLOC SUP_CTL_CODE_BIG(10)
|
---|
[13061] | 550 | #define SUP_IOCTL_LOW_ALLOC_SIZE(cPages) ((uint32_t)RT_UOFFSETOF(SUPLOWALLOC, u.Out.aPages[cPages]))
|
---|
[4800] | 551 | #define SUP_IOCTL_LOW_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLOWALLOC, u.In))
|
---|
| 552 | #define SUP_IOCTL_LOW_ALLOC_SIZE_OUT(cPages) SUP_IOCTL_LOW_ALLOC_SIZE(cPages)
|
---|
| 553 | typedef struct SUPLOWALLOC
|
---|
[1] | 554 | {
|
---|
[4800] | 555 | /** The header. */
|
---|
| 556 | SUPREQHDR Hdr;
|
---|
| 557 | union
|
---|
| 558 | {
|
---|
| 559 | struct
|
---|
| 560 | {
|
---|
| 561 | /** Number of pages to allocate. */
|
---|
| 562 | uint32_t cPages;
|
---|
| 563 | } In;
|
---|
| 564 | struct
|
---|
| 565 | {
|
---|
| 566 | /** The ring-3 address of the allocated memory. */
|
---|
| 567 | RTR3PTR pvR3;
|
---|
| 568 | /** The ring-0 address of the allocated memory. */
|
---|
| 569 | RTR0PTR pvR0;
|
---|
| 570 | /** Array of pages. */
|
---|
| 571 | RTHCPHYS aPages[1];
|
---|
| 572 | } Out;
|
---|
| 573 | } u;
|
---|
| 574 | } SUPLOWALLOC, *PSUPLOWALLOC;
|
---|
| 575 | /** @} */
|
---|
[1] | 576 |
|
---|
| 577 |
|
---|
[4800] | 578 | /** @name SUP_IOCTL_LOW_FREE
|
---|
| 579 | * Free low memory.
|
---|
| 580 | * @{
|
---|
| 581 | */
|
---|
| 582 | #define SUP_IOCTL_LOW_FREE SUP_CTL_CODE_SIZE(11, SUP_IOCTL_LOW_FREE_SIZE)
|
---|
| 583 | #define SUP_IOCTL_LOW_FREE_SIZE sizeof(SUPLOWFREE)
|
---|
| 584 | #define SUP_IOCTL_LOW_FREE_SIZE_IN sizeof(SUPLOWFREE)
|
---|
| 585 | #define SUP_IOCTL_LOW_FREE_SIZE_OUT sizeof(SUPREQHDR)
|
---|
| 586 | typedef struct SUPLOWFREE
|
---|
[1] | 587 | {
|
---|
[4800] | 588 | /** The header. */
|
---|
| 589 | SUPREQHDR Hdr;
|
---|
| 590 | union
|
---|
| 591 | {
|
---|
| 592 | struct
|
---|
| 593 | {
|
---|
| 594 | /** The ring-3 address of the memory to free. */
|
---|
| 595 | RTR3PTR pvR3;
|
---|
| 596 | } In;
|
---|
| 597 | } u;
|
---|
| 598 | } SUPLOWFREE, *PSUPLOWFREE;
|
---|
| 599 | /** @} */
|
---|
[1] | 600 |
|
---|
[4800] | 601 |
|
---|
| 602 | /** @name SUP_IOCTL_PAGE_ALLOC
|
---|
| 603 | * Allocate memory and map into the user process.
|
---|
| 604 | * The memory is of course locked.
|
---|
| 605 | * @{
|
---|
| 606 | */
|
---|
| 607 | #define SUP_IOCTL_PAGE_ALLOC SUP_CTL_CODE_BIG(12)
|
---|
[13061] | 608 | #define SUP_IOCTL_PAGE_ALLOC_SIZE(cPages) RT_UOFFSETOF(SUPPAGEALLOC, u.Out.aPages[cPages])
|
---|
[4800] | 609 | #define SUP_IOCTL_PAGE_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGEALLOC, u.In))
|
---|
| 610 | #define SUP_IOCTL_PAGE_ALLOC_SIZE_OUT(cPages) SUP_IOCTL_PAGE_ALLOC_SIZE(cPages)
|
---|
| 611 | typedef struct SUPPAGEALLOC
|
---|
[1] | 612 | {
|
---|
[4800] | 613 | /** The header. */
|
---|
| 614 | SUPREQHDR Hdr;
|
---|
| 615 | union
|
---|
| 616 | {
|
---|
| 617 | struct
|
---|
| 618 | {
|
---|
| 619 | /** Number of pages to allocate */
|
---|
| 620 | uint32_t cPages;
|
---|
| 621 | } In;
|
---|
| 622 | struct
|
---|
| 623 | {
|
---|
| 624 | /** Returned ring-3 address. */
|
---|
| 625 | RTR3PTR pvR3;
|
---|
| 626 | /** The physical addresses of the allocated pages. */
|
---|
| 627 | RTHCPHYS aPages[1];
|
---|
| 628 | } Out;
|
---|
| 629 | } u;
|
---|
| 630 | } SUPPAGEALLOC, *PSUPPAGEALLOC;
|
---|
| 631 | /** @} */
|
---|
[1] | 632 |
|
---|
| 633 |
|
---|
[4800] | 634 | /** @name SUP_IOCTL_PAGE_FREE
|
---|
[14575] | 635 | * Free memory allocated with SUP_IOCTL_PAGE_ALLOC or SUP_IOCTL_PAGE_ALLOC_EX.
|
---|
[4800] | 636 | * @{
|
---|
| 637 | */
|
---|
| 638 | #define SUP_IOCTL_PAGE_FREE SUP_CTL_CODE_SIZE(13, SUP_IOCTL_PAGE_FREE_SIZE_IN)
|
---|
| 639 | #define SUP_IOCTL_PAGE_FREE_SIZE sizeof(SUPPAGEFREE)
|
---|
| 640 | #define SUP_IOCTL_PAGE_FREE_SIZE_IN sizeof(SUPPAGEFREE)
|
---|
| 641 | #define SUP_IOCTL_PAGE_FREE_SIZE_OUT sizeof(SUPREQHDR)
|
---|
| 642 | typedef struct SUPPAGEFREE
|
---|
[1] | 643 | {
|
---|
[4800] | 644 | /** The header. */
|
---|
| 645 | SUPREQHDR Hdr;
|
---|
| 646 | union
|
---|
| 647 | {
|
---|
| 648 | struct
|
---|
| 649 | {
|
---|
| 650 | /** Address of memory range to free. */
|
---|
| 651 | RTR3PTR pvR3;
|
---|
| 652 | } In;
|
---|
| 653 | } u;
|
---|
| 654 | } SUPPAGEFREE, *PSUPPAGEFREE;
|
---|
| 655 | /** @} */
|
---|
[1] | 656 |
|
---|
[4800] | 657 |
|
---|
| 658 | /** @name SUP_IOCTL_PAGE_LOCK
|
---|
| 659 | * Pin down physical pages.
|
---|
| 660 | * @{
|
---|
| 661 | */
|
---|
| 662 | #define SUP_IOCTL_PAGE_LOCK SUP_CTL_CODE_BIG(14)
|
---|
| 663 | #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)))
|
---|
| 664 | #define SUP_IOCTL_PAGE_LOCK_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGELOCK, u.In))
|
---|
[13061] | 665 | #define SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages) RT_UOFFSETOF(SUPPAGELOCK, u.Out.aPages[cPages])
|
---|
[4800] | 666 | typedef struct SUPPAGELOCK
|
---|
[1] | 667 | {
|
---|
[4800] | 668 | /** The header. */
|
---|
| 669 | SUPREQHDR Hdr;
|
---|
| 670 | union
|
---|
| 671 | {
|
---|
| 672 | struct
|
---|
| 673 | {
|
---|
| 674 | /** Start of page range. Must be PAGE aligned. */
|
---|
| 675 | RTR3PTR pvR3;
|
---|
| 676 | /** The range size given as a page count. */
|
---|
| 677 | uint32_t cPages;
|
---|
| 678 | } In;
|
---|
[1] | 679 |
|
---|
[4800] | 680 | struct
|
---|
| 681 | {
|
---|
| 682 | /** Array of pages. */
|
---|
| 683 | RTHCPHYS aPages[1];
|
---|
| 684 | } Out;
|
---|
| 685 | } u;
|
---|
| 686 | } SUPPAGELOCK, *PSUPPAGELOCK;
|
---|
| 687 | /** @} */
|
---|
[1] | 688 |
|
---|
[1840] | 689 |
|
---|
[4800] | 690 | /** @name SUP_IOCTL_PAGE_UNLOCK
|
---|
| 691 | * Unpin physical pages.
|
---|
| 692 | * @{ */
|
---|
| 693 | #define SUP_IOCTL_PAGE_UNLOCK SUP_CTL_CODE_SIZE(15, SUP_IOCTL_PAGE_UNLOCK_SIZE)
|
---|
| 694 | #define SUP_IOCTL_PAGE_UNLOCK_SIZE sizeof(SUPPAGEUNLOCK)
|
---|
| 695 | #define SUP_IOCTL_PAGE_UNLOCK_SIZE_IN sizeof(SUPPAGEUNLOCK)
|
---|
| 696 | #define SUP_IOCTL_PAGE_UNLOCK_SIZE_OUT sizeof(SUPREQHDR)
|
---|
| 697 | typedef struct SUPPAGEUNLOCK
|
---|
[1] | 698 | {
|
---|
[4800] | 699 | /** The header. */
|
---|
| 700 | SUPREQHDR Hdr;
|
---|
| 701 | union
|
---|
| 702 | {
|
---|
| 703 | struct
|
---|
| 704 | {
|
---|
| 705 | /** Start of page range of a range previuosly pinned. */
|
---|
| 706 | RTR3PTR pvR3;
|
---|
| 707 | } In;
|
---|
| 708 | } u;
|
---|
| 709 | } SUPPAGEUNLOCK, *PSUPPAGEUNLOCK;
|
---|
| 710 | /** @} */
|
---|
[1] | 711 |
|
---|
[4800] | 712 |
|
---|
| 713 | /** @name SUP_IOCTL_CONT_ALLOC
|
---|
| 714 | * Allocate contious memory.
|
---|
| 715 | * @{
|
---|
| 716 | */
|
---|
| 717 | #define SUP_IOCTL_CONT_ALLOC SUP_CTL_CODE_SIZE(16, SUP_IOCTL_CONT_ALLOC_SIZE)
|
---|
| 718 | #define SUP_IOCTL_CONT_ALLOC_SIZE sizeof(SUPCONTALLOC)
|
---|
| 719 | #define SUP_IOCTL_CONT_ALLOC_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCONTALLOC, u.In))
|
---|
| 720 | #define SUP_IOCTL_CONT_ALLOC_SIZE_OUT sizeof(SUPCONTALLOC)
|
---|
| 721 | typedef struct SUPCONTALLOC
|
---|
[1] | 722 | {
|
---|
[4800] | 723 | /** The header. */
|
---|
| 724 | SUPREQHDR Hdr;
|
---|
| 725 | union
|
---|
| 726 | {
|
---|
| 727 | struct
|
---|
| 728 | {
|
---|
| 729 | /** The allocation size given as a page count. */
|
---|
| 730 | uint32_t cPages;
|
---|
| 731 | } In;
|
---|
[1] | 732 |
|
---|
[4800] | 733 | struct
|
---|
| 734 | {
|
---|
| 735 | /** The address of the ring-0 mapping of the allocated memory. */
|
---|
| 736 | RTR0PTR pvR0;
|
---|
| 737 | /** The address of the ring-3 mapping of the allocated memory. */
|
---|
| 738 | RTR3PTR pvR3;
|
---|
| 739 | /** The physical address of the allocation. */
|
---|
| 740 | RTHCPHYS HCPhys;
|
---|
| 741 | } Out;
|
---|
| 742 | } u;
|
---|
| 743 | } SUPCONTALLOC, *PSUPCONTALLOC;
|
---|
| 744 | /** @} */
|
---|
[1] | 745 |
|
---|
[1840] | 746 |
|
---|
[4800] | 747 | /** @name SUP_IOCTL_CONT_FREE Input.
|
---|
| 748 | * @{
|
---|
| 749 | */
|
---|
| 750 | /** Free contious memory. */
|
---|
| 751 | #define SUP_IOCTL_CONT_FREE SUP_CTL_CODE_SIZE(17, SUP_IOCTL_CONT_FREE_SIZE)
|
---|
| 752 | #define SUP_IOCTL_CONT_FREE_SIZE sizeof(SUPCONTFREE)
|
---|
| 753 | #define SUP_IOCTL_CONT_FREE_SIZE_IN sizeof(SUPCONTFREE)
|
---|
| 754 | #define SUP_IOCTL_CONT_FREE_SIZE_OUT sizeof(SUPREQHDR)
|
---|
| 755 | typedef struct SUPCONTFREE
|
---|
[1] | 756 | {
|
---|
[4800] | 757 | /** The header. */
|
---|
| 758 | SUPREQHDR Hdr;
|
---|
| 759 | union
|
---|
| 760 | {
|
---|
| 761 | struct
|
---|
| 762 | {
|
---|
| 763 | /** The ring-3 address of the memory to free. */
|
---|
| 764 | RTR3PTR pvR3;
|
---|
| 765 | } In;
|
---|
| 766 | } u;
|
---|
| 767 | } SUPCONTFREE, *PSUPCONTFREE;
|
---|
| 768 | /** @} */
|
---|
[1] | 769 |
|
---|
| 770 |
|
---|
[4800] | 771 | /** @name SUP_IOCTL_GET_PAGING_MODE
|
---|
| 772 | * Get the host paging mode.
|
---|
| 773 | * @{
|
---|
| 774 | */
|
---|
| 775 | #define SUP_IOCTL_GET_PAGING_MODE SUP_CTL_CODE_SIZE(18, SUP_IOCTL_GET_PAGING_MODE_SIZE)
|
---|
| 776 | #define SUP_IOCTL_GET_PAGING_MODE_SIZE sizeof(SUPGETPAGINGMODE)
|
---|
| 777 | #define SUP_IOCTL_GET_PAGING_MODE_SIZE_IN sizeof(SUPREQHDR)
|
---|
| 778 | #define SUP_IOCTL_GET_PAGING_MODE_SIZE_OUT sizeof(SUPGETPAGINGMODE)
|
---|
| 779 | typedef struct SUPGETPAGINGMODE
|
---|
[1] | 780 | {
|
---|
[4800] | 781 | /** The header. */
|
---|
| 782 | SUPREQHDR Hdr;
|
---|
| 783 | union
|
---|
| 784 | {
|
---|
| 785 | struct
|
---|
| 786 | {
|
---|
| 787 | /** The paging mode. */
|
---|
| 788 | SUPPAGINGMODE enmMode;
|
---|
| 789 | } Out;
|
---|
| 790 | } u;
|
---|
| 791 | } SUPGETPAGINGMODE, *PSUPGETPAGINGMODE;
|
---|
| 792 | /** @} */
|
---|
[1] | 793 |
|
---|
| 794 |
|
---|
[4800] | 795 | /** @name SUP_IOCTL_SET_VM_FOR_FAST
|
---|
| 796 | * Set the VM handle for doing fast call ioctl calls.
|
---|
| 797 | * @{
|
---|
| 798 | */
|
---|
| 799 | #define SUP_IOCTL_SET_VM_FOR_FAST SUP_CTL_CODE_SIZE(19, SUP_IOCTL_SET_VM_FOR_FAST_SIZE)
|
---|
| 800 | #define SUP_IOCTL_SET_VM_FOR_FAST_SIZE sizeof(SUPSETVMFORFAST)
|
---|
| 801 | #define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_IN sizeof(SUPSETVMFORFAST)
|
---|
| 802 | #define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_OUT sizeof(SUPREQHDR)
|
---|
| 803 | typedef struct SUPSETVMFORFAST
|
---|
[1] | 804 | {
|
---|
[4800] | 805 | /** The header. */
|
---|
| 806 | SUPREQHDR Hdr;
|
---|
| 807 | union
|
---|
| 808 | {
|
---|
| 809 | struct
|
---|
| 810 | {
|
---|
| 811 | /** The ring-0 VM handle (pointer). */
|
---|
| 812 | PVMR0 pVMR0;
|
---|
| 813 | } In;
|
---|
| 814 | } u;
|
---|
| 815 | } SUPSETVMFORFAST, *PSUPSETVMFORFAST;
|
---|
| 816 | /** @} */
|
---|
[1] | 817 |
|
---|
| 818 |
|
---|
[4800] | 819 | /** @name SUP_IOCTL_GIP_MAP
|
---|
| 820 | * Map the GIP into user space.
|
---|
| 821 | * @{
|
---|
| 822 | */
|
---|
| 823 | #define SUP_IOCTL_GIP_MAP SUP_CTL_CODE_SIZE(20, SUP_IOCTL_GIP_MAP_SIZE)
|
---|
| 824 | #define SUP_IOCTL_GIP_MAP_SIZE sizeof(SUPGIPMAP)
|
---|
| 825 | #define SUP_IOCTL_GIP_MAP_SIZE_IN sizeof(SUPREQHDR)
|
---|
| 826 | #define SUP_IOCTL_GIP_MAP_SIZE_OUT sizeof(SUPGIPMAP)
|
---|
| 827 | typedef struct SUPGIPMAP
|
---|
[1] | 828 | {
|
---|
[4800] | 829 | /** The header. */
|
---|
| 830 | SUPREQHDR Hdr;
|
---|
| 831 | union
|
---|
| 832 | {
|
---|
| 833 | struct
|
---|
| 834 | {
|
---|
| 835 | /** The physical address of the GIP. */
|
---|
| 836 | RTHCPHYS HCPhysGip;
|
---|
| 837 | /** Pointer to the read-only usermode GIP mapping for this session. */
|
---|
| 838 | R3PTRTYPE(PSUPGLOBALINFOPAGE) pGipR3;
|
---|
| 839 | /** Pointer to the supervisor mode GIP mapping. */
|
---|
| 840 | R0PTRTYPE(PSUPGLOBALINFOPAGE) pGipR0;
|
---|
| 841 | } Out;
|
---|
| 842 | } u;
|
---|
| 843 | } SUPGIPMAP, *PSUPGIPMAP;
|
---|
| 844 | /** @} */
|
---|
[1] | 845 |
|
---|
[4755] | 846 |
|
---|
[4800] | 847 | /** @name SUP_IOCTL_GIP_UNMAP
|
---|
| 848 | * Unmap the GIP.
|
---|
| 849 | * @{
|
---|
| 850 | */
|
---|
| 851 | #define SUP_IOCTL_GIP_UNMAP SUP_CTL_CODE_SIZE(21, SUP_IOCTL_GIP_UNMAP_SIZE)
|
---|
| 852 | #define SUP_IOCTL_GIP_UNMAP_SIZE sizeof(SUPGIPUNMAP)
|
---|
| 853 | #define SUP_IOCTL_GIP_UNMAP_SIZE_IN sizeof(SUPGIPUNMAP)
|
---|
| 854 | #define SUP_IOCTL_GIP_UNMAP_SIZE_OUT sizeof(SUPGIPUNMAP)
|
---|
| 855 | typedef struct SUPGIPUNMAP
|
---|
[4755] | 856 | {
|
---|
[4800] | 857 | /** The header. */
|
---|
| 858 | SUPREQHDR Hdr;
|
---|
| 859 | } SUPGIPUNMAP, *PSUPGIPUNMAP;
|
---|
| 860 | /** @} */
|
---|
[4755] | 861 |
|
---|
| 862 |
|
---|
[14332] | 863 | /** @name SUP_IOCTL_CALL_SERVICE
|
---|
| 864 | * Call the a ring-0 service.
|
---|
| 865 | *
|
---|
| 866 | * @todo Might have to convert this to a big request, just like
|
---|
| 867 | * SUP_IOCTL_CALL_VMMR0
|
---|
| 868 | * @{
|
---|
| 869 | */
|
---|
| 870 | #define SUP_IOCTL_CALL_SERVICE(cbReq) SUP_CTL_CODE_SIZE(22, SUP_IOCTL_CALL_SERVICE_SIZE(cbReq))
|
---|
| 871 | #define SUP_IOCTL_CALL_SERVICE_SIZE(cbReq) RT_UOFFSETOF(SUPCALLSERVICE, abReqPkt[cbReq])
|
---|
| 872 | #define SUP_IOCTL_CALL_SERVICE_SIZE_IN(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
|
---|
| 873 | #define SUP_IOCTL_CALL_SERVICE_SIZE_OUT(cbReq) SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
|
---|
| 874 | typedef struct SUPCALLSERVICE
|
---|
| 875 | {
|
---|
| 876 | /** The header. */
|
---|
| 877 | SUPREQHDR Hdr;
|
---|
| 878 | union
|
---|
| 879 | {
|
---|
| 880 | struct
|
---|
| 881 | {
|
---|
| 882 | /** The service name. */
|
---|
| 883 | char szName[28];
|
---|
| 884 | /** Which operation to execute. */
|
---|
| 885 | uint32_t uOperation;
|
---|
| 886 | /** Argument to use when no request packet is supplied. */
|
---|
| 887 | uint64_t u64Arg;
|
---|
| 888 | } In;
|
---|
| 889 | } u;
|
---|
| 890 | /** The request packet passed to SUP. */
|
---|
| 891 | uint8_t abReqPkt[1];
|
---|
| 892 | } SUPCALLSERVICE, *PSUPCALLSERVICE;
|
---|
| 893 | /** @} */
|
---|
| 894 |
|
---|
[14575] | 895 | /** @name SUP_IOCTL_PAGE_ALLOC_EX
|
---|
| 896 | * Allocate memory and map it into kernel and/or user space. The memory is of
|
---|
| 897 | * course locked. This is an extended version of SUP_IOCTL_PAGE_ALLOC and the
|
---|
| 898 | * result should be freed using SUP_IOCTL_PAGE_FREE.
|
---|
| 899 | *
|
---|
| 900 | * @remarks Allocations without a kernel mapping may fail with
|
---|
| 901 | * VERR_NOT_SUPPORTED on some platforms just like with
|
---|
| 902 | * SUP_IOCTL_PAGE_ALLOC.
|
---|
| 903 | *
|
---|
| 904 | * @{
|
---|
| 905 | */
|
---|
[18191] | 906 | #define SUP_IOCTL_PAGE_ALLOC_EX SUP_CTL_CODE_BIG(23)
|
---|
| 907 | #define SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages) RT_UOFFSETOF(SUPPAGEALLOCEX, u.Out.aPages[cPages])
|
---|
| 908 | #define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_IN (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGEALLOCEX, u.In))
|
---|
| 909 | #define SUP_IOCTL_PAGE_ALLOC_EX_SIZE_OUT(cPages) SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages)
|
---|
[14575] | 910 | typedef struct SUPPAGEALLOCEX
|
---|
| 911 | {
|
---|
| 912 | /** The header. */
|
---|
| 913 | SUPREQHDR Hdr;
|
---|
| 914 | union
|
---|
| 915 | {
|
---|
| 916 | struct
|
---|
| 917 | {
|
---|
| 918 | /** Number of pages to allocate */
|
---|
| 919 | uint32_t cPages;
|
---|
| 920 | /** Whether it should have kernel mapping. */
|
---|
| 921 | bool fKernelMapping;
|
---|
| 922 | /** Whether it should have a user mapping. */
|
---|
| 923 | bool fUserMapping;
|
---|
| 924 | /** Reserved. Must be false. */
|
---|
| 925 | bool fReserved0;
|
---|
| 926 | /** Reserved. Must be false. */
|
---|
| 927 | bool fReserved1;
|
---|
| 928 | } In;
|
---|
| 929 | struct
|
---|
| 930 | {
|
---|
| 931 | /** Returned ring-3 address. */
|
---|
| 932 | RTR3PTR pvR3;
|
---|
| 933 | /** Returned ring-0 address. */
|
---|
| 934 | RTR0PTR pvR0;
|
---|
| 935 | /** The physical addresses of the allocated pages. */
|
---|
| 936 | RTHCPHYS aPages[1];
|
---|
| 937 | } Out;
|
---|
| 938 | } u;
|
---|
| 939 | } SUPPAGEALLOCEX, *PSUPPAGEALLOCEX;
|
---|
| 940 | /** @} */
|
---|
[14332] | 941 |
|
---|
[14575] | 942 |
|
---|
[14825] | 943 | /** @name SUP_IOCTL_PAGE_MAP_KERNEL
|
---|
| 944 | * Maps a portion of memory allocated by SUP_IOCTL_PAGE_ALLOC_EX /
|
---|
| 945 | * SUPR0PageAllocEx into kernel space for use by a device or similar.
|
---|
| 946 | *
|
---|
| 947 | * The mapping will be freed together with the ring-3 mapping when
|
---|
| 948 | * SUP_IOCTL_PAGE_FREE or SUPR0PageFree is called.
|
---|
| 949 | *
|
---|
| 950 | * @remarks Not necessarily supported on all platforms.
|
---|
| 951 | *
|
---|
| 952 | * @{
|
---|
| 953 | */
|
---|
[18191] | 954 | #define SUP_IOCTL_PAGE_MAP_KERNEL SUP_CTL_CODE_SIZE(24, SUP_IOCTL_PAGE_MAP_KERNEL_SIZE)
|
---|
| 955 | #define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE sizeof(SUPPAGEMAPKERNEL)
|
---|
| 956 | #define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_IN sizeof(SUPPAGEMAPKERNEL)
|
---|
| 957 | #define SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_OUT sizeof(SUPPAGEMAPKERNEL)
|
---|
[14825] | 958 | typedef struct SUPPAGEMAPKERNEL
|
---|
| 959 | {
|
---|
| 960 | /** The header. */
|
---|
| 961 | SUPREQHDR Hdr;
|
---|
| 962 | union
|
---|
| 963 | {
|
---|
| 964 | struct
|
---|
| 965 | {
|
---|
| 966 | /** The pointer of to the previously allocated memory. */
|
---|
| 967 | RTR3PTR pvR3;
|
---|
| 968 | /** The offset to start mapping from. */
|
---|
| 969 | uint32_t offSub;
|
---|
| 970 | /** Size of the section to map. */
|
---|
| 971 | uint32_t cbSub;
|
---|
| 972 | /** Flags reserved for future fun. */
|
---|
| 973 | uint32_t fFlags;
|
---|
| 974 | } In;
|
---|
| 975 | struct
|
---|
| 976 | {
|
---|
| 977 | /** The ring-0 address corresponding to pvR3 + offSub. */
|
---|
| 978 | RTR0PTR pvR0;
|
---|
| 979 | } Out;
|
---|
| 980 | } u;
|
---|
| 981 | } SUPPAGEMAPKERNEL, *PSUPPAGEMAPKERNEL;
|
---|
| 982 | /** @} */
|
---|
| 983 |
|
---|
| 984 |
|
---|
[18191] | 985 | /** @name SUP_IOCTL_LOGGER_SETTINGS
|
---|
| 986 | * Changes the ring-0 release or debug logger settings.
|
---|
| 987 | * @{
|
---|
| 988 | */
|
---|
| 989 | #define SUP_IOCTL_LOGGER_SETTINGS(cbStrTab) SUP_CTL_CODE_SIZE(25, SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab))
|
---|
| 990 | #define SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab) RT_UOFFSETOF(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
|
---|
| 991 | #define SUP_IOCTL_LOGGER_SETTINGS_SIZE_IN(cbStrTab) RT_UOFFSETOF(SUPLOGGERSETTINGS, u.In.szStrings[cbStrTab])
|
---|
| 992 | #define SUP_IOCTL_LOGGER_SETTINGS_SIZE_OUT sizeof(SUPREQHDR)
|
---|
| 993 | typedef struct SUPLOGGERSETTINGS
|
---|
| 994 | {
|
---|
| 995 | /** The header. */
|
---|
| 996 | SUPREQHDR Hdr;
|
---|
| 997 | union
|
---|
| 998 | {
|
---|
| 999 | struct
|
---|
| 1000 | {
|
---|
| 1001 | /** Which logger. */
|
---|
| 1002 | uint32_t fWhich;
|
---|
| 1003 | /** What to do with it. */
|
---|
| 1004 | uint32_t fWhat;
|
---|
| 1005 | /** Offset of the flags setting string. */
|
---|
| 1006 | uint32_t offFlags;
|
---|
| 1007 | /** Offset of the groups setting string. */
|
---|
| 1008 | uint32_t offGroups;
|
---|
| 1009 | /** Offset of the destination setting string. */
|
---|
| 1010 | uint32_t offDestination;
|
---|
| 1011 | /** The string table. */
|
---|
| 1012 | char szStrings[1];
|
---|
| 1013 | } In;
|
---|
| 1014 | } u;
|
---|
| 1015 | } SUPLOGGERSETTINGS, *PSUPLOGGERSETTINGS;
|
---|
| 1016 |
|
---|
| 1017 | /** Debug logger. */
|
---|
| 1018 | #define SUPLOGGERSETTINGS_WHICH_DEBUG 0
|
---|
| 1019 | /** Release logger. */
|
---|
| 1020 | #define SUPLOGGERSETTINGS_WHICH_RELEASE 1
|
---|
| 1021 |
|
---|
| 1022 | /** Change the settings. */
|
---|
| 1023 | #define SUPLOGGERSETTINGS_WHAT_SETTINGS 0
|
---|
| 1024 | /** Create the logger instance. */
|
---|
| 1025 | #define SUPLOGGERSETTINGS_WHAT_CREATE 1
|
---|
| 1026 | /** Destroy the logger instance. */
|
---|
| 1027 | #define SUPLOGGERSETTINGS_WHAT_DESTROY 2
|
---|
| 1028 |
|
---|
| 1029 | /** @} */
|
---|
| 1030 |
|
---|
| 1031 |
|
---|
[1] | 1032 | #pragma pack() /* paranoia */
|
---|
| 1033 |
|
---|
| 1034 | #endif
|
---|
| 1035 |
|
---|