VirtualBox

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

Last change on this file since 14825 was 14825, checked in by vboxsync, 16 years ago

SUPDrv: Permit userland to make kernel mappings of SUPR0PageAllocEx allocations. (darwin + VGA + VT-x, #1865/#3202)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 32.7 KB
Line 
1/* $Revision: 14825 $ */
2/** @file
3 * VirtualBox Support Driver - IOCtl definitions.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
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 * 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.
29 */
30
31#ifndef ___SUPDrvIOC_h___
32#define ___SUPDrvIOC_h___
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 */
45#ifdef RT_ARCH_AMD64
46# define SUP_IOCTL_FLAG 128
47#elif defined(RT_ARCH_X86)
48# define SUP_IOCTL_FLAG 0
49#else
50# error "dunno which arch this is!"
51#endif
52
53#ifdef RT_OS_WINDOWS
54# ifndef CTL_CODE
55# include <Windows.h>
56# endif
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)
62
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))
67# define SUP_CTL_CODE_BIG(Function) _IOWRN('V', (Function) | SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
68# define SUP_CTL_CODE_FAST(Function) _IO( 'V', (Function) | SUP_IOCTL_FLAG)
69# define SUP_CTL_CODE_NO_SIZE(uIOCtl) (uIOCtl)
70
71#elif defined(RT_OS_OS2)
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)
79
80#elif defined(RT_OS_LINUX)
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)
87
88#elif defined(RT_OS_L4)
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)
94
95#else /* BSD Like */
96 /* Automatic buffering, size limited to 4KB on *BSD and 8KB on Darwin - commands the limit, 4KB. */
97# include <sys/ioccom.h>
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) )
102#endif
103
104/** Fast path IOCtl: VMMR0_DO_RAW_RUN */
105#define SUP_IOCTL_FAST_DO_RAW_RUN SUP_CTL_CODE_FAST(64)
106/** Fast path IOCtl: VMMR0_DO_HWACC_RUN */
107#define SUP_IOCTL_FAST_DO_HWACC_RUN SUP_CTL_CODE_FAST(65)
108/** Just a NOP call for profiling the latency of a fast ioctl call to VMMR0. */
109#define SUP_IOCTL_FAST_DO_NOP SUP_CTL_CODE_FAST(66)
110
111
112
113/*******************************************************************************
114* Structures and Typedefs *
115*******************************************************************************/
116#ifdef RT_ARCH_AMD64
117# pragma pack(8) /* paranoia. */
118#else
119# pragma pack(4) /* paranoia. */
120#endif
121
122
123/**
124 * Common In/Out header.
125 */
126typedef struct SUPREQHDR
127{
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. */
142typedef SUPREQHDR *PSUPREQHDR;
143
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)
152
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)
176/** SUPCOOKIE_IN magic word. */
177#define SUPCOOKIE_MAGIC "The Magic Word!"
178/** The initial cookie. */
179#define SUPCOOKIE_INITIAL_COOKIE 0x69726f74 /* 'tori' */
180
181/** Current interface version.
182 * The upper 16-bit is the major version, the the lower the minor version.
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 */
190#define SUPDRV_IOC_VERSION 0x000a0006
191
192/** SUP_IOCTL_COOKIE. */
193typedef struct SUPCOOKIE
194{
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/** @} */
228
229
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))
235#define SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs) RT_UOFFSETOF(SUPQUERYFUNCS, u.Out.aFunctions[(cFuncs)])
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)
238
239/** A function. */
240typedef struct SUPFUNC
241{
242 /** Name - mangled. */
243 char szName[32];
244 /** Address. */
245 RTR0PTR pfn;
246} SUPFUNC, *PSUPFUNC;
247
248typedef struct SUPQUERYFUNCS
249{
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/** @} */
264
265
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)
274typedef struct SUPIDTINSTALL
275{
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/** @} */
288
289
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)
298typedef struct SUPIDTREMOVE
299{
300 /** The header. */
301 SUPREQHDR Hdr;
302} SUPIDTREMOVE, *PSUPIDTREMOVE;
303/** @}*/
304
305
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))
314typedef struct SUPLDROPEN
315{
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/** @} */
339
340
341/** @name SUP_IOCTL_LDR_LOAD
342 * Upload the image bits.
343 * @{
344 */
345#define SUP_IOCTL_LDR_LOAD SUP_CTL_CODE_BIG(6)
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])
348#define SUP_IOCTL_LDR_LOAD_SIZE_OUT sizeof(SUPREQHDR)
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 */
357typedef DECLCALLBACK(int) FNR0MODULEINIT(void);
358/** Pointer to a FNR0MODULEINIT(). */
359typedef R0PTRTYPE(FNR0MODULEINIT *) PFNR0MODULEINIT;
360
361/**
362 * Module termination callback function.
363 * This is called once right before the module is being unloaded.
364 */
365typedef DECLCALLBACK(void) FNR0MODULETERM(void);
366/** Pointer to a FNR0MODULETERM(). */
367typedef R0PTRTYPE(FNR0MODULETERM *) PFNR0MODULETERM;
368
369/**
370 * Symbol table entry.
371 */
372typedef 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;
378} SUPLDRSYM;
379/** Pointer to a symbol table entry. */
380typedef SUPLDRSYM *PSUPLDRSYM;
381/** Pointer to a const symbol table entry. */
382typedef SUPLDRSYM const *PCSUPLDRSYM;
383
384/**
385 * SUPLDRLOAD::u::In::EP type.
386 */
387typedef enum SUPLDRLOADEP
388{
389 SUPLDRLOADEP_NOTHING = 0,
390 SUPLDRLOADEP_VMMR0,
391 SUPLDRLOADEP_SERVICE,
392 SUPLDRLOADEP_32BIT_HACK = 0x7fffffff
393} SUPLDRLOADEP;
394
395typedef struct SUPLDRLOAD
396{
397 /** The header. */
398 SUPREQHDR Hdr;
399 union
400 {
401 struct
402 {
403 /** The address of module initialization function. Similar to _DLL_InitTerm(hmod, 0). */
404 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 {
410 /** SUPLDRLOADEP_VMMR0. */
411 struct
412 {
413 /** The module handle (i.e. address). */
414 RTR0PTR pvVMMR0;
415 /** Address of VMMR0EntryInt function. */
416 RTR0PTR pvVMMR0EntryInt;
417 /** Address of VMMR0EntryFast function. */
418 RTR0PTR pvVMMR0EntryFast;
419 /** Address of VMMR0EntryEx function. */
420 RTR0PTR pvVMMR0EntryEx;
421 } VMMR0;
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;
431 } EP;
432 /** Address. */
433 RTR0PTR pvImageBase;
434 /** Entry point type. */
435 SUPLDRLOADEP eEPType;
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/** @} */
452
453
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)
462typedef 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/** @} */
476
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))
486typedef struct SUPLDRGETSYMBOL
487{
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/** @} */
507
508
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))
516#define SUP_IOCTL_CALL_VMMR0_SIZE(cbReq) RT_UOFFSETOF(SUPCALLVMMR0, abReqPkt[cbReq])
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)
519typedef struct SUPCALLVMMR0
520{
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. */
536 uint64_t u64Arg;
537 } In;
538 } u;
539 /** The VMMR0Entry request packet. */
540 uint8_t abReqPkt[1];
541} SUPCALLVMMR0, *PSUPCALLVMMR0;
542/** @} */
543
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)
550#define SUP_IOCTL_LOW_ALLOC_SIZE(cPages) ((uint32_t)RT_UOFFSETOF(SUPLOWALLOC, u.Out.aPages[cPages]))
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)
553typedef struct SUPLOWALLOC
554{
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/** @} */
576
577
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)
586typedef struct SUPLOWFREE
587{
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/** @} */
600
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)
608#define SUP_IOCTL_PAGE_ALLOC_SIZE(cPages) RT_UOFFSETOF(SUPPAGEALLOC, u.Out.aPages[cPages])
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)
611typedef struct SUPPAGEALLOC
612{
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/** @} */
632
633
634/** @name SUP_IOCTL_PAGE_FREE
635 * Free memory allocated with SUP_IOCTL_PAGE_ALLOC or SUP_IOCTL_PAGE_ALLOC_EX.
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)
642typedef struct SUPPAGEFREE
643{
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/** @} */
656
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))
665#define SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages) RT_UOFFSETOF(SUPPAGELOCK, u.Out.aPages[cPages])
666typedef struct SUPPAGELOCK
667{
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;
679
680 struct
681 {
682 /** Array of pages. */
683 RTHCPHYS aPages[1];
684 } Out;
685 } u;
686} SUPPAGELOCK, *PSUPPAGELOCK;
687/** @} */
688
689
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)
697typedef struct SUPPAGEUNLOCK
698{
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/** @} */
711
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)
721typedef struct SUPCONTALLOC
722{
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;
732
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/** @} */
745
746
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)
755typedef struct SUPCONTFREE
756{
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/** @} */
769
770
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)
779typedef struct SUPGETPAGINGMODE
780{
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/** @} */
793
794
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)
803typedef struct SUPSETVMFORFAST
804{
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/** @} */
817
818
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)
827typedef struct SUPGIPMAP
828{
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/** @} */
845
846
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)
855typedef struct SUPGIPUNMAP
856{
857 /** The header. */
858 SUPREQHDR Hdr;
859} SUPGIPUNMAP, *PSUPGIPUNMAP;
860/** @} */
861
862
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)
874typedef 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
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 */
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)
910typedef 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/** @} */
941
942
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 */
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)
958typedef 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
985#pragma pack() /* paranoia */
986
987#endif
988
Note: See TracBrowser for help on using the repository browser.

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