VirtualBox

Ignore:
Timestamp:
Sep 14, 2007 2:59:15 PM (17 years ago)
Author:
vboxsync
Message:

Redid the supdrv interface. works on windows and linux while the other OSes still needs some adjusting/testing. internal networking is temporarily broken as the SUPCallVMMR0Ex interface is being reworked (this is what all this is really about).

Location:
trunk/src/VBox/HostDrivers/Support
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostDrivers/Support/SUPDRV.h

    r4755 r4800  
    198198
    199199/* dprintf */
    200 #if (defined(DEBUG) && !defined(NO_LOGGING)) || defined(RT_OS_FREEBSD)
     200/* bird debugging - #if (defined(DEBUG) && !defined(NO_LOGGING)) || defined(RT_OS_FREEBSD)
    201201# ifdef LOG_TO_COM
    202202#  include <VBox/log.h>
    203203#  define dprintf(a) RTLogComPrintf a
    204 # else
     204# else */
    205205#  define dprintf(a) OSDBGPRINT(a)
    206 # endif
     206/*# endif
    207207#else
    208208# define dprintf(a) do {} while (0)
    209 #endif
     209#endif*/
    210210
    211211/* dprintf2 - extended logging. */
    212 #if defined(RT_OS_DARWIN) || defined(RT_OS_OS2) || defined(RT_OS_FREEBSD)
     212#if 1//bird defined(RT_OS_DARWIN) || defined(RT_OS_OS2) || defined(RT_OS_FREEBSD)
    213213# define dprintf2 dprintf
    214214#else
    … …  
    735735*   Shared Functions                                                           *
    736736*******************************************************************************/
    737 int  VBOXCALL   supdrvIOCtl(unsigned uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession,
    738                             void *pvIn, unsigned cbIn, void *pvOut, unsigned cbOut, unsigned *pcbReturned);
     737int  VBOXCALL   supdrvIOCtl(uintptr_t uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPREQHDR pReqHdr);
    739738#ifdef VBOX_WITHOUT_IDT_PATCHING
    740 int  VBOXCALL   supdrvIOCtlFast(unsigned uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession);
     739int  VBOXCALL   supdrvIOCtlFast(uintptr_t uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession);
    741740#endif
    742741int  VBOXCALL   supdrvInitDevExt(PSUPDRVDEVEXT pDevExt);
    743 int VBOXCALL   supdrvDeleteDevExt(PSUPDRVDEVEXT pDevExt);
     742void VBOXCALL   supdrvDeleteDevExt(PSUPDRVDEVEXT pDevExt);
    744743int  VBOXCALL   supdrvCreateSession(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION *ppSession);
    745744void VBOXCALL   supdrvCloseSession(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession);

  • trunk/src/VBox/HostDrivers/Support/SUPDRVIOC.h

    r4755 r4800  
    1616 */
    1717
    18 #ifndef __SUPDRVIOC_h__
    19 #define __SUPDRVIOC_h__
     18#ifndef ___SUPDRVIOC_h___
     19#define ___SUPDRVIOC_h___
    2020
    2121/*
    … …  
    3939
    4040#ifdef RT_OS_WINDOWS
    41 # define SUP_CTL_CODE(Function)         CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) | SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
    42 # define SUP_CTL_CODE_FAST(Function)    CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) | SUP_IOCTL_FLAG, METHOD_NEITHER, FILE_WRITE_ACCESS)
    43 
    44 /** @todo get rid of this duplication of window header #defines! */
    4541# ifndef CTL_CODE
    46 #  define CTL_CODE(DeviceType, Function, Method, Access) \
    47     ( ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) )
     42#  include <Windows.h>
    4843# endif
    49 # ifndef METHOD_BUFFERED
    50 #  define METHOD_BUFFERED        0
    51 # endif
    52 # ifndef METHOD_NEITHER
    53 #  define METHOD_NEITHER         3
    54 # endif
    55 # ifndef FILE_WRITE_ACCESS
    56 #  define FILE_WRITE_ACCESS      0x0002
    57 # endif
    58 # ifndef FILE_DEVICE_UNKNOWN
    59 #  define FILE_DEVICE_UNKNOWN    0x00000022
    60 # endif
     44  /* Automatic buffering, size not encoded. */
     45# define SUP_CTL_CODE_SIZE(Function, Size)      CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) | SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
     46# define SUP_CTL_CODE_BIG(Function)             CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) | SUP_IOCTL_FLAG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
     47# define SUP_CTL_CODE_FAST(Function)            CTL_CODE(FILE_DEVICE_UNKNOWN, (Function) | SUP_IOCTL_FLAG, METHOD_NEITHER,  FILE_WRITE_ACCESS)
     48# define SUP_CTL_CODE_NO_SIZE(uIOCtl)           (uIOCtl)
     49
     50#elif defined(RT_OS_SOLARIS)
     51  /* No automatic buffering, size limited to 255 bytes. */
     52# include <sys/ioccom.h>
     53# define SUP_CTL_CODE_SIZE(Function, Size)      _IOWRN('V', (Function) | SUP_IOCTL_FLAG, sizeof(SUPREQHDR))
     54# define SUP_CTL_CODE_BIG(Function)             _IO(   'V', (Function) | SUP_IOCTL_FLAG)
     55# define SUP_CTL_CODE_FAST(Function)            _IO(   'V', (Function) | SUP_IOCTL_FLAG)
     56# define SUP_CTL_CODE_NO_SIZE(uIOCtl)           (uIOCtl)
    6157
    6258#elif defined(RT_OS_OS2)
    63 # define SUP_CTL_CATEGORY               0xc0
    64 # define SUP_CTL_CODE(Function)         ((unsigned char)(Function))
    65 # define SUP_CTL_CATEGORY_FAST          0xc1
    66 # define SUP_CTL_CODE_FAST(Function)    ((unsigned char)(Function))
     59  /* No automatic buffering, size not encoded. */
     60# define SUP_CTL_CATEGORY                       0xc0
     61# define SUP_CTL_CODE_SIZE(Function, Size)      ((unsigned char)(Function))
     62# define SUP_CTL_CODE_BIG(Function)             ((unsigned char)(Function))
     63# define SUP_CTL_CATEGORY_FAST                  0xc1
     64# define SUP_CTL_CODE_FAST(Function)            ((unsigned char)(Function))
     65# define SUP_CTL_CODE_NO_SIZE(uIOCtl)           (uIOCtl)
    6766
    6867#elif defined(RT_OS_LINUX)
    69 # ifdef RT_ARCH_X86 /** @todo With the next major version change, drop this branch. */
    70 #  define SUP_CTL_CODE(Function) \
    71     ( (3U << 30) | ((0x22) << 8) | ((Function) | SUP_IOCTL_FLAG) | (sizeof(SUPDRVIOCTLDATA) << 16) )
    72 #  define SUP_CTL_CODE_FAST(Function) \
    73     ( (3U << 30) | ((0x22) << 8) | ((Function) | SUP_IOCTL_FLAG) | (0 << 16) )
    74 # else
    75 #  include <linux/ioctl.h>
    76 #  if 1 /* figure out when this changed. */
    77 #   define SUP_CTL_CODE(Function)         _IOWR('V', (Function) | SUP_IOCTL_FLAG, SUPDRVIOCTLDATA)
    78 #   define SUP_CTL_CODE_FAST(Function)    _IO(  'V', (Function) | SUP_IOCTL_FLAG)
    79 #  else /* now: _IO_BAD and _IOWR_BAD */
    80 #   define SUP_CTL_CODE(Function)         _IOWR('V', (Function) | SUP_IOCTL_FLAG, sizeof(SUPDRVIOCTLDATA))
    81 #   define SUP_CTL_CODE_FAST(Function)    _IO(  'V', (Function) | SUP_IOCTL_FLAG)
    82 #  endif
    83 # endif
     68  /* No automatic buffering, size limited to 16KB. */
     69# include <linux/ioctl.h>
     70# define SUP_CTL_CODE_SIZE(Function, Size)      _IOC(_IOC_READ | _IOC_WRITE, 'V', (Function) | SUP_IOCTL_FLAG, (Size))
     71# define SUP_CTL_CODE_BIG(Function)             _IO('V', (Function) | SUP_IOCTL_FLAG)
     72# define SUP_CTL_CODE_FAST(Function)            _IO('V', (Function) | SUP_IOCTL_FLAG)
     73# define SUP_CTL_CODE_NO_SIZE(uIOCtl)           ((uIOCtl) & ~IOCSIZE_MASK)
    8474
    8575#elif defined(RT_OS_L4)
    86 # define SUP_CTL_CODE(Function) \
    87     ( (3U << 30) | ((0x22) << 8) | ((Function) | SUP_IOCTL_FLAG) | (sizeof(SUPDRVIOCTLDATA) << 16) )
    88 # define SUP_CTL_CODE_FAST(Function) \
    89     ( (3U << 30) | ((0x22) << 8) | ((Function) | SUP_IOCTL_FLAG) | (0 << 16) )
    90 
    91 #else /* BSD */
     76  /* Implemented in suplib, no worries. */
     77# define SUP_CTL_CODE_SIZE(Function, Size)      (Function)
     78# define SUP_CTL_CODE_BIG(Function)             (Function)
     79# define SUP_CTL_CODE_FAST(Function)            (Function)
     80# define SUP_CTL_CODE_NO_SIZE(uIOCtl)           (uIOCtl)
     81
     82#else /* BSD Like */
     83  /* Automatic buffering, size limited to 4KB on *BSD and 8KB on Darwin - commands the limit, 4KB. */
    9284# include <sys/ioccom.h>
    93 # define SUP_CTL_CODE(Function)         _IOWR('V', (Function) | SUP_IOCTL_FLAG, SUPDRVIOCTLDATA)
    94 # define SUP_CTL_CODE_FAST(Function)    _IO(  'V', (Function) | SUP_IOCTL_FLAG)
     85# define SUP_CTL_CODE_SIZE(Function, Size)      _IOC(IOC_INOUT, 'V', (Function) | SUP_IOCTL_FLAG, (Size))
     86# define SUP_CTL_CODE_BIG(Function)             _IO('V', (Function) | SUP_IOCTL_FLAG)
     87# define SUP_CTL_CODE_FAST(Function)            _IO('V', (Function) | SUP_IOCTL_FLAG)
     88# define SUP_CTL_CODE_NO_SIZE(uIOCtl)           ( (uIOCtl) & ~_IOC(0,0,0,IOCPARM_MASK) )
    9589#endif
    9690
    97 
    98 /** Negotiate cookie. */
    99 #define SUP_IOCTL_COOKIE            SUP_CTL_CODE( 1)
    100 /** Query SUPR0 functions. */
    101 #define SUP_IOCTL_QUERY_FUNCS       SUP_CTL_CODE( 2)
    102 /** Install IDT patch for calling processor. */
    103 #define SUP_IOCTL_IDT_INSTALL       SUP_CTL_CODE( 3)
    104 /** Remove IDT patch for calling processor. */
    105 #define SUP_IOCTL_IDT_REMOVE        SUP_CTL_CODE( 4)
    106 /** Pin down physical pages. */
    107 #define SUP_IOCTL_PINPAGES          SUP_CTL_CODE( 5)
    108 /** Unpin physical pages. */
    109 #define SUP_IOCTL_UNPINPAGES        SUP_CTL_CODE( 6)
    110 /** Allocate contious memory. */
    111 #define SUP_IOCTL_CONT_ALLOC        SUP_CTL_CODE( 7)
    112 /** Free contious memory. */
    113 #define SUP_IOCTL_CONT_FREE         SUP_CTL_CODE( 8)
    114 /** Open an image. */
    115 #define SUP_IOCTL_LDR_OPEN          SUP_CTL_CODE( 9)
    116 /** Upload the image bits. */
    117 #define SUP_IOCTL_LDR_LOAD          SUP_CTL_CODE(10)
    118 /** Free an image. */
    119 #define SUP_IOCTL_LDR_FREE          SUP_CTL_CODE(11)
    120 /** Get address of a symbol within an image. */
    121 #define SUP_IOCTL_LDR_GET_SYMBOL    SUP_CTL_CODE(12)
    122 /** Call the R0 VMM Entry point. */
    123 #define SUP_IOCTL_CALL_VMMR0        SUP_CTL_CODE(14)
    124 /** Get the host paging mode. */
    125 #define SUP_IOCTL_GET_PAGING_MODE   SUP_CTL_CODE(15)
    126 /** Allocate memory below 4GB (physically). */
    127 #define SUP_IOCTL_LOW_ALLOC         SUP_CTL_CODE(16)
    128 /** Free low memory. */
    129 #define SUP_IOCTL_LOW_FREE          SUP_CTL_CODE(17)
    130 /** Map the GIP into user space. */
    131 #define SUP_IOCTL_GIP_MAP           SUP_CTL_CODE(18)
    132 /** Unmap the GIP. */
    133 #define SUP_IOCTL_GIP_UNMAP         SUP_CTL_CODE(19)
    134 /** Set the VM handle for doing fast call ioctl calls. */
    135 #define SUP_IOCTL_SET_VM_FOR_FAST   SUP_CTL_CODE(20)
    136 /** Allocate memory and map into the user process. */
    137 #define SUP_IOCTL_PAGE_ALLOC        SUP_CTL_CODE(21)
    138 /** Free memory allocated with SUP_IOCTL_PAGE_ALLOC. */
    139 #define SUP_IOCTL_PAGE_FREE         SUP_CTL_CODE(22)
    140 
    14191/** Fast path IOCtl: VMMR0_DO_RAW_RUN */
    142 #define SUP_IOCTL_FAST_DO_RAW_RUN   SUP_CTL_CODE_FAST(64)
     92#define SUP_IOCTL_FAST_DO_RAW_RUN               SUP_CTL_CODE_FAST(64)
    14393/** Fast path IOCtl: VMMR0_DO_HWACC_RUN */
    144 #define SUP_IOCTL_FAST_DO_HWACC_RUN SUP_CTL_CODE_FAST(65)
     94#define SUP_IOCTL_FAST_DO_HWACC_RUN             SUP_CTL_CODE_FAST(65)
    14595/** Just a NOP call for profiling the latency of a fast ioctl call to VMMR0. */
    146 #define SUP_IOCTL_FAST_DO_NOP       SUP_CTL_CODE_FAST(66)
     96#define SUP_IOCTL_FAST_DO_NOP                   SUP_CTL_CODE_FAST(66)
     97
    14798
    14899
    … …  
    156107#endif
    157108
    158 #ifndef RT_OS_WINDOWS
     109
    159110/**
    160  * Structure used by OSes with less advanced ioctl interfaces, i.e. most
    161  * Unix like OSes :-)
    162  */
    163 typedef struct SUPDRVIOCTLDATA
    164 {
    165     void           *pvIn;
    166     unsigned long   cbIn;
    167     void           *pvOut;
    168     unsigned long   cbOut;
    169 #ifdef RT_OS_OS2
    170     int             rc;
    171 #endif
    172 } SUPDRVIOCTLDATA, *PSUPDRVIOCTLDATA;
    173 #endif
    174 
    175 
    176 /** SUPCOOKIE_IN magic word. */
    177 #define SUPCOOKIE_MAGIC             "The Magic Word!"
    178 /** Current interface version.
    179  * The upper 16-bit is the major version, the the lower the minor version.
    180  * When incompatible changes are made, the upper major number has to be changed. */
    181 #define SUPDRVIOC_VERSION           0x00050001
    182 
    183 /** SUP_IOCTL_COOKIE Input. */
    184 typedef struct SUPCOOKIE_IN
    185 {
    186     /** Magic word. */
    187     char            szMagic[16];
    188     /** The requested interface version number. */
    189     uint32_t        u32ReqVersion;
    190     /** The minimum interface version number. */
    191     uint32_t        u32MinVersion;
    192 } SUPCOOKIE_IN, *PSUPCOOKIE_IN;
    193 
    194 /** SUP_IOCTL_COOKIE Output. */
    195 typedef struct SUPCOOKIE_OUT
     111 * Common In/Out header.
     112 */
     113typedef struct SUPREQHDR
    196114{
    197115    /** Cookie. */
    … …  
    199117    /** Session cookie. */
    200118    uint32_t        u32SessionCookie;
    201     /** Interface version for this session. */
    202     uint32_t        u32SessionVersion;
    203     /** The actual interface version in the driver. */
    204     uint32_t        u32DriverVersion;
    205     /** Number of functions available for the SUP_IOCTL_QUERY_FUNCS request. */
    206     uint32_t        cFunctions;
    207     /** Session handle. */
    208     R0PTRTYPE(PSUPDRVSESSION)   pSession;
    209 } SUPCOOKIE_OUT, *PSUPCOOKIE_OUT;
    210 
    211 
    212 
    213 /** SUP_IOCTL_QUERY_FUNCS Input. */
    214 typedef struct SUPQUERYFUNCS_IN
    215 {
    216     /** Cookie. */
    217     uint32_t        u32Cookie;
    218     /** Session cookie. */
    219     uint32_t        u32SessionCookie;
    220 } SUPQUERYFUNCS_IN, *PSUPQUERYFUNCS_IN;
    221 
    222 /** Function. */
     119    /** The size of the input. */
     120    uint32_t        cbIn;
     121    /** The size of the output. */
     122    uint32_t        cbOut;
     123    /** Flags. See SUPREQHDR_FLAGS_* for details and values. */
     124    uint32_t        fFlags;
     125    /** The VBox status code of the operation, out direction only. */
     126    int32_t         rc;
     127} SUPREQHDR;
     128/** Pointer to a IOC header. */
     129typedef SUPREQHDR *PSUPREQHDR;
     130
     131/** @name SUPREQHDR::fFlags values
     132 * @{  */
     133/** Masks out the magic value.  */
     134#define SUPREQHDR_FLAGS_MAGIC_MASK                      UINT32_C(0xff0000ff)
     135/** The generic mask. */
     136#define SUPREQHDR_FLAGS_GEN_MASK                        UINT32_C(0x0000ff00)
     137/** The request specific mask. */
     138#define SUPREQHDR_FLAGS_REQ_MASK                        UINT32_C(0x00ff0000)
     139
     140/** There is extra input that needs copying on some platforms. */
     141#define SUPREQHDR_FLAGS_EXTRA_IN                        UINT32_C(0x00000100)
     142/** There is extra output that needs copying on some platforms. */
     143#define SUPREQHDR_FLAGS_EXTRA_OUT                       UINT32_C(0x00000200)
     144
     145/** The magic value. */
     146#define SUPREQHDR_FLAGS_MAGIC                           UINT32_C(0x42000042)
     147/** The default value. Use this when no special stuff is requested. */
     148#define SUPREQHDR_FLAGS_DEFAULT                         SUPREQHDR_FLAGS_MAGIC
     149/** @} */
     150
     151
     152/** @name SUP_IOCTL_COOKIE
     153 * @{
     154 */
     155/** Negotiate cookie. */
     156#define SUP_IOCTL_COOKIE                                SUP_CTL_CODE_SIZE(1, SUP_IOCTL_COOKIE_SIZE)
     157/** The request size. */
     158#define SUP_IOCTL_COOKIE_SIZE                           sizeof(SUPCOOKIE)
     159/** The SUPREQHDR::cbIn value. */
     160#define SUP_IOCTL_COOKIE_SIZE_IN                        sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.In)
     161/** The SUPREQHDR::cbOut value. */
     162#define SUP_IOCTL_COOKIE_SIZE_OUT                       sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCOOKIE, u.Out)
     163/** SUPCOOKIE_IN magic word. */
     164#define SUPCOOKIE_MAGIC                                 "The Magic Word!"
     165/** The initial cookie. */
     166#define SUPCOOKIE_INITIAL_COOKIE                        0x69726f74 /* 'tori' */
     167
     168/** Current interface version.
     169 * The upper 16-bit is the major version, the the lower the minor version.
     170 * When incompatible changes are made, the upper major number has to be changed. */
     171#define SUPDRVIOC_VERSION                               0x00060000
     172
     173/** SUP_IOCTL_COOKIE. */
     174typedef struct SUPCOOKIE
     175{
     176    /** The header.
     177     * u32Cookie must be set to SUPCOOKIE_INITIAL_COOKIE.
     178     * u32SessionCookie should be set to some random value. */
     179    SUPREQHDR               Hdr;
     180    union
     181    {
     182        struct
     183        {
     184            /** Magic word. */
     185            char            szMagic[16];
     186            /** The requested interface version number. */
     187            uint32_t        u32ReqVersion;
     188            /** The minimum interface version number. */
     189            uint32_t        u32MinVersion;
     190        } In;
     191        struct
     192        {
     193            /** Cookie. */
     194            uint32_t        u32Cookie;
     195            /** Session cookie. */
     196            uint32_t        u32SessionCookie;
     197            /** Interface version for this session. */
     198            uint32_t        u32SessionVersion;
     199            /** The actual interface version in the driver. */
     200            uint32_t        u32DriverVersion;
     201            /** Number of functions available for the SUP_IOCTL_QUERY_FUNCS request. */
     202            uint32_t        cFunctions;
     203            /** Session handle. */
     204            R0PTRTYPE(PSUPDRVSESSION)   pSession;
     205        } Out;
     206    } u;
     207} SUPCOOKIE, *PSUPCOOKIE;
     208/** @} */
     209
     210
     211/** @name SUP_IOCTL_QUERY_FUNCS
     212 * Query SUPR0 functions.
     213 * @{
     214 */
     215#define SUP_IOCTL_QUERY_FUNCS(cFuncs)                   SUP_CTL_CODE_SIZE(2, SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs))
     216#define SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs)              RT_OFFSETOF(SUPQUERYFUNCS, u.Out.aFunctions[(cFuncs)])
     217#define SUP_IOCTL_QUERY_FUNCS_SIZE_IN                   sizeof(SUPREQHDR)
     218#define SUP_IOCTL_QUERY_FUNCS_SIZE_OUT(cFuncs)          SUP_IOCTL_QUERY_FUNCS_SIZE(cFuncs)
     219
     220/** A function. */
    223221typedef struct SUPFUNC
    224222{
    … …  
    229227} SUPFUNC, *PSUPFUNC;
    230228
    231 /** SUP_IOCTL_QUERY_FUNCS Output. */
    232 typedef struct SUPQUERYFUNCS_OUT
    233 {
    234     /** Number of functions returned. */
    235     uint32_t        cFunctions;
    236     /** Array of functions. */
    237     SUPFUNC         aFunctions[1];
    238 } SUPQUERYFUNCS_OUT, *PSUPQUERYFUNCS_OUT;
    239 
    240 
    241 
    242 /** SUP_IOCTL_IDT_INSTALL Input. */
    243 typedef struct SUPIDTINSTALL_IN
    244 {
    245     /** Cookie. */
    246     uint32_t        u32Cookie;
    247     /** Session cookie. */
    248     uint32_t        u32SessionCookie;
    249 } SUPIDTINSTALL_IN, *PSUPIDTINSTALL_IN;
    250 
    251 /** SUP_IOCTL_IDT_INSTALL Output. */
    252 typedef struct SUPIDTINSTALL_OUT
    253 {
    254     /** Cookie. */
    255     uint8_t         u8Idt;
    256 } SUPIDTINSTALL_OUT, *PSUPIDTINSTALL_OUT;
    257 
    258 
    259 
    260 /** SUP_IOCTL_IDT_REMOVE Input. */
    261 typedef struct SUPIDTREMOVE_IN
    262 {
    263     /** Cookie. */
    264     uint32_t        u32Cookie;
    265     /** Session cookie. */
    266     uint32_t        u32SessionCookie;
    267 } SUPIDTREMOVE_IN, *PSUPIDTREMOVE_IN;
    268 
    269 
    270 
    271 /** SUP_IOCTL_PINPAGES Input. */
    272 typedef struct SUPPINPAGES_IN
    273 {
    274     /** Cookie. */
    275     uint32_t        u32Cookie;
    276     /** Session cookie. */
    277     uint32_t        u32SessionCookie;
    278     /** Start of page range. Must be PAGE aligned. */
    279     RTR3PTR         pvR3;
    280     /** Size of the range. Must be PAGE aligned. */
    281     uint32_t        cPages;
    282 } SUPPINPAGES_IN, *PSUPPINPAGES_IN;
    283 
    284 /** SUP_IOCTL_PINPAGES Output. */
    285 typedef struct SUPPINPAGES_OUT
    286 {
    287     /** Array of pages. */
    288     SUPPAGE         aPages[1];
    289 } SUPPINPAGES_OUT, *PSUPPINPAGES_OUT;
    290 
    291 
    292 
    293 /** SUP_IOCTL_UNPINPAGES Input. */
    294 typedef struct SUPUNPINPAGES_IN
    295 {
    296     /** Cookie. */
    297     uint32_t        u32Cookie;
    298     /** Session cookie. */
    299     uint32_t        u32SessionCookie;
    300     /** Start of page range of a range previuosly pinned. */
    301     RTR3PTR         pvR3;
    302 } SUPUNPINPAGES_IN, *PSUPUNPINPAGES_IN;
    303 
    304 
    305 
    306 /** SUP_IOCTL_CONT_ALLOC Input. */
    307 typedef struct SUPCONTALLOC_IN
    308 {
    309     /** Cookie. */
    310     uint32_t        u32Cookie;
    311     /** Session cookie. */
    312     uint32_t        u32SessionCookie;
    313     /** Number of bytes to allocate. */
    314     uint32_t        cPages;
    315 } SUPCONTALLOC_IN, *PSUPCONTALLOC_IN;
    316 
    317 
    318 
    319 /** SUP_IOCTL_CONT_ALLOC Output. */
    320 typedef struct SUPCONTALLOC_OUT
    321 {
    322     /** The address of the ring-0 mapping of the allocated memory. */
    323     RTR0PTR         pvR0;
    324     /** The address of the ring-3 mapping of the allocated memory. */
    325     RTR3PTR         pvR3;
    326     /** The physical address of the allocation. */
    327     RTHCPHYS        HCPhys;
    328 } SUPCONTALLOC_OUT, *PSUPCONTALLOC_OUT;
    329 
    330 
    331 
    332 /** SUP_IOCTL_CONT_FREE Input. */
    333 typedef struct SUPCONTFREE_IN
    334 {
    335     /** Cookie. */
    336     uint32_t        u32Cookie;
    337     /** Session cookie. */
    338     uint32_t        u32SessionCookie;
    339     /** The ring-3 address of the memory to free. */
    340     RTR3PTR         pvR3;
    341 } SUPCONTFREE_IN, *PSUPCONTFREE_IN;
    342 
    343 
    344 
    345 /** SUP_IOCTL_LDR_OPEN Input. */
    346 typedef struct SUPLDROPEN_IN
    347 {
    348     /** Cookie. */
    349     uint32_t        u32Cookie;
    350     /** Session cookie. */
    351     uint32_t        u32SessionCookie;
    352     /** Size of the image we'll be loading. */
    353     uint32_t        cbImage;
    354     /** Image name.
    355      * This is the NAME of the image, not the file name. It is used
    356      * to share code with other processes. (Max len is 32 chars!)  */
    357     char            szName[32];
    358 } SUPLDROPEN_IN, *PSUPLDROPEN_IN;
    359 
    360 /** SUP_IOCTL_LDR_OPEN Output. */
    361 typedef struct SUPLDROPEN_OUT
    362 {
    363     /** The base address of the image. */
    364     RTR0PTR         pvImageBase;
    365     /** Indicate whether or not the image requires loading. */
    366     bool            fNeedsLoading;
    367 } SUPLDROPEN_OUT, *PSUPLDROPEN_OUT;
    368 
    369 
     229typedef struct SUPQUERYFUNCS
     230{
     231    /** The header. */
     232    SUPREQHDR               Hdr;
     233    union
     234    {
     235        struct
     236        {
     237            /** Number of functions returned. */
     238            uint32_t        cFunctions;
     239            /** Array of functions. */
     240            SUPFUNC         aFunctions[1];
     241        } Out;
     242    } u;
     243} SUPQUERYFUNCS, *PSUPQUERYFUNCS;
     244/** @} */
     245
     246
     247/** @name SUP_IOCTL_IDT_INSTALL
     248 * Install IDT patch for calling processor.
     249 * @{
     250 */
     251#define SUP_IOCTL_IDT_INSTALL                           SUP_CTL_CODE_SIZE(3, SUP_IOCTL_IDT_INSTALL_SIZE)
     252#define SUP_IOCTL_IDT_INSTALL_SIZE                      sizeof(SUPIDTINSTALL)
     253#define SUP_IOCTL_IDT_INSTALL_SIZE_IN                   sizeof(SUPREQHDR)
     254#define SUP_IOCTL_IDT_INSTALL_SIZE_OUT                  sizeof(SUPIDTINSTALL)
     255typedef struct SUPIDTINSTALL
     256{
     257    /** The header. */
     258    SUPREQHDR               Hdr;
     259    union
     260    {
     261        struct
     262        {
     263            /** The IDT entry number. */
     264            uint8_t         u8Idt;
     265        } Out;
     266    } u;
     267} SUPIDTINSTALL, *PSUPIDTINSTALL;
     268/** @} */
     269
     270
     271/** @name SUP_IOCTL_IDT_REMOVE
     272 * Remove IDT patch for calling processor.
     273 * @{
     274 */
     275#define SUP_IOCTL_IDT_REMOVE                            SUP_CTL_CODE_SIZE(4, SUP_IOCTL_IDT_REMOVE_SIZE)
     276#define SUP_IOCTL_IDT_REMOVE_SIZE                       sizeof(SUPIDTREMOVE)
     277#define SUP_IOCTL_IDT_REMOVE_SIZE_IN                    sizeof(SUPIDTREMOVE)
     278#define SUP_IOCTL_IDT_REMOVE_SIZE_OUT                   sizeof(SUPIDTREMOVE)
     279typedef struct SUPIDTREMOVE
     280{
     281    /** The header. */
     282    SUPREQHDR               Hdr;
     283} SUPIDTREMOVE, *PSUPIDTREMOVE;
     284/** @}*/
     285
     286
     287/** @name SUP_IOCTL_LDR_OPEN
     288 * Open an image.
     289 * @{
     290 */
     291#define SUP_IOCTL_LDR_OPEN                              SUP_CTL_CODE_SIZE(5, SUP_IOCTL_LDR_OPEN_SIZE)
     292#define SUP_IOCTL_LDR_OPEN_SIZE                         sizeof(SUPLDROPEN)
     293#define SUP_IOCTL_LDR_OPEN_SIZE_IN                      sizeof(SUPLDROPEN)
     294#define SUP_IOCTL_LDR_OPEN_SIZE_OUT                     (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDROPEN, u.Out))
     295typedef struct SUPLDROPEN
     296{
     297    /** The header. */
     298    SUPREQHDR               Hdr;
     299    union
     300    {
     301        struct
     302        {
     303            /** Size of the image we'll be loading. */
     304            uint32_t        cbImage;
     305            /** Image name.
     306             * This is the NAME of the image, not the file name. It is used
     307             * to share code with other processes. (Max len is 32 chars!)  */
     308            char            szName[32];
     309        } In;
     310        struct
     311        {
     312            /** The base address of the image. */
     313            RTR0PTR         pvImageBase;
     314            /** Indicate whether or not the image requires loading. */
     315            bool            fNeedsLoading;
     316        } Out;
     317    } u;
     318} SUPLDROPEN, *PSUPLDROPEN;
     319/** @} */
     320
     321
     322/** @name SUP_IOCTL_LDR_LOAD
     323 * Upload the image bits.
     324 * @{
     325 */
     326#define SUP_IOCTL_LDR_LOAD                              SUP_CTL_CODE_BIG(6)
     327#define SUP_IOCTL_LDR_LOAD_SIZE(cbImage)                RT_OFFSETOF(SUPLDRLOAD, u.In.achImage[cbImage])
     328#define SUP_IOCTL_LDR_LOAD_SIZE_IN(cbImage)             RT_OFFSETOF(SUPLDRLOAD, u.In.achImage[cbImage])
     329#define SUP_IOCTL_LDR_LOAD_SIZE_OUT                     sizeof(SUPREQHDR)
    370330
    371331/**
    … …  
    399359} SUPLDRSYM, *PSUPLDRSYM;
    400360
    401 /** SUP_IOCTL_LDR_LOAD Input. */
    402 typedef struct SUPLDRLOAD_IN
    403 {
    404     /** Cookie. */
    405     uint32_t        u32Cookie;
    406     /** Session cookie. */
    407     uint32_t        u32SessionCookie;
    408     /** The address of module initialization function. Similar to _DLL_InitTerm(hmod, 0). */
    409     PFNR0MODULEINIT pfnModuleInit;
    410     /** The address of module termination function. Similar to _DLL_InitTerm(hmod, 1). */
    411     PFNR0MODULETERM pfnModuleTerm;
    412     /** Special entry points. */
    413     union
    414     {
    415         struct
    416         {
    417             /** The module handle (i.e. address). */
    418             RTR0PTR         pvVMMR0;
    419             /** Address of VMMR0Entry function. */
    420             RTR0PTR         pvVMMR0Entry;
    421         } VMMR0;
    422     }               EP;
    423     /** Address. */
    424     RTR0PTR         pvImageBase;
    425     /** Entry point type. */
    426     enum { EP_NOTHING, EP_VMMR0 }
    427                     eEPType;
    428     /** The offset of the symbol table. */
    429     uint32_t        offSymbols;
    430     /** The number of entries in the symbol table. */
    431     uint32_t        cSymbols;
    432     /** The offset of the string table. */
    433     uint32_t        offStrTab;
    434     /** Size of the string table. */
    435     uint32_t        cbStrTab;
    436     /** Size of image (including string and symbol tables). */
    437     uint32_t        cbImage;
    438     /** The image data. */
    439     char            achImage[1];
    440 } SUPLDRLOAD_IN, *PSUPLDRLOAD_IN;
    441 
    442 
    443 
    444 /** SUP_IOCTL_LDR_FREE Input. */
    445 typedef struct SUPLDRFREE_IN
    446 {
    447     /** Cookie. */
    448     uint32_t        u32Cookie;
    449     /** Session cookie. */
    450     uint32_t        u32SessionCookie;
    451     /** Address. */
    452     RTR0PTR         pvImageBase;
    453 } SUPLDRFREE_IN, *PSUPLDRFREE_IN;
    454 
    455 
    456 
    457 /** SUP_IOCTL_LDR_GET_SYMBOL Input. */
    458 typedef struct SUPLDRGETSYMBOL_IN
    459 {
    460     /** Cookie. */
    461     uint32_t        u32Cookie;
    462     /** Session cookie. */
    463     uint32_t        u32SessionCookie;
    464     /** Address. */
    465     RTR0PTR         pvImageBase;
    466     /** The symbol name (variable length). */
    467     char            szSymbol[1];
    468 } SUPLDRGETSYMBOL_IN, *PSUPLDRGETSYMBOL_IN;
    469 
    470 /** SUP_IOCTL_LDR_GET_SYMBOL Output. */
    471 typedef struct SUPLDRGETSYMBOL_OUT
    472 {
    473     /** The symbol address. */
    474     RTR0PTR         pvSymbol;
    475 } SUPLDRGETSYMBOL_OUT, *PSUPLDRGETSYMBOL_OUT;
    476 
    477 
    478 
    479 /** SUP_IOCTL_CALL_VMMR0 Input. */
    480 typedef struct SUPCALLVMMR0_IN
    481 {
    482     /** Cookie. */
    483     uint32_t        u32Cookie;
    484     /** Session cookie. */
    485     uint32_t        u32SessionCookie;
    486     /** The VM handle. */
    487     PVMR0           pVMR0;
    488     /** Which operation to execute. */
    489     uint32_t        uOperation;
    490     /** The size of the buffer pointed to by pvArg. */
    491     uint32_t        cbArg;
    492     /** Argument to that operation. */
    493     RTR3PTR         pvArg;
    494 } SUPCALLVMMR0_IN, *PSUPCALLVMMR0_IN;
    495 
    496 /** SUP_IOCTL_CALL_VMMR0 Output. */
    497 typedef struct SUPCALLVMMR0_OUT
    498 {
    499     /** The VBox status code for the operation. */
    500     int32_t         rc;
    501 } SUPCALLVMMR0_OUT, *PSUPCALLVMMR0_OUT;
    502 
    503 
    504 
    505 /** SUP_IOCTL_GET_PAGING_MODE Input. */
    506 typedef struct SUPGETPAGINGMODE_IN
    507 {
    508     /** Cookie. */
    509     uint32_t        u32Cookie;
    510     /** Session cookie. */
    511     uint32_t        u32SessionCookie;
    512 } SUPGETPAGINGMODE_IN, *PSUPGETPAGINGMODE_IN;
    513 
    514 /** SUP_IOCTL_GET_PAGING_MODE Output. */
    515 typedef struct SUPGETPAGINGMODE_OUT
    516 {
    517     /** The paging mode. */
    518     SUPPAGINGMODE       enmMode;
    519 } SUPGETPAGINGMODE_OUT, *PSUPGETPAGINGMODE_OUT;
    520 
    521 
    522 
    523 /** SUP_IOCTL_LOW_ALLOC Input. */
    524 typedef struct SUPLOWALLOC_IN
    525 {
    526     /** Cookie. */
    527     uint32_t        u32Cookie;
    528     /** Session cookie. */
    529     uint32_t        u32SessionCookie;
    530     /** Number of pages to allocate. */
    531     uint32_t        cPages;
    532 } SUPLOWALLOC_IN, *PSUPLOWALLOC_IN;
    533 
    534 /** SUP_IOCTL_LOW_ALLOC Output. */
    535 typedef struct SUPLOWALLOC_OUT
    536 {
    537     /** The ring-3 address of the allocated memory. */
    538     RTR3PTR         pvR3;
    539     /** The ring-0 address of the allocated memory. */
    540     RTR0PTR         pvR0;
    541     /** Array of pages. */
    542     SUPPAGE         aPages[1];
    543 } SUPLOWALLOC_OUT, *PSUPLOWALLOC_OUT;
    544 
    545 
    546 
    547 /** SUP_IOCTL_LOW_FREE Input. */
    548 typedef struct SUPLOWFREE_IN
    549 {
    550     /** Cookie. */
    551     uint32_t        u32Cookie;
    552     /** Session cookie. */
    553     uint32_t        u32SessionCookie;
    554     /** The ring-3 address of the memory to free. */
    555     RTR3PTR         pvR3;
    556 } SUPLOWFREE_IN, *PSUPLOWFREE_IN;
    557 
    558 
    559 
    560 /** SUP_IOCTL_GIP_MAP Input. */
    561 typedef struct SUPGIPMAP_IN
    562 {
    563     /** Cookie. */
    564     uint32_t        u32Cookie;
    565     /** Session cookie. */
    566     uint32_t        u32SessionCookie;
    567 } SUPGIPMAP_IN, *PSUPGIPMAP_IN;
    568 
    569 /** SUP_IOCTL_GIP_MAP Output. */
    570 typedef struct SUPGIPMAP_OUT
    571 {
    572     /** Pointer to the read-only usermode GIP mapping for this session. */
    573     R3PTRTYPE(PSUPGLOBALINFOPAGE)   pGipR3;
    574     /** Pointer to the supervisor mode GIP mapping. */
    575     R0PTRTYPE(PSUPGLOBALINFOPAGE)   pGipR0;
    576     /** The physical address of the GIP. */
    577     RTHCPHYS                        HCPhysGip;
    578 } SUPGIPMAP_OUT, *PSUPGIPMAP_OUT;
    579 
    580 
    581 
    582 /** SUP_IOCTL_GIP_UNMAP Input. */
    583 typedef struct SUPGIPUNMAP_IN
    584 {
    585     /** Cookie. */
    586     uint32_t        u32Cookie;
    587     /** Session cookie. */
    588     uint32_t        u32SessionCookie;
    589 } SUPGIPUNMAP_IN, *PSUPGIPUNMAP_IN;
    590 
    591 
    592 
    593 /** SUP_IOCTL_SET_VM_FOR_FAST Input. */
    594 typedef struct SUPSETVMFORFAST_IN
    595 {
    596     /** Cookie. */
    597     uint32_t        u32Cookie;
    598     /** Session cookie. */
    599     uint32_t        u32SessionCookie;
    600     /** The ring-0 VM handle (pointer). */
    601     PVMR0           pVMR0;
    602 } SUPSETVMFORFAST_IN, *PSUPSETVMFORFAST_IN;
    603 
    604 typedef struct SUPALLOCPAGE_IN
    605 {
    606     /** Cookie. */
    607     uint32_t        u32Cookie;
    608     /** Session cookie. */
    609     uint32_t        u32SessionCookie;
    610     /** Number of pages to allocate */
    611     uint32_t        cPages;
    612 } SUPALLOCPAGE_IN, *PSUPALLOCPAGE_IN;
    613 
    614 typedef struct SUPALLOCPAGE_OUT
    615 {
    616     /** Cookie. */
    617     uint32_t            u32Cookie;
    618     /** Returned ring-3 address */
    619     R3PTRTYPE(void *)   pvR3;
    620 } SUPALLOCPAGE_OUT, *PSUPALLOCPAGE_OUT;
    621 
    622 typedef struct SUPFREEPAGE_IN
    623 {
    624     /** Cookie. */
    625     uint32_t            u32Cookie;
    626     /** Session cookie. */
    627     uint32_t        u32SessionCookie;
    628     /** Address of memory range to free */
    629     R3PTRTYPE(void *)   pvR3;
    630 } SUPFREEPAGE_IN, *PSUPFREEPAGE_IN;
     361typedef struct SUPLDRLOAD
     362{
     363    /** The header. */
     364    SUPREQHDR               Hdr;
     365    union
     366    {
     367        struct
     368        {
     369            /** The address of module initialization function. Similar to _DLL_InitTerm(hmod, 0). */
     370            PFNR0MODULEINIT pfnModuleInit;
     371            /** The address of module termination function. Similar to _DLL_InitTerm(hmod, 1). */
     372            PFNR0MODULETERM pfnModuleTerm;
     373            /** Special entry points. */
     374            union
     375            {
     376                struct
     377                {
     378                    /** The module handle (i.e. address). */
     379                    RTR0PTR         pvVMMR0;
     380                    /** Address of VMMR0Entry function. */
     381                    RTR0PTR         pvVMMR0Entry;
     382                } VMMR0;
     383            }               EP;
     384            /** Address. */
     385            RTR0PTR         pvImageBase;
     386            /** Entry point type. */
     387            enum { EP_NOTHING, EP_VMMR0 }
     388                            eEPType;
     389            /** The offset of the symbol table. */
     390            uint32_t        offSymbols;
     391            /** The number of entries in the symbol table. */
     392            uint32_t        cSymbols;
     393            /** The offset of the string table. */
     394            uint32_t        offStrTab;
     395            /** Size of the string table. */
     396            uint32_t        cbStrTab;
     397            /** Size of image (including string and symbol tables). */
     398            uint32_t        cbImage;
     399            /** The image data. */
     400            char            achImage[1];
     401        } In;
     402    } u;
     403} SUPLDRLOAD, *PSUPLDRLOAD;
     404/** @} */
     405
     406
     407/** @name SUP_IOCTL_LDR_FREE
     408 * Free an image.
     409 * @{
     410 */
     411#define SUP_IOCTL_LDR_FREE                              SUP_CTL_CODE_SIZE(7, SUP_IOCTL_LDR_FREE_SIZE)
     412#define SUP_IOCTL_LDR_FREE_SIZE                         sizeof(SUPLDRFREE)
     413#define SUP_IOCTL_LDR_FREE_SIZE_IN                      sizeof(SUPLDRFREE)
     414#define SUP_IOCTL_LDR_FREE_SIZE_OUT                     sizeof(SUPREQHDR)
     415typedef struct SUPLDRFREE
     416{
     417    /** The header. */
     418    SUPREQHDR               Hdr;
     419    union
     420    {
     421        struct
     422        {
     423            /** Address. */
     424            RTR0PTR         pvImageBase;
     425        } In;
     426    } u;
     427} SUPLDRFREE, *PSUPLDRFREE;
     428/** @} */
     429
     430
     431/** @name SUP_IOCTL_LDR_GET_SYMBOL
     432 * Get address of a symbol within an image.
     433 * @{
     434 */
     435#define SUP_IOCTL_LDR_GET_SYMBOL                        SUP_CTL_CODE_SIZE(8, SUP_IOCTL_LDR_GET_SYMBOL_SIZE)
     436#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE                   sizeof(SUPLDRGETSYMBOL)
     437#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_IN                sizeof(SUPLDRGETSYMBOL)
     438#define SUP_IOCTL_LDR_GET_SYMBOL_SIZE_OUT               (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLDRGETSYMBOL, u.Out))
     439typedef struct SUPLDRGETSYMBOL
     440{
     441    /** The header. */
     442    SUPREQHDR               Hdr;
     443    union
     444    {
     445        struct
     446        {
     447            /** Address. */
     448            RTR0PTR         pvImageBase;
     449            /** The symbol name. */
     450            char            szSymbol[64];
     451        } In;
     452        struct
     453        {
     454            /** The symbol address. */
     455            RTR0PTR         pvSymbol;
     456        } Out;
     457    } u;
     458} SUPLDRGETSYMBOL, *PSUPLDRGETSYMBOL;
     459/** @} */
     460
     461
     462/** @name SUP_IOCTL_CALL_VMMR0
     463 * Call the R0 VMM Entry point.
     464 *
     465 * @todo Might have to convert this to a big request...
     466 * @{
     467 */
     468#define SUP_IOCTL_CALL_VMMR0(cbReq)                     SUP_CTL_CODE_SIZE(9, SUP_IOCTL_CALL_VMMR0_SIZE(cbReq))
     469#define SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)                RT_OFFSETOF(SUPCALLVMMR0, abReqPkt[cbReq])
     470#define SUP_IOCTL_CALL_VMMR0_SIZE_IN(cbReq)             SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
     471#define SUP_IOCTL_CALL_VMMR0_SIZE_OUT(cbReq)            SUP_IOCTL_CALL_VMMR0_SIZE(cbReq)
     472typedef struct SUPCALLVMMR0
     473{
     474    /** The header. */
     475    SUPREQHDR               Hdr;
     476    union
     477    {
     478        struct
     479        {
     480            /** The VM handle. */
     481            PVMR0           pVMR0;
     482            /** Which operation to execute. */
     483            uint32_t        uOperation;
     484#if R0_ARCH_BITS == 64
     485            /** Alignment. */
     486            uint32_t        u32Reserved;
     487#endif
     488            /** Argument to use when no request packet is supplied. */
     489            RTR0UINTPTR     uArg;
     490        } In;
     491    } u;
     492    /** The VMMR0Entry request packet. */
     493    uint8_t                 abReqPkt[1];
     494} SUPCALLVMMR0, *PSUPCALLVMMR0;
     495/** @} */
     496
     497
     498/** @name SUP_IOCTL_LOW_ALLOC
     499 * Allocate memory below 4GB (physically).
     500 * @{
     501 */
     502#define SUP_IOCTL_LOW_ALLOC                             SUP_CTL_CODE_BIG(10)
     503#define SUP_IOCTL_LOW_ALLOC_SIZE(cPages)                RT_OFFSETOF(SUPLOWALLOC, u.Out.aPages[cPages])
     504#define SUP_IOCTL_LOW_ALLOC_SIZE_IN                     (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPLOWALLOC, u.In))
     505#define SUP_IOCTL_LOW_ALLOC_SIZE_OUT(cPages)            SUP_IOCTL_LOW_ALLOC_SIZE(cPages)
     506typedef struct SUPLOWALLOC
     507{
     508    /** The header. */
     509    SUPREQHDR               Hdr;
     510    union
     511    {
     512        struct
     513        {
     514            /** Number of pages to allocate. */
     515            uint32_t        cPages;
     516        } In;
     517        struct
     518        {
     519            /** The ring-3 address of the allocated memory. */
     520            RTR3PTR         pvR3;
     521            /** The ring-0 address of the allocated memory. */
     522            RTR0PTR         pvR0;
     523            /** Array of pages. */
     524            RTHCPHYS        aPages[1];
     525        } Out;
     526    } u;
     527} SUPLOWALLOC, *PSUPLOWALLOC;
     528/** @} */
     529
     530
     531/** @name SUP_IOCTL_LOW_FREE
     532 * Free low memory.
     533 * @{
     534 */
     535#define SUP_IOCTL_LOW_FREE                              SUP_CTL_CODE_SIZE(11, SUP_IOCTL_LOW_FREE_SIZE)
     536#define SUP_IOCTL_LOW_FREE_SIZE                         sizeof(SUPLOWFREE)
     537#define SUP_IOCTL_LOW_FREE_SIZE_IN                      sizeof(SUPLOWFREE)
     538#define SUP_IOCTL_LOW_FREE_SIZE_OUT                     sizeof(SUPREQHDR)
     539typedef struct SUPLOWFREE
     540{
     541    /** The header. */
     542    SUPREQHDR               Hdr;
     543    union
     544    {
     545        struct
     546        {
     547            /** The ring-3 address of the memory to free. */
     548            RTR3PTR         pvR3;
     549        } In;
     550    } u;
     551} SUPLOWFREE, *PSUPLOWFREE;
     552/** @} */
     553
     554
     555/** @name SUP_IOCTL_PAGE_ALLOC
     556 * Allocate memory and map into the user process.
     557 * The memory is of course locked.
     558 * @{
     559 */
     560#define SUP_IOCTL_PAGE_ALLOC                            SUP_CTL_CODE_BIG(12)
     561#define SUP_IOCTL_PAGE_ALLOC_SIZE(cPages)               RT_OFFSETOF(SUPPAGEALLOC, u.Out.aPages[cPages])
     562#define SUP_IOCTL_PAGE_ALLOC_SIZE_IN                    (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGEALLOC, u.In))
     563#define SUP_IOCTL_PAGE_ALLOC_SIZE_OUT(cPages)           SUP_IOCTL_PAGE_ALLOC_SIZE(cPages)
     564typedef struct SUPPAGEALLOC
     565{
     566    /** The header. */
     567    SUPREQHDR               Hdr;
     568    union
     569    {
     570        struct
     571        {
     572            /** Number of pages to allocate */
     573            uint32_t        cPages;
     574        } In;
     575        struct
     576        {
     577            /** Returned ring-3 address. */
     578            RTR3PTR         pvR3;
     579            /** The physical addresses of the allocated pages. */
     580            RTHCPHYS        aPages[1];
     581        } Out;
     582    } u;
     583} SUPPAGEALLOC, *PSUPPAGEALLOC;
     584/** @} */
     585
     586
     587/** @name SUP_IOCTL_PAGE_FREE
     588 * Free memory allocated with SUP_IOCTL_PAGE_ALLOC.
     589 * @{
     590 */
     591#define SUP_IOCTL_PAGE_FREE                             SUP_CTL_CODE_SIZE(13, SUP_IOCTL_PAGE_FREE_SIZE_IN)
     592#define SUP_IOCTL_PAGE_FREE_SIZE                        sizeof(SUPPAGEFREE)
     593#define SUP_IOCTL_PAGE_FREE_SIZE_IN                     sizeof(SUPPAGEFREE)
     594#define SUP_IOCTL_PAGE_FREE_SIZE_OUT                    sizeof(SUPREQHDR)
     595typedef struct SUPPAGEFREE
     596{
     597    /** The header. */
     598    SUPREQHDR               Hdr;
     599    union
     600    {
     601        struct
     602        {
     603            /** Address of memory range to free. */
     604            RTR3PTR         pvR3;
     605        } In;
     606    } u;
     607} SUPPAGEFREE, *PSUPPAGEFREE;
     608/** @} */
     609
     610
     611/** @name SUP_IOCTL_PAGE_LOCK
     612 * Pin down physical pages.
     613 * @{
     614 */
     615#define SUP_IOCTL_PAGE_LOCK                             SUP_CTL_CODE_BIG(14)
     616#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)))
     617#define SUP_IOCTL_PAGE_LOCK_SIZE_IN                     (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPPAGELOCK, u.In))
     618#define SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages)            RT_OFFSETOF(SUPPAGELOCK, u.Out.aPages[cPages])
     619typedef struct SUPPAGELOCK
     620{
     621    /** The header. */
     622    SUPREQHDR               Hdr;
     623    union
     624    {
     625        struct
     626        {
     627            /** Start of page range. Must be PAGE aligned. */
     628            RTR3PTR         pvR3;
     629            /** The range size given as a page count. */
     630            uint32_t        cPages;
     631        } In;
     632
     633        struct
     634        {
     635            /** Array of pages. */
     636            RTHCPHYS        aPages[1];
     637        } Out;
     638    } u;
     639} SUPPAGELOCK, *PSUPPAGELOCK;
     640/** @} */
     641
     642
     643/** @name SUP_IOCTL_PAGE_UNLOCK
     644 * Unpin physical pages.
     645 * @{ */
     646#define SUP_IOCTL_PAGE_UNLOCK                           SUP_CTL_CODE_SIZE(15, SUP_IOCTL_PAGE_UNLOCK_SIZE)
     647#define SUP_IOCTL_PAGE_UNLOCK_SIZE                      sizeof(SUPPAGEUNLOCK)
     648#define SUP_IOCTL_PAGE_UNLOCK_SIZE_IN                   sizeof(SUPPAGEUNLOCK)
     649#define SUP_IOCTL_PAGE_UNLOCK_SIZE_OUT                  sizeof(SUPREQHDR)
     650typedef struct SUPPAGEUNLOCK
     651{
     652    /** The header. */
     653    SUPREQHDR               Hdr;
     654    union
     655    {
     656        struct
     657        {
     658            /** Start of page range of a range previuosly pinned. */
     659            RTR3PTR         pvR3;
     660        } In;
     661    } u;
     662} SUPPAGEUNLOCK, *PSUPPAGEUNLOCK;
     663/** @} */
     664
     665
     666/** @name SUP_IOCTL_CONT_ALLOC
     667 * Allocate contious memory.
     668 * @{
     669 */
     670#define SUP_IOCTL_CONT_ALLOC                            SUP_CTL_CODE_SIZE(16, SUP_IOCTL_CONT_ALLOC_SIZE)
     671#define SUP_IOCTL_CONT_ALLOC_SIZE                       sizeof(SUPCONTALLOC)
     672#define SUP_IOCTL_CONT_ALLOC_SIZE_IN                    (sizeof(SUPREQHDR) + RT_SIZEOFMEMB(SUPCONTALLOC, u.In))
     673#define SUP_IOCTL_CONT_ALLOC_SIZE_OUT                   sizeof(SUPCONTALLOC)
     674typedef struct SUPCONTALLOC
     675{
     676    /** The header. */
     677    SUPREQHDR               Hdr;
     678    union
     679    {
     680        struct
     681        {
     682            /** The allocation size given as a page count. */
     683            uint32_t        cPages;
     684        } In;
     685
     686        struct
     687        {
     688            /** The address of the ring-0 mapping of the allocated memory. */
     689            RTR0PTR         pvR0;
     690            /** The address of the ring-3 mapping of the allocated memory. */
     691            RTR3PTR         pvR3;
     692            /** The physical address of the allocation. */
     693            RTHCPHYS        HCPhys;
     694        } Out;
     695    } u;
     696} SUPCONTALLOC, *PSUPCONTALLOC;
     697/** @} */
     698
     699
     700/** @name SUP_IOCTL_CONT_FREE Input.
     701 * @{
     702 */
     703/** Free contious memory. */
     704#define SUP_IOCTL_CONT_FREE                             SUP_CTL_CODE_SIZE(17, SUP_IOCTL_CONT_FREE_SIZE)
     705#define SUP_IOCTL_CONT_FREE_SIZE                        sizeof(SUPCONTFREE)
     706#define SUP_IOCTL_CONT_FREE_SIZE_IN                     sizeof(SUPCONTFREE)
     707#define SUP_IOCTL_CONT_FREE_SIZE_OUT                    sizeof(SUPREQHDR)
     708typedef struct SUPCONTFREE
     709{
     710    /** The header. */
     711    SUPREQHDR               Hdr;
     712    union
     713    {
     714        struct
     715        {
     716            /** The ring-3 address of the memory to free. */
     717            RTR3PTR         pvR3;
     718        } In;
     719    } u;
     720} SUPCONTFREE, *PSUPCONTFREE;
     721/** @} */
     722
     723
     724/** @name SUP_IOCTL_GET_PAGING_MODE
     725 * Get the host paging mode.
     726 * @{
     727 */
     728#define SUP_IOCTL_GET_PAGING_MODE                       SUP_CTL_CODE_SIZE(18, SUP_IOCTL_GET_PAGING_MODE_SIZE)
     729#define SUP_IOCTL_GET_PAGING_MODE_SIZE                  sizeof(SUPGETPAGINGMODE)
     730#define SUP_IOCTL_GET_PAGING_MODE_SIZE_IN               sizeof(SUPREQHDR)
     731#define SUP_IOCTL_GET_PAGING_MODE_SIZE_OUT              sizeof(SUPGETPAGINGMODE)
     732typedef struct SUPGETPAGINGMODE
     733{
     734    /** The header. */
     735    SUPREQHDR               Hdr;
     736    union
     737    {
     738        struct
     739        {
     740            /** The paging mode. */
     741            SUPPAGINGMODE   enmMode;
     742        } Out;
     743    } u;
     744} SUPGETPAGINGMODE, *PSUPGETPAGINGMODE;
     745/** @} */
     746
     747
     748/** @name SUP_IOCTL_SET_VM_FOR_FAST
     749 * Set the VM handle for doing fast call ioctl calls.
     750 * @{
     751 */
     752#define SUP_IOCTL_SET_VM_FOR_FAST                       SUP_CTL_CODE_SIZE(19, SUP_IOCTL_SET_VM_FOR_FAST_SIZE)
     753#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE                  sizeof(SUPSETVMFORFAST)
     754#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_IN               sizeof(SUPSETVMFORFAST)
     755#define SUP_IOCTL_SET_VM_FOR_FAST_SIZE_OUT              sizeof(SUPREQHDR)
     756typedef struct SUPSETVMFORFAST
     757{
     758    /** The header. */
     759    SUPREQHDR               Hdr;
     760    union
     761    {
     762        struct
     763        {
     764            /** The ring-0 VM handle (pointer). */
     765            PVMR0           pVMR0;
     766        } In;
     767    } u;
     768} SUPSETVMFORFAST, *PSUPSETVMFORFAST;
     769/** @} */
     770
     771
     772/** @name SUP_IOCTL_GIP_MAP
     773 * Map the GIP into user space.
     774 * @{
     775 */
     776#define SUP_IOCTL_GIP_MAP                               SUP_CTL_CODE_SIZE(20, SUP_IOCTL_GIP_MAP_SIZE)
     777#define SUP_IOCTL_GIP_MAP_SIZE                          sizeof(SUPGIPMAP)
     778#define SUP_IOCTL_GIP_MAP_SIZE_IN                       sizeof(SUPREQHDR)
     779#define SUP_IOCTL_GIP_MAP_SIZE_OUT                      sizeof(SUPGIPMAP)
     780typedef struct SUPGIPMAP
     781{
     782    /** The header. */
     783    SUPREQHDR               Hdr;
     784    union
     785    {
     786        struct
     787        {
     788            /** The physical address of the GIP. */
     789            RTHCPHYS        HCPhysGip;
     790            /** Pointer to the read-only usermode GIP mapping for this session. */
     791            R3PTRTYPE(PSUPGLOBALINFOPAGE)   pGipR3;
     792            /** Pointer to the supervisor mode GIP mapping. */
     793            R0PTRTYPE(PSUPGLOBALINFOPAGE)   pGipR0;
     794        } Out;
     795    } u;
     796} SUPGIPMAP, *PSUPGIPMAP;
     797/** @} */
     798
     799
     800/** @name SUP_IOCTL_GIP_UNMAP
     801 * Unmap the GIP.
     802 * @{
     803 */
     804#define SUP_IOCTL_GIP_UNMAP                             SUP_CTL_CODE_SIZE(21, SUP_IOCTL_GIP_UNMAP_SIZE)
     805#define SUP_IOCTL_GIP_UNMAP_SIZE                        sizeof(SUPGIPUNMAP)
     806#define SUP_IOCTL_GIP_UNMAP_SIZE_IN                     sizeof(SUPGIPUNMAP)
     807#define SUP_IOCTL_GIP_UNMAP_SIZE_OUT                    sizeof(SUPGIPUNMAP)
     808typedef struct SUPGIPUNMAP
     809{
     810    /** The header. */
     811    SUPREQHDR               Hdr;
     812} SUPGIPUNMAP, *PSUPGIPUNMAP;
     813/** @} */
     814
    631815
    632816#pragma pack()                          /* paranoia */

  • trunk/src/VBox/HostDrivers/Support/SUPDRVShared.c

    r4792 r4800  
    6464#define GIP_UPDATEHZ_RECALC_FREQ            0x800
    6565
     66/**
     67 * Validates a session pointer.
     68 *
     69 * @returns true/false accordingly.
     70 * @param   pSession    The session.
     71 */
     72#define SUP_IS_SESSION_VALID(pSession)  \
     73    (   VALID_PTR(pSession) \
     74     && pSession->u32Cookie == BIRD_INV)
     75
    6676
    6777/*******************************************************************************
    … …  
    8797#ifdef USE_NEW_OS_INTERFACE_FOR_MM
    8898    { "SUPR0PageAlloc",                         (void *)SUPR0PageAlloc },
    89     { "SUPR0PageGetPhys",                       (void *)SUPR0PageGetPhys },
    9099    { "SUPR0PageFree",                          (void *)SUPR0PageFree },
    91100#endif
    … …  
    147156*   Internal Functions                                                         *
    148157*******************************************************************************/
    149 __BEGIN_DECLS
    150158static int      supdrvMemAdd(PSUPDRVMEMREF pMem, PSUPDRVSESSION pSession);
    151159static int      supdrvMemRelease(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, SUPDRVMEMREFTYPE eType);
    152160#ifndef VBOX_WITHOUT_IDT_PATCHING
    153 static int      supdrvIOCtl_IdtInstall(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPIDTINSTALL_IN pIn, PSUPIDTINSTALL_OUT pOut);
     161static int      supdrvIOCtl_IdtInstall(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPIDTINSTALL pReq);
    154162static PSUPDRVPATCH supdrvIdtPatchOne(PSUPDRVDEVEXT pDevExt, PSUPDRVPATCH pPatch);
    155163static int      supdrvIOCtl_IdtRemoveAll(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession);
    … …  
    157165static void     supdrvIdtWrite(volatile void *pvIdtEntry, const SUPDRVIDTE *pNewIDTEntry);
    158166#endif /* !VBOX_WITHOUT_IDT_PATCHING */
    159 static int      supdrvIOCtl_LdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDROPEN_IN pIn, PSUPLDROPEN_OUT pOut);
    160 static int      supdrvIOCtl_LdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRLOAD_IN pIn);
    161 static int      supdrvIOCtl_LdrFree(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRFREE_IN pIn);
    162 static int      supdrvIOCtl_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRGETSYMBOL_IN pIn, PSUPLDRGETSYMBOL_OUT pOut);
     167static int      supdrvIOCtl_LdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDROPEN pReq);
     168static int      supdrvIOCtl_LdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRLOAD pReq);
     169static int      supdrvIOCtl_LdrFree(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRFREE pReq);
     170static int      supdrvIOCtl_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRGETSYMBOL pReq);
    163171static int      supdrvLdrSetR0EP(PSUPDRVDEVEXT pDevExt, void *pvVMMR0, void *pvVMMR0Entry);
    164172static void     supdrvLdrUnsetR0EP(PSUPDRVDEVEXT pDevExt);
    165173static void     supdrvLdrAddUsage(PSUPDRVSESSION pSession, PSUPDRVLDRIMAGE pImage);
    166174static void     supdrvLdrFree(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage);
    167 static int      supdrvIOCtl_GetPagingMode(PSUPGETPAGINGMODE_OUT pOut);
     175static SUPPAGINGMODE supdrvIOCtl_GetPagingMode(void);
    168176static SUPGIPMODE supdrvGipDeterminTscMode(void);
     177#ifdef RT_OS_WINDOWS
     178static int      supdrvPageGetPhys(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages);
     179static bool     supdrvPageWasLockedByPageAlloc(PSUPDRVSESSION pSession, RTR3PTR pvR3);
     180#endif
    169181#ifdef USE_NEW_OS_INTERFACE_FOR_GIP
    170182static int      supdrvGipCreate(PSUPDRVDEVEXT pDevExt);
    171 static int      supdrvGipDestroy(PSUPDRVDEVEXT pDevExt);
     183static void     supdrvGipDestroy(PSUPDRVDEVEXT pDevExt);
    172184static DECLCALLBACK(void) supdrvGipTimer(PRTTIMER pTimer, void *pvUser);
    173185#endif
    174186
    175 __END_DECLS
    176 
    177187
    178188/**
    179189 * Initializes the device extentsion structure.
    180190 *
    181  * @returns 0 on success.
    182  * @returns SUPDRV_ERR_ on failure.
     191 * @returns IPRT status code.
    183192 * @param   pDevExt     The device extension to initialize.
    184193 */
    … …  
    203212                if (RT_SUCCESS(rc))
    204213                {
    205                     pDevExt->u32Cookie = BIRD;
    206                     return 0;
     214                    pDevExt->u32Cookie = BIRD;  /** @todo make this random? */
     215                    return VINF_SUCCESS;
    207216                }
    208217#else
    209218                pDevExt->u32Cookie = BIRD;
    210                 return 0;
     219                return VINF_SUCCESS;
    211220#endif
    212221            }
    … …  
    220229}
    221230
     231
    222232/**
    223233 * Delete the device extension (e.g. cleanup members).
    224234 *
    225  * @returns 0.
    226235 * @param   pDevExt     The device extension to delete.
    227236 */
    228 int VBOXCALL supdrvDeleteDevExt(PSUPDRVDEVEXT pDevExt)
     237void VBOXCALL supdrvDeleteDevExt(PSUPDRVDEVEXT pDevExt)
    229238{
    230239#ifndef VBOX_WITHOUT_IDT_PATCHING
    … …  
    247256     * Free lists.
    248257     */
    249 
    250258#ifndef VBOX_WITHOUT_IDT_PATCHING
    251259    /* patches */
    … …  
    288296    supdrvGipDestroy(pDevExt);
    289297#endif
    290 
    291     return 0;
    292298}
    293299
    … …  
    296302 * Create session.
    297303 *
    298  * @returns 0 on success.
    299  * @returns SUPDRV_ERR_ on failure.
     304 * @returns IPRT status code.
    300305 * @param   pDevExt     Device extension.
    301306 * @param   ppSession   Where to store the pointer to the session data.
    … …  
    306311     * Allocate memory for the session data.
    307312     */
    308     int rc = SUPDRV_ERR_NO_MEMORY;
     313    int rc = VERR_NO_MEMORY;
    309314    PSUPDRVSESSION pSession = *ppSession = (PSUPDRVSESSION)RTMemAllocZ(sizeof(*pSession));
    310315    if (pSession)
    … …  
    325330
    326331            dprintf(("Created session %p initial cookie=%#x\n", pSession, pSession->u32Cookie));
    327             return 0;
     332            return VINF_SUCCESS;
    328333        }
    329334
    … …  
    461466         * Check and unlock all entries in the bundle.
    462467         */
    463         for (i = 0; i < sizeof(pBundle->aMem) / sizeof(pBundle->aMem[0]); i++)
     468        for (i = 0; i < RT_ELEMENTS(pBundle->aMem); i++)
    464469        {
    465470#ifdef USE_NEW_OS_INTERFACE_FOR_MM
    … …  
    467472            {
    468473                int rc;
    469                 dprintf2(("eType=%d pvR0=%p pvR3=%p cb=%d\n", pBundle->aMem[i].eType,
    470                           RTR0MemObjAddress(pBundle->aMem[i].MapObj), RTR0MemObjAddressR3(pBundle->aMem[i].MapObjR3), RTR0MemObjSize(pBundle->aMem[i].MemObj)));
     474                dprintf2(("eType=%d pvR0=%p pvR3=%p cb=%ld\n", pBundle->aMem[i].eType, RTR0MemObjAddress(pBundle->aMem[i].MemObj),
     475                          (void *)RTR0MemObjAddressR3(pBundle->aMem[i].MapObjR3), (long)RTR0MemObjSize(pBundle->aMem[i].MemObj)));
    471476                if (pBundle->aMem[i].MapObjR3 != NIL_RTR0MEMOBJ)
    472477                {
    … …  
    571576 * Fast path I/O Control worker.
    572577 *
    573  * @returns 0 on success.
    574  * @returns One of the SUPDRV_ERR_* on failure.
     578 * @returns VBox status code that should be passed down to ring-3 unchanged.
    575579 * @param   uIOCtl      Function number.
    576580 * @param   pDevExt     Device extention.
    577581 * @param   pSession    Session data.
    578582 */
    579 int  VBOXCALL   supdrvIOCtlFast(unsigned uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
     583int VBOXCALL supdrvIOCtlFast(uintptr_t uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
    580584{
    581585    /*
    … …  
    619623 *
    620624 * @returns 0 on success.
    621  * @returns One of the SUPDRV_ERR_* on failure.
     625 * @returns VERR_INVALID_PARAMETER if the request is invalid.
     626 *
    622627 * @param   uIOCtl      Function number.
    623628 * @param   pDevExt     Device extention.
    624629 * @param   pSession    Session data.
    625  * @param   pvIn        Input data.
    626  * @param   cbIn        Size of input data.
    627  * @param   pvOut       Output data.
    628  *                      IMPORTANT! This buffer may be shared with the input
    629  *                                 data, thus no writing before done reading
    630  *                                 input data!!!
    631  * @param   cbOut       Size of output data.
    632  * @param   pcbReturned Size of the returned data.
    633  */
    634 int VBOXCALL supdrvIOCtl(unsigned int uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession,
    635                          void *pvIn, unsigned cbIn, void *pvOut, unsigned cbOut, unsigned *pcbReturned)
    636 {
    637     *pcbReturned = 0;
    638     switch (uIOCtl)
    639     {
    640         case SUP_IOCTL_COOKIE:
    641         {
    642             PSUPCOOKIE_IN  pIn = (PSUPCOOKIE_IN)pvIn;
    643             PSUPCOOKIE_OUT pOut = (PSUPCOOKIE_OUT)pvOut;
    644 
     630 * @param   pReqHdr     The request header.
     631 */
     632int VBOXCALL supdrvIOCtl(uintptr_t uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPREQHDR pReqHdr)
     633{
     634    /*
     635     * Validate the request.
     636     */
     637    /* this first check could probably be omitted as its also done by the OS specific code... */
     638    if (RT_UNLIKELY(    (pReqHdr->fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC
     639                    ||  pReqHdr->cbIn < sizeof(*pReqHdr)
     640                    ||  pReqHdr->cbOut < sizeof(*pReqHdr)))
     641    {
     642        OSDBGPRINT(("vboxdrv: Bad ioctl request header; cbIn=%#lx cbOut=%#lx fFlags=%#lx\n",
     643                    (long)pReqHdr->cbIn, (long)pReqHdr->cbOut, (long)pReqHdr->fFlags));
     644        return VERR_INVALID_PARAMETER;
     645    }
     646    if (RT_UNLIKELY(uIOCtl == SUP_IOCTL_COOKIE))
     647    {
     648        if (pReqHdr->u32Cookie != SUPCOOKIE_INITIAL_COOKIE)
     649        {
     650            OSDBGPRINT(("SUP_IOCTL_COOKIE: bad cookie %#lx\n", (long)pReqHdr->u32Cookie));
     651            return VERR_INVALID_PARAMETER;
     652        }
     653    }
     654    else if (RT_UNLIKELY(    pReqHdr->u32Cookie != pDevExt->u32Cookie
     655                         ||  pReqHdr->u32SessionCookie != pSession->u32Cookie))
     656    {
     657        OSDBGPRINT(("vboxdrv: bad cookie %#lx / %#lx.\n", (long)pReqHdr->u32Cookie, (long)pReqHdr->u32SessionCookie));
     658        return VERR_INVALID_PARAMETER;
     659    }
     660
     661/*
     662 * Validation macros
     663 */
     664#define REQ_CHECK_SIZES_EX(Name, cbInExpect, cbOutExpect) \
     665    do { \
     666        if (RT_UNLIKELY(pReqHdr->cbIn != (cbInExpect) || pReqHdr->cbOut != (cbOutExpect))) \
     667        { \
     668            OSDBGPRINT(( #Name ": Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n", \
     669                        (long)pReq->Hdr.cbIn, (long)(cbInExpect), (long)pReq->Hdr.cbOut, (long)(cbOutExpect))); \
     670            return pReq->Hdr.rc = VERR_INVALID_PARAMETER; \
     671        } \
     672    } while (0)
     673
     674#define REQ_CHECK_SIZES(Name) REQ_CHECK_SIZES_EX(Name, Name ## _SIZE_IN, Name ## _SIZE_OUT)
     675
     676#define REQ_CHECK_SIZE_IN(Name, cbInExpect) \
     677    do { \
     678        if (RT_UNLIKELY(pReqHdr->cbIn != (cbInExpect))) \
     679        { \
     680            OSDBGPRINT(( #Name ": Invalid input/output sizes. cbIn=%ld expected %ld.\n", \
     681                        (long)pReq->Hdr.cbIn, (long)(cbInExpect))); \
     682            return pReq->Hdr.rc = VERR_INVALID_PARAMETER; \
     683        } \
     684    } while (0)
     685
     686#define REQ_CHECK_SIZE_OUT(Name, cbOutExpect) \
     687    do { \
     688        if (RT_UNLIKELY(pReqHdr->cbOut != (cbOutExpect))) \
     689        { \
     690            OSDBGPRINT(( #Name ": Invalid input/output sizes. cbOut=%ld expected %ld.\n", \
     691                        (long)pReq->Hdr.cbOut, (long)(cbOutExpect))); \
     692            return pReq->Hdr.rc = VERR_INVALID_PARAMETER; \
     693        } \
     694    } while (0)
     695
     696#define REQ_CHECK_EXPR(Name, expr) \
     697    do { \
     698        if (RT_UNLIKELY(!(expr))) \
     699        { \
     700            OSDBGPRINT(( #Name ": %s\n", #expr)); \
     701            return pReq->Hdr.rc = VERR_INVALID_PARAMETER; \
     702        } \
     703    } while (0)
     704
     705#define REQ_CHECK_EXPR_FMT(expr, fmt) \
     706    do { \
     707        if (RT_UNLIKELY(!(expr))) \
     708        { \
     709            OSDBGPRINT( fmt ); \
     710            return pReq->Hdr.rc = VERR_INVALID_PARAMETER; \
     711        } \
     712    } while (0)
     713
     714
     715    /*
     716     * The switch.
     717     */
     718    switch (SUP_CTL_CODE_NO_SIZE(uIOCtl))
     719    {
     720        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_COOKIE):
     721        {
     722            PSUPCOOKIE pReq = (PSUPCOOKIE)pReqHdr;
     723            REQ_CHECK_SIZES(SUP_IOCTL_COOKIE);
     724            if (strncmp(pReq->u.In.szMagic, SUPCOOKIE_MAGIC, sizeof(pReq->u.In.szMagic)))
     725            {
     726                OSDBGPRINT(("SUP_IOCTL_COOKIE: invalid magic %.16s\n", pReq->u.In.szMagic));
     727                pReq->Hdr.rc = VERR_INVALID_MAGIC;
     728                return 0;
     729            }
     730
     731#if 0
    645732            /*
    646              * Validate.
     733             * Call out to the OS specific code and let it do permission checks on the
     734             * client process.
    647735             */
    648             if (    cbIn != sizeof(*pIn)
    649                 ||  cbOut != sizeof(*pOut))
     736            if (!supdrvOSValidateClientProcess(pDevExt, pSession))
    650737            {
    651                 OSDBGPRINT(("SUP_IOCTL_COOKIE: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    652                             (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)sizeof(*pOut)));
    653                 return SUPDRV_ERR_INVALID_PARAM;
     738                pReq->u.Out.u32Cookie         = 0xffffffff;
     739                pReq->u.Out.u32SessionCookie  = 0xffffffff;
     740                pReq->u.Out.u32SessionVersion = 0xffffffff;
     741                pReq->u.Out.u32DriverVersion  = SUPDRVIOC_VERSION;
     742                pReq->u.Out.pSession          = NULL;
     743                pReq->u.Out.cFunctions        = 0;
     744                pReq->Hdr.rc = VERR_PERMISSION_DENIED;
     745                return 0;
    654746            }
    655             if (strncmp(pIn->szMagic, SUPCOOKIE_MAGIC, sizeof(pIn->szMagic)))
    656             {
    657                 OSDBGPRINT(("SUP_IOCTL_COOKIE: invalid magic %.16s\n", pIn->szMagic));
    658                 return SUPDRV_ERR_INVALID_MAGIC;
    659             }
     747#endif
    660748
    661749            /*
    … …  
    663751             * The current logic is very simple, match the major interface version.
    664752             */
    665             if (    pIn->u32MinVersion > SUPDRVIOC_VERSION
    666                 ||  (pIn->u32MinVersion & 0xffff0000) != (SUPDRVIOC_VERSION & 0xffff0000))
     753            if (    pReq->u.In.u32MinVersion > SUPDRVIOC_VERSION
     754                ||  (pReq->u.In.u32MinVersion & 0xffff0000) != (SUPDRVIOC_VERSION & 0xffff0000))
    667755            {
    668756                OSDBGPRINT(("SUP_IOCTL_COOKIE: Version mismatch. Requested: %#x  Min: %#x  Current: %#x\n",
    669                             pIn->u32ReqVersion, pIn->u32MinVersion, SUPDRVIOC_VERSION));
    670                 pOut->u32Cookie         = 0xffffffff;
    671                 pOut->u32SessionCookie  = 0xffffffff;
    672                 pOut->u32SessionVersion = 0xffffffff;
    673                 pOut->u32DriverVersion  = SUPDRVIOC_VERSION;
    674                 pOut->pSession          = NULL;
    675                 pOut->cFunctions        = 0;
    676                 *pcbReturned = sizeof(*pOut);
    677                 return SUPDRV_ERR_VERSION_MISMATCH;
     757                            pReq->u.In.u32ReqVersion, pReq->u.In.u32MinVersion, SUPDRVIOC_VERSION));
     758                pReq->u.Out.u32Cookie         = 0xffffffff;
     759                pReq->u.Out.u32SessionCookie  = 0xffffffff;
     760                pReq->u.Out.u32SessionVersion = 0xffffffff;
     761                pReq->u.Out.u32DriverVersion  = SUPDRVIOC_VERSION;
     762                pReq->u.Out.pSession          = NULL;
     763                pReq->u.Out.cFunctions        = 0;
     764                pReq->Hdr.rc = VERR_VERSION_MISMATCH;
     765                return 0;
    678766            }
    679767
    … …  
    683771             *      u32SessionVersion <= u32ReqVersion!
    684772             */
    685             /** @todo A more secure cookie negotiation? */
    686             pOut->u32Cookie         = pDevExt->u32Cookie;
    687             pOut->u32SessionCookie  = pSession->u32Cookie;
    688             pOut->u32SessionVersion = SUPDRVIOC_VERSION;
    689             pOut->u32DriverVersion  = SUPDRVIOC_VERSION;
    690             pOut->pSession          = pSession;
    691             pOut->cFunctions        = sizeof(g_aFunctions) / sizeof(g_aFunctions[0]);
    692             *pcbReturned = sizeof(*pOut);
     773            /** @todo Somehow validate the client and negotiate a secure cookie... */
     774            pReq->u.Out.u32Cookie         = pDevExt->u32Cookie;
     775            pReq->u.Out.u32SessionCookie  = pSession->u32Cookie;
     776            pReq->u.Out.u32SessionVersion = SUPDRVIOC_VERSION;
     777            pReq->u.Out.u32DriverVersion  = SUPDRVIOC_VERSION;
     778            pReq->u.Out.pSession          = pSession;
     779            pReq->u.Out.cFunctions        = sizeof(g_aFunctions) / sizeof(g_aFunctions[0]);
     780            pReq->Hdr.rc = VINF_SUCCESS;
    693781            return 0;
    694782        }
    695783
    696 
    697         case SUP_IOCTL_QUERY_FUNCS:
    698         {
    699             unsigned            cFunctions;
    700             PSUPQUERYFUNCS_IN   pIn = (PSUPQUERYFUNCS_IN)pvIn;
    701             PSUPQUERYFUNCS_OUT  pOut = (PSUPQUERYFUNCS_OUT)pvOut;
    702 
    703             /*
    704              * Validate.
    705              */
    706             if (    cbIn != sizeof(*pIn)
    707                 ||  cbOut < sizeof(*pOut))
     784        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_QUERY_FUNCS(0)):
     785        {
     786            /* validate */
     787            PSUPQUERYFUNCS pReq = (PSUPQUERYFUNCS)pReqHdr;
     788            REQ_CHECK_SIZES_EX(SUP_IOCTL_QUERY_FUNCS, SUP_IOCTL_QUERY_FUNCS_SIZE_IN, SUP_IOCTL_QUERY_FUNCS_SIZE_OUT(RT_ELEMENTS(g_aFunctions)));
     789
     790            /* execute */
     791            pReq->u.Out.cFunctions = RT_ELEMENTS(g_aFunctions);
     792            memcpy(&pReq->u.Out.aFunctions[0], g_aFunctions, sizeof(g_aFunctions));
     793            pReq->Hdr.rc = VINF_SUCCESS;
     794            return 0;
     795        }
     796
     797        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_IDT_INSTALL):
     798        {
     799            /* validate */
     800            PSUPIDTINSTALL pReq = (PSUPIDTINSTALL)pReqHdr;
     801            REQ_CHECK_SIZES(SUP_IOCTL_IDT_INSTALL);
     802
     803            /* execute */
     804#ifndef VBOX_WITHOUT_IDT_PATCHING
     805            pReq->Hdr.rc = supdrvIOCtl_IdtInstall(pDevExt, pSession, pReq);
     806#else
     807            pReq->u.Out.u8Idt = 3;
     808            pReq->Hdr.rc = VERR_NOT_SUPPORTED;
     809#endif
     810            return 0;
     811        }
     812
     813        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_IDT_REMOVE):
     814        {
     815            /* validate */
     816            PSUPIDTREMOVE pReq = (PSUPIDTREMOVE)pReqHdr;
     817            REQ_CHECK_SIZES(SUP_IOCTL_IDT_REMOVE);
     818
     819            /* execute */
     820#ifndef VBOX_WITHOUT_IDT_PATCHING
     821            pReq->Hdr.rc = supdrvIOCtl_IdtRemoveAll(pDevExt, pSession);
     822#else
     823            pReq->Hdr.rc = VERR_NOT_SUPPORTED;
     824#endif
     825            return 0;
     826        }
     827
     828        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_PAGE_LOCK):
     829        {
     830            /* validate */
     831            PSUPPAGELOCK pReq = (PSUPPAGELOCK)pReqHdr;
     832            REQ_CHECK_SIZE_IN(SUP_IOCTL_PAGE_LOCK, SUP_IOCTL_PAGE_LOCK_SIZE_IN);
     833            REQ_CHECK_SIZE_OUT(SUP_IOCTL_PAGE_LOCK, SUP_IOCTL_PAGE_LOCK_SIZE_OUT(pReq->u.In.cPages));
     834            REQ_CHECK_EXPR(SUP_IOCTL_PAGE_LOCK, pReq->u.In.cPages > 0);
     835            REQ_CHECK_EXPR(SUP_IOCTL_PAGE_LOCK, pReq->u.In.pvR3 >= PAGE_SIZE);
     836
     837            /* execute */
     838            pReq->Hdr.rc = SUPR0LockMem(pSession, pReq->u.In.pvR3, pReq->u.In.cPages, &pReq->u.Out.aPages[0]);
     839            if (RT_FAILURE(pReq->Hdr.rc))
     840                pReq->Hdr.cbOut = sizeof(pReq->Hdr);
     841            return 0;
     842        }
     843
     844        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_PAGE_UNLOCK):
     845        {
     846            /* validate */
     847            PSUPPAGEUNLOCK pReq = (PSUPPAGEUNLOCK)pReqHdr;
     848            REQ_CHECK_SIZES(SUP_IOCTL_PAGE_UNLOCK);
     849
     850            /* execute */
     851            pReq->Hdr.rc = SUPR0UnlockMem(pSession, pReq->u.In.pvR3);
     852            return 0;
     853        }
     854
     855        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_CONT_ALLOC):
     856        {
     857            /* validate */
     858            PSUPCONTALLOC pReq = (PSUPCONTALLOC)pReqHdr;
     859            REQ_CHECK_SIZES(SUP_IOCTL_CONT_ALLOC);
     860
     861            /* execute */
     862            pReq->Hdr.rc = SUPR0ContAlloc(pSession, pReq->u.In.cPages, &pReq->u.Out.pvR0, &pReq->u.Out.pvR3, &pReq->u.Out.HCPhys);
     863            if (RT_FAILURE(pReq->Hdr.rc))
     864                pReq->Hdr.cbOut = sizeof(pReq->Hdr);
     865            return 0;
     866        }
     867
     868        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_CONT_FREE):
     869        {
     870            /* validate */
     871            PSUPCONTFREE pReq = (PSUPCONTFREE)pReqHdr;
     872            REQ_CHECK_SIZES(SUP_IOCTL_CONT_FREE);
     873
     874            /* execute */
     875            pReq->Hdr.rc = SUPR0ContFree(pSession, (RTHCUINTPTR)pReq->u.In.pvR3);
     876            return 0;
     877        }
     878
     879        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_LDR_OPEN):
     880        {
     881            /* validate */
     882            PSUPLDROPEN pReq = (PSUPLDROPEN)pReqHdr;
     883            REQ_CHECK_SIZES(SUP_IOCTL_LDR_OPEN);
     884            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImage > 0);
     885            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImage < _1M*16);
     886            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.szName[0]);
     887            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, memchr(pReq->u.In.szName, '\0', sizeof(pReq->u.In.szName)));
     888            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, !strpbrk(pReq->u.In.szName, ";:()[]{}/\\|&*%#@!~`\"'"));
     889
     890            /* execute */
     891            pReq->Hdr.rc = supdrvIOCtl_LdrOpen(pDevExt, pSession, pReq);
     892            return 0;
     893        }
     894
     895        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_LDR_LOAD):
     896        {
     897            /* validate */
     898            PSUPLDRLOAD pReq = (PSUPLDRLOAD)pReqHdr;
     899            REQ_CHECK_EXPR(Name, pReq->Hdr.cbIn >= sizeof(*pReq));
     900            REQ_CHECK_SIZES_EX(SUP_IOCTL_LDR_LOAD, SUP_IOCTL_LDR_LOAD_SIZE_IN(pReq->u.In.cbImage), SUP_IOCTL_LDR_LOAD_SIZE_OUT);
     901            REQ_CHECK_EXPR(SUP_IOCTL_LDR_LOAD, pReq->u.In.cSymbols <= 16384);
     902            REQ_CHECK_EXPR_FMT(     !pReq->u.In.cSymbols
     903                               ||   (   pReq->u.In.offSymbols < pReq->u.In.cbImage
     904                                     && pReq->u.In.offSymbols + pReq->u.In.cSymbols * sizeof(SUPLDRSYM) <= pReq->u.In.cbImage),
     905                               ("SUP_IOCTL_LDR_LOAD: offSymbols=%#lx cSymbols=%#lx cbImage=%#lx\n", (long)pReq->u.In.offSymbols,
     906                                (long)pReq->u.In.cSymbols, (long)pReq->u.In.cbImage));
     907            REQ_CHECK_EXPR_FMT(     !pReq->u.In.cbStrTab
     908                               ||   (   pReq->u.In.offStrTab < pReq->u.In.cbImage
     909                                     && pReq->u.In.offStrTab + pReq->u.In.cbStrTab <= pReq->u.In.cbImage
     910                                     && pReq->u.In.cbStrTab <= pReq->u.In.cbImage),
     911                               ("SUP_IOCTL_LDR_LOAD: offStrTab=%#lx cbStrTab=%#lx cbImage=%#lx\n", (long)pReq->u.In.offStrTab,
     912                                (long)pReq->u.In.cbStrTab, (long)pReq->u.In.cbImage));
     913
     914            if (pReq->u.In.cSymbols)
    708915            {
    709                 dprintf(("SUP_IOCTL_QUERY_FUNCS: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    710                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)sizeof(*pOut)));
    711                 return SUPDRV_ERR_INVALID_PARAM;
    712             }
    713             if (    pIn->u32Cookie != pDevExt->u32Cookie
    714                 ||  pIn->u32SessionCookie != pSession->u32Cookie )
    715             {
    716                 dprintf(("SUP_IOCTL_QUERY_FUNCS: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    717                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    718                 return SUPDRV_ERR_INVALID_MAGIC;
    719             }
    720 
    721             /*
    722              * Copy the functions.
    723              */
    724             cFunctions = (cbOut - RT_OFFSETOF(SUPQUERYFUNCS_OUT, aFunctions)) / sizeof(pOut->aFunctions[0]);
    725             cFunctions = RT_MIN(cFunctions, ELEMENTS(g_aFunctions));
    726             AssertMsg(cFunctions == ELEMENTS(g_aFunctions),
    727                       ("Why aren't R3 querying all the functions!?! cFunctions=%d while there are %d available\n",
    728                        cFunctions, ELEMENTS(g_aFunctions)));
    729             pOut->cFunctions = cFunctions;
    730             memcpy(&pOut->aFunctions[0], g_aFunctions, sizeof(pOut->aFunctions[0]) * cFunctions);
    731             *pcbReturned = RT_OFFSETOF(SUPQUERYFUNCS_OUT, aFunctions[cFunctions]);
    732             return 0;
    733         }
    734 
    735 
    736         case SUP_IOCTL_IDT_INSTALL:
    737         {
    738             PSUPIDTINSTALL_IN   pIn = (PSUPIDTINSTALL_IN)pvIn;
    739             PSUPIDTINSTALL_OUT  pOut = (PSUPIDTINSTALL_OUT)pvOut;
    740 
    741             /*
    742              * Validate.
    743              */
    744             if (    cbIn != sizeof(*pIn)
    745                 ||  cbOut != sizeof(*pOut))
    746             {
    747                 dprintf(("SUP_IOCTL_INSTALL: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    748                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)sizeof(*pOut)));
    749                 return SUPDRV_ERR_INVALID_PARAM;
    750             }
    751             if (    pIn->u32Cookie != pDevExt->u32Cookie
    752                 ||  pIn->u32SessionCookie != pSession->u32Cookie )
    753             {
    754                 dprintf(("SUP_IOCTL_INSTALL: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    755                          pIn->u32Cookie,  pDevExt->u32Cookie,
    756                          pIn->u32SessionCookie, pSession->u32Cookie));
    757                 return SUPDRV_ERR_INVALID_MAGIC;
    758             }
    759 
    760             *pcbReturned = sizeof(*pOut);
    761 #ifndef VBOX_WITHOUT_IDT_PATCHING
    762             return supdrvIOCtl_IdtInstall(pDevExt, pSession, pIn, pOut);
    763 #else
    764             pOut->u8Idt = 3;
    765             return 0;
    766 #endif
    767         }
    768 
    769 
    770         case SUP_IOCTL_IDT_REMOVE:
    771         {
    772             PSUPIDTREMOVE_IN   pIn = (PSUPIDTREMOVE_IN)pvIn;
    773 
    774             /*
    775              * Validate.
    776              */
    777             if (    cbIn != sizeof(*pIn)
    778                 ||  cbOut != 0)
    779             {
    780                 dprintf(("SUP_IOCTL_REMOVE: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    781                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)0));
    782                 return SUPDRV_ERR_INVALID_PARAM;
    783             }
    784             if (    pIn->u32Cookie != pDevExt->u32Cookie
    785                 ||  pIn->u32SessionCookie != pSession->u32Cookie )
    786             {
    787                 dprintf(("SUP_IOCTL_REMOVE: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    788                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    789                 return SUPDRV_ERR_INVALID_MAGIC;
    790             }
    791 
    792 #ifndef VBOX_WITHOUT_IDT_PATCHING
    793             return supdrvIOCtl_IdtRemoveAll(pDevExt, pSession);
    794 #else
    795             return 0;
    796 #endif
    797         }
    798 
    799 
    800         case SUP_IOCTL_PINPAGES:
    801         {
    802             int                 rc;
    803             PSUPPINPAGES_IN     pIn = (PSUPPINPAGES_IN)pvIn;
    804             PSUPPINPAGES_OUT    pOut = (PSUPPINPAGES_OUT)pvOut;
    805 
    806             /*
    807              * Validate.
    808              */
    809             if (    cbIn != sizeof(*pIn)
    810                 ||  cbOut < sizeof(*pOut))
    811             {
    812                 dprintf(("SUP_IOCTL_PINPAGES: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    813                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)sizeof(*pOut)));
    814                 return SUPDRV_ERR_INVALID_PARAM;
    815             }
    816             if (    pIn->u32Cookie != pDevExt->u32Cookie
    817                 ||  pIn->u32SessionCookie != pSession->u32Cookie )
    818             {
    819                 dprintf(("SUP_IOCTL_PINPAGES: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    820                          pIn->u32Cookie,  pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    821                 return SUPDRV_ERR_INVALID_MAGIC;
    822             }
    823             if (pIn->cPages <= 0 || !pIn->pvR3)
    824             {
    825                 dprintf(("SUP_IOCTL_PINPAGES: Illegal request %p %d\n", (void *)pIn->pvR3, pIn->cPages));
    826                 return SUPDRV_ERR_INVALID_PARAM;
    827             }
    828             if ((unsigned)RT_OFFSETOF(SUPPINPAGES_OUT, aPages[pIn->cPages]) > cbOut)
    829             {
    830                 dprintf(("SUP_IOCTL_PINPAGES: Output buffer is too small! %d required %d passed in.\n",
    831                          RT_OFFSETOF(SUPPINPAGES_OUT, aPages[pIn->cPages]), cbOut));
    832                 return SUPDRV_ERR_INVALID_PARAM;
    833             }
    834 
    835             /*
    836              * Execute.
    837              */
    838             *pcbReturned = RT_OFFSETOF(SUPPINPAGES_OUT, aPages[pIn->cPages]);
    839             rc = SUPR0LockMem(pSession, pIn->pvR3, pIn->cPages, &pOut->aPages[0]);
    840             if (rc)
    841                 *pcbReturned = 0;
    842             return rc;
    843         }
    844 
    845 
    846         case SUP_IOCTL_UNPINPAGES:
    847         {
    848             PSUPUNPINPAGES_IN   pIn = (PSUPUNPINPAGES_IN)pvIn;
    849 
    850             /*
    851              * Validate.
    852              */
    853             if (    cbIn != sizeof(*pIn)
    854                 ||  cbOut != 0)
    855             {
    856                 dprintf(("SUP_IOCTL_UNPINPAGES: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    857                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)0));
    858                 return SUPDRV_ERR_INVALID_PARAM;
    859             }
    860             if (    pIn->u32Cookie != pDevExt->u32Cookie
    861                 ||  pIn->u32SessionCookie != pSession->u32Cookie)
    862             {
    863                 dprintf(("SUP_IOCTL_UNPINPAGES: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    864                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    865                 return SUPDRV_ERR_INVALID_MAGIC;
    866             }
    867 
    868             /*
    869              * Execute.
    870              */
    871             return SUPR0UnlockMem(pSession, pIn->pvR3);
    872         }
    873 
    874         case SUP_IOCTL_CONT_ALLOC:
    875         {
    876             int                 rc;
    877             PSUPCONTALLOC_IN    pIn = (PSUPCONTALLOC_IN)pvIn;
    878             PSUPCONTALLOC_OUT   pOut = (PSUPCONTALLOC_OUT)pvOut;
    879 
    880             /*
    881              * Validate.
    882              */
    883             if (    cbIn != sizeof(*pIn)
    884                 ||  cbOut < sizeof(*pOut))
    885             {
    886                 dprintf(("SUP_IOCTL_CONT_ALLOC: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    887                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)sizeof(*pOut)));
    888                 return SUPDRV_ERR_INVALID_PARAM;
    889             }
    890             if (    pIn->u32Cookie != pDevExt->u32Cookie
    891                 ||  pIn->u32SessionCookie != pSession->u32Cookie )
    892             {
    893                 dprintf(("SUP_IOCTL_CONT_ALLOC: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    894                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    895                 return SUPDRV_ERR_INVALID_MAGIC;
    896             }
    897 
    898             /*
    899              * Execute.
    900              */
    901             rc = SUPR0ContAlloc(pSession, pIn->cPages, &pOut->pvR0, &pOut->pvR3, &pOut->HCPhys);
    902             if (!rc)
    903                 *pcbReturned = sizeof(*pOut);
    904             return rc;
    905         }
    906 
    907 
    908         case SUP_IOCTL_CONT_FREE:
    909         {
    910             PSUPCONTFREE_IN   pIn = (PSUPCONTFREE_IN)pvIn;
    911 
    912             /*
    913              * Validate.
    914              */
    915             if (    cbIn != sizeof(*pIn)
    916                 ||  cbOut != 0)
    917             {
    918                 dprintf(("SUP_IOCTL_CONT_FREE: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    919                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)0));
    920                 return SUPDRV_ERR_INVALID_PARAM;
    921             }
    922             if (    pIn->u32Cookie != pDevExt->u32Cookie
    923                 ||  pIn->u32SessionCookie != pSession->u32Cookie)
    924             {
    925                 dprintf(("SUP_IOCTL_CONT_FREE: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    926                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    927                 return SUPDRV_ERR_INVALID_MAGIC;
    928             }
    929 
    930             /*
    931              * Execute.
    932              */
    933             return SUPR0ContFree(pSession, (RTHCUINTPTR)pIn->pvR3);
    934         }
    935 
    936 
    937         case SUP_IOCTL_LDR_OPEN:
    938         {
    939             PSUPLDROPEN_IN  pIn = (PSUPLDROPEN_IN)pvIn;
    940             PSUPLDROPEN_OUT pOut = (PSUPLDROPEN_OUT)pvOut;
    941 
    942             /*
    943              * Validate.
    944              */
    945             if (    cbIn != sizeof(*pIn)
    946                 ||  cbOut != sizeof(*pOut))
    947             {
    948                 dprintf(("SUP_IOCTL_LDR_OPEN: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    949                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)sizeof(*pOut)));
    950                 return SUPDRV_ERR_INVALID_PARAM;
    951             }
    952             if (    pIn->u32Cookie != pDevExt->u32Cookie
    953                 ||  pIn->u32SessionCookie != pSession->u32Cookie)
    954             {
    955                 dprintf(("SUP_IOCTL_LDR_OPEN: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    956                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    957                 return SUPDRV_ERR_INVALID_MAGIC;
    958             }
    959             if (    pIn->cbImage <= 0
    960                 ||  pIn->cbImage >= 16*1024*1024 /*16MB*/)
    961             {
    962                 dprintf(("SUP_IOCTL_LDR_OPEN: Invalid size %d. (max is 16MB)\n", pIn->cbImage));
    963                 return SUPDRV_ERR_INVALID_PARAM;
    964             }
    965             if (!memchr(pIn->szName, '\0', sizeof(pIn->szName)))
    966             {
    967                 dprintf(("SUP_IOCTL_LDR_OPEN: The image name isn't terminated!\n"));
    968                 return SUPDRV_ERR_INVALID_PARAM;
    969             }
    970             if (!pIn->szName[0])
    971             {
    972                 dprintf(("SUP_IOCTL_LDR_OPEN: The image name is too short\n"));
    973                 return SUPDRV_ERR_INVALID_PARAM;
    974             }
    975             if (strpbrk(pIn->szName, ";:()[]{}/\\|&*%#@!~`\"'"))
    976             {
    977                 dprintf(("SUP_IOCTL_LDR_OPEN: The name is invalid '%s'\n", pIn->szName));
    978                 return SUPDRV_ERR_INVALID_PARAM;
    979             }
    980 
    981             *pcbReturned = sizeof(*pOut);
    982             return supdrvIOCtl_LdrOpen(pDevExt, pSession, pIn, pOut);
    983         }
    984 
    985 
    986         case SUP_IOCTL_LDR_LOAD:
    987         {
    988             PSUPLDRLOAD_IN  pIn = (PSUPLDRLOAD_IN)pvIn;
    989 
    990             /*
    991              * Validate.
    992              */
    993             if (    cbIn <= sizeof(*pIn)
    994                 ||  cbOut != 0)
    995             {
    996                 dprintf(("SUP_IOCTL_LDR_LOAD: Invalid input/output sizes. cbIn=%ld expected greater than %ld. cbOut=%ld expected %ld.\n",
    997                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)0));
    998                 return SUPDRV_ERR_INVALID_PARAM;
    999             }
    1000             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1001                 ||  pIn->u32SessionCookie != pSession->u32Cookie)
    1002             {
    1003                 dprintf(("SUP_IOCTL_LDR_LOAD: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1004                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1005                 return SUPDRV_ERR_INVALID_MAGIC;
    1006             }
    1007             if ((unsigned)RT_OFFSETOF(SUPLDRLOAD_IN, achImage[pIn->cbImage]) > cbIn)
    1008             {
    1009                 dprintf(("SUP_IOCTL_LDR_LOAD: Invalid size %d. InputBufferLength=%d\n",
    1010                          pIn->cbImage, cbIn));
    1011                 return SUPDRV_ERR_INVALID_PARAM;
    1012             }
    1013             if (pIn->cSymbols > 16384)
    1014             {
    1015                 dprintf(("SUP_IOCTL_LDR_LOAD: Too many symbols. cSymbols=%u max=16384\n", pIn->cSymbols));
    1016                 return SUPDRV_ERR_INVALID_PARAM;
    1017             }
    1018             if (    pIn->cSymbols
    1019                 &&  (   pIn->offSymbols >= pIn->cbImage
    1020                      || pIn->offSymbols + pIn->cSymbols * sizeof(SUPLDRSYM) > pIn->cbImage)
    1021                )
    1022             {
    1023                 dprintf(("SUP_IOCTL_LDR_LOAD: symbol table is outside the image bits! offSymbols=%u cSymbols=%d cbImage=%d\n",
    1024                          pIn->offSymbols, pIn->cSymbols, pIn->cbImage));
    1025                 return SUPDRV_ERR_INVALID_PARAM;
    1026             }
    1027             if (    pIn->cbStrTab
    1028                 &&  (   pIn->offStrTab >= pIn->cbImage
    1029                      || pIn->offStrTab + pIn->cbStrTab > pIn->cbImage
    1030                      || pIn->offStrTab + pIn->cbStrTab < pIn->offStrTab)
    1031                )
    1032             {
    1033                 dprintf(("SUP_IOCTL_LDR_LOAD: string table is outside the image bits! offStrTab=%u cbStrTab=%d cbImage=%d\n",
    1034                          pIn->offStrTab, pIn->cbStrTab, pIn->cbImage));
    1035                 return SUPDRV_ERR_INVALID_PARAM;
    1036             }
    1037 
    1038             if (pIn->cSymbols)
    1039             {
    1040                 uint32_t    i;
    1041                 PSUPLDRSYM  paSyms = (PSUPLDRSYM)&pIn->achImage[pIn->offSymbols];
    1042                 for (i = 0; i < pIn->cSymbols; i++)
     916                uint32_t i;
     917                PSUPLDRSYM paSyms = (PSUPLDRSYM)&pReq->u.In.achImage[pReq->u.In.offSymbols];
     918                for (i = 0; i < pReq->u.In.cSymbols; i++)
    1043919                {
    1044                     if (paSyms[i].offSymbol >= pIn->cbImage)
    1045                     {
    1046                         dprintf(("SUP_IOCTL_LDR_LOAD: symbol i=%d has an invalid symbol offset: %#x (max=%#x)\n",
    1047                                  i, paSyms[i].offSymbol, pIn->cbImage));
    1048                         return SUPDRV_ERR_INVALID_PARAM;
    1049                     }
    1050                     if (paSyms[i].offName >= pIn->cbStrTab)
    1051                     {
    1052                         dprintf(("SUP_IOCTL_LDR_LOAD: symbol i=%d has an invalid name offset: %#x (max=%#x)\n",
    1053                                  i, paSyms[i].offName, pIn->cbStrTab));
    1054                         return SUPDRV_ERR_INVALID_PARAM;
    1055                     }
    1056                     if (!memchr(&pIn->achImage[pIn->offStrTab + paSyms[i].offName], '\0', pIn->cbStrTab - paSyms[i].offName))
    1057                     {
    1058                         dprintf(("SUP_IOCTL_LDR_LOAD: symbol i=%d has an unterminated name! offName=%#x (max=%#x)\n",
    1059                                  i, paSyms[i].offName, pIn->cbStrTab));
    1060                         return SUPDRV_ERR_INVALID_PARAM;
    1061                     }
     920                    REQ_CHECK_EXPR_FMT(paSyms[i].offSymbol < pReq->u.In.cbImage,
     921                                       ("SUP_IOCTL_LDR_LOAD: sym #%ld: symb off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offSymbol, (long)pReq->u.In.cbImage));
     922                    REQ_CHECK_EXPR_FMT(paSyms[i].offName < pReq->u.In.cbStrTab,
     923                                       ("SUP_IOCTL_LDR_LOAD: sym #%ld: name off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImage));
     924                    REQ_CHECK_EXPR_FMT(memchr(&pReq->u.In.achImage[pReq->u.In.offStrTab + paSyms[i].offName], '\0', pReq->u.In.cbStrTab - paSyms[i].offName),
     925                                       ("SUP_IOCTL_LDR_LOAD: sym #%ld: unterminated name! (%#lx / %#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImage));
    1062926                }
    1063927            }
    1064928
    1065             return supdrvIOCtl_LdrLoad(pDevExt, pSession, pIn);
    1066         }
    1067 
    1068 
    1069         case SUP_IOCTL_LDR_FREE:
    1070         {
    1071             PSUPLDRFREE_IN  pIn = (PSUPLDRFREE_IN)pvIn;
    1072 
    1073             /*
    1074              * Validate.
    1075              */
    1076             if (    cbIn != sizeof(*pIn)
    1077                 ||  cbOut != 0)
     929            /* execute */
     930            pReq->Hdr.rc = supdrvIOCtl_LdrLoad(pDevExt, pSession, pReq);
     931            return 0;
     932        }
     933
     934        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_LDR_FREE):
     935        {
     936            /* validate */
     937            PSUPLDRFREE pReq = (PSUPLDRFREE)pReqHdr;
     938            REQ_CHECK_SIZES(SUP_IOCTL_LDR_FREE);
     939
     940            /* execute */
     941            pReq->Hdr.rc = supdrvIOCtl_LdrFree(pDevExt, pSession, pReq);
     942            return 0;
     943        }
     944
     945        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_LDR_GET_SYMBOL):
     946        {
     947            /* validate */
     948            PSUPLDRGETSYMBOL pReq = (PSUPLDRGETSYMBOL)pReqHdr;
     949            REQ_CHECK_SIZES(SUP_IOCTL_LDR_GET_SYMBOL);
     950            REQ_CHECK_EXPR(SUP_IOCTL_LDR_GET_SYMBOL, memchr(pReq->u.In.szSymbol, '\0', sizeof(pReq->u.In.szSymbol)));
     951
     952            /* execute */
     953            pReq->Hdr.rc = supdrvIOCtl_LdrGetSymbol(pDevExt, pSession, pReq);
     954            return 0;
     955        }
     956
     957        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_CALL_VMMR0(0)):
     958        {
     959            /* validate */
     960            PSUPCALLVMMR0 pReq = (PSUPCALLVMMR0)pReqHdr;
     961            if (pReq->Hdr.cbIn == SUP_IOCTL_CALL_VMMR0(0))
    1078962            {
    1079                 dprintf(("SUP_IOCTL_LDR_FREE: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    1080                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)0));
    1081                 return SUPDRV_ERR_INVALID_PARAM;
     963                REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_VMMR0, SUP_IOCTL_CALL_VMMR0_SIZE_IN(0), SUP_IOCTL_CALL_VMMR0_SIZE_OUT(0));
     964
     965                /* execute */
     966                if (RT_LIKELY(pDevExt->pfnVMMR0Entry))
     967                    pReq->Hdr.rc = pDevExt->pfnVMMR0Entry(pReq->u.In.pVMR0, pReq->u.In.uOperation, (void *)pReq->u.In.uArg);
     968                else
     969                    pReq->Hdr.rc = VERR_WRONG_ORDER;
    1082970            }
    1083             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1084                 ||  pIn->u32SessionCookie != pSession->u32Cookie)
     971            else
    1085972            {
    1086                 dprintf(("SUP_IOCTL_LDR_FREE: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1087                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1088                 return SUPDRV_ERR_INVALID_MAGIC;
     973                PSUPVMMR0REQHDR pVMMReq = (PSUPVMMR0REQHDR)&pReq->abReqPkt[0];
     974                REQ_CHECK_EXPR(SUP_IOCTL_CALL_VMMR0, pReq->Hdr.cbIn >= SUP_IOCTL_CALL_VMMR0_SIZE(sizeof(SUPVMMR0REQHDR)));
     975                REQ_CHECK_EXPR(SUP_IOCTL_CALL_VMMR0, pVMMReq->u32Magic == SUPVMMR0REQHDR_MAGIC);
     976                REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_VMMR0, SUP_IOCTL_CALL_VMMR0_SIZE_IN(pVMMReq->cbReq), SUP_IOCTL_CALL_VMMR0_SIZE_OUT(pVMMReq->cbReq));
     977
     978                /* execute */
     979                if (RT_LIKELY(pDevExt->pfnVMMR0Entry))
     980                    pReq->Hdr.rc = pDevExt->pfnVMMR0Entry(pReq->u.In.pVMR0, pReq->u.In.uOperation, pVMMReq);
     981                else
     982                    pReq->Hdr.rc = VERR_WRONG_ORDER;
    1089983            }
    1090 
    1091             return supdrvIOCtl_LdrFree(pDevExt, pSession, pIn);
    1092         }
    1093 
    1094 
    1095         case SUP_IOCTL_LDR_GET_SYMBOL:
    1096         {
    1097             PSUPLDRGETSYMBOL_IN  pIn  = (PSUPLDRGETSYMBOL_IN)pvIn;
    1098             PSUPLDRGETSYMBOL_OUT pOut = (PSUPLDRGETSYMBOL_OUT)pvOut;
    1099             char                *pszEnd;
    1100 
    1101             /*
    1102              * Validate.
    1103              */
    1104             if (    cbIn < (unsigned)RT_OFFSETOF(SUPLDRGETSYMBOL_IN, szSymbol[2])
    1105                 ||  cbOut != sizeof(*pOut))
    1106             {
    1107                 dprintf(("SUP_IOCTL_LDR_GET_SYMBOL: Invalid input/output sizes. cbIn=%d expected >=%d. cbOut=%d expected at%d.\n",
    1108                          cbIn, RT_OFFSETOF(SUPLDRGETSYMBOL_IN, szSymbol[2]), cbOut, 0));
    1109                 return SUPDRV_ERR_INVALID_PARAM;
    1110             }
    1111             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1112                 ||  pIn->u32SessionCookie != pSession->u32Cookie)
    1113             {
    1114                 dprintf(("SUP_IOCTL_LDR_GET_SYMBOL: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1115                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1116                 return SUPDRV_ERR_INVALID_MAGIC;
    1117             }
    1118             pszEnd = memchr(pIn->szSymbol, '\0', cbIn - RT_OFFSETOF(SUPLDRGETSYMBOL_IN, szSymbol));
    1119             if (!pszEnd)
    1120             {
    1121                 dprintf(("SUP_IOCTL_LDR_GET_SYMBOL: The symbol name isn't terminated!\n"));
    1122                 return SUPDRV_ERR_INVALID_PARAM;
    1123             }
    1124             if (pszEnd - &pIn->szSymbol[0] >= 1024)
    1125             {
    1126                 dprintf(("SUP_IOCTL_LDR_GET_SYMBOL: The symbol name too long (%ld chars, max is %d)!\n",
    1127                          (long)(pszEnd - &pIn->szSymbol[0]), 1024));
    1128                 return SUPDRV_ERR_INVALID_PARAM;
    1129             }
    1130 
    1131             pOut->pvSymbol = NULL;
    1132             *pcbReturned = sizeof(*pOut);
    1133             return supdrvIOCtl_LdrGetSymbol(pDevExt, pSession, pIn, pOut);
    1134         }
    1135 
    1136 
    1137         /** @todo this interface needs re-doing, we're accessing Ring-3 buffers directly here! */
    1138         case SUP_IOCTL_CALL_VMMR0:
    1139         {
    1140             PSUPCALLVMMR0_IN    pIn = (PSUPCALLVMMR0_IN)pvIn;
    1141             PSUPCALLVMMR0_OUT   pOut = (PSUPCALLVMMR0_OUT)pvOut;
    1142             RTCCUINTREG         uFlags;
    1143 
    1144             /*
    1145              * Validate.
    1146              */
    1147             if (    cbIn != sizeof(*pIn)
    1148                 ||  cbOut != sizeof(*pOut))
    1149             {
    1150                 dprintf(("SUP_IOCTL_CALL_VMMR0: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    1151                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)sizeof(*pOut)));
    1152                 return SUPDRV_ERR_INVALID_PARAM;
    1153             }
    1154             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1155                 ||  pIn->u32SessionCookie != pSession->u32Cookie )
    1156             {
    1157                 dprintf(("SUP_IOCTL_CALL_VMMR0: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1158                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1159                 return SUPDRV_ERR_INVALID_MAGIC;
    1160             }
    1161 
    1162             /*
    1163              * Do we have an entrypoint?
    1164              */
    1165             if (!pDevExt->pfnVMMR0Entry)
    1166                 return SUPDRV_ERR_GENERAL_FAILURE;
    1167 
    1168             /*
    1169              * Execute.
    1170              */
    1171             uFlags = ASMGetFlags();
    1172             ASMIntDisable();
    1173             pOut->rc = pDevExt->pfnVMMR0Entry(pIn->pVMR0, pIn->uOperation, (void *)pIn->pvArg); /** @todo address the pvArg problem! */
    1174             ASMSetFlags(uFlags);
    1175             *pcbReturned = sizeof(*pOut);
    1176984            return 0;
    1177985        }
    1178986
    1179 
    1180         case SUP_IOCTL_GET_PAGING_MODE:
    1181         {
    1182             int                     rc;
    1183             PSUPGETPAGINGMODE_IN    pIn = (PSUPGETPAGINGMODE_IN)pvIn;
    1184             PSUPGETPAGINGMODE_OUT   pOut = (PSUPGETPAGINGMODE_OUT)pvOut;
    1185 
    1186             /*
    1187              * Validate.
    1188              */
    1189             if (    cbIn != sizeof(*pIn)
    1190                 ||  cbOut != sizeof(*pOut))
    1191             {
    1192                 dprintf(("SUP_IOCTL_GET_PAGING_MODE: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    1193                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)sizeof(*pOut)));
    1194                 return SUPDRV_ERR_INVALID_PARAM;
    1195             }
    1196             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1197                 ||  pIn->u32SessionCookie != pSession->u32Cookie )
    1198             {
    1199                 dprintf(("SUP_IOCTL_GET_PAGING_MODE: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1200                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1201                 return SUPDRV_ERR_INVALID_MAGIC;
    1202             }
    1203 
    1204             /*
    1205              * Execute.
    1206              */
    1207             *pcbReturned = sizeof(*pOut);
    1208             rc = supdrvIOCtl_GetPagingMode(pOut);
    1209             if (rc)
    1210                 *pcbReturned = 0;
    1211             return rc;
    1212         }
    1213 
    1214 
    1215         case SUP_IOCTL_LOW_ALLOC:
    1216         {
    1217             int                 rc;
    1218             PSUPLOWALLOC_IN     pIn = (PSUPLOWALLOC_IN)pvIn;
    1219             PSUPLOWALLOC_OUT    pOut = (PSUPLOWALLOC_OUT)pvOut;
    1220 
    1221             /*
    1222              * Validate.
    1223              */
    1224             if (    cbIn != sizeof(*pIn)
    1225                 ||  cbOut < sizeof(*pOut))
    1226             {
    1227                 dprintf(("SUP_IOCTL_LOW_ALLOC: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    1228                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)sizeof(*pOut)));
    1229                 return SUPDRV_ERR_INVALID_PARAM;
    1230             }
    1231             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1232                 ||  pIn->u32SessionCookie != pSession->u32Cookie )
    1233             {
    1234                 dprintf(("SUP_IOCTL_LOW_ALLOC: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1235                          pIn->u32Cookie,  pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1236                 return SUPDRV_ERR_INVALID_MAGIC;
    1237             }
    1238             if ((unsigned)RT_OFFSETOF(SUPLOWALLOC_OUT, aPages[pIn->cPages]) > cbOut)
    1239             {
    1240                 dprintf(("SUP_IOCTL_LOW_ALLOC: Output buffer is too small! %d required %d passed in.\n",
    1241                          RT_OFFSETOF(SUPLOWALLOC_OUT, aPages[pIn->cPages]), cbOut));
    1242                 return SUPDRV_ERR_INVALID_PARAM;
    1243             }
    1244 
    1245             /*
    1246              * Execute.
    1247              */
    1248             *pcbReturned = RT_OFFSETOF(SUPLOWALLOC_OUT, aPages[pIn->cPages]);
    1249             rc = SUPR0LowAlloc(pSession, pIn->cPages, &pOut->pvR0, &pOut->pvR3, &pOut->aPages[0]);
    1250             if (rc)
    1251                 *pcbReturned = 0;
    1252             return rc;
    1253         }
    1254 
    1255 
    1256         case SUP_IOCTL_LOW_FREE:
    1257         {
    1258             PSUPLOWFREE_IN  pIn = (PSUPLOWFREE_IN)pvIn;
    1259 
    1260             /*
    1261              * Validate.
    1262              */
    1263             if (    cbIn != sizeof(*pIn)
    1264                 ||  cbOut != 0)
    1265             {
    1266                 dprintf(("SUP_IOCTL_LOW_FREE: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    1267                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)0));
    1268                 return SUPDRV_ERR_INVALID_PARAM;
    1269             }
    1270             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1271                 ||  pIn->u32SessionCookie != pSession->u32Cookie)
    1272             {
    1273                 dprintf(("SUP_IOCTL_LOW_FREE: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1274                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1275                 return SUPDRV_ERR_INVALID_MAGIC;
    1276             }
    1277 
    1278             /*
    1279              * Execute.
    1280              */
    1281             return SUPR0LowFree(pSession, (RTHCUINTPTR)pIn->pvR3);
    1282         }
    1283 
    1284 
    1285         case SUP_IOCTL_GIP_MAP:
    1286         {
    1287             int             rc;
    1288             PSUPGIPMAP_IN   pIn = (PSUPGIPMAP_IN)pvIn;
    1289             PSUPGIPMAP_OUT  pOut = (PSUPGIPMAP_OUT)pvOut;
    1290 
    1291             /*
    1292              * Validate.
    1293              */
    1294             if (    cbIn != sizeof(*pIn)
    1295                 ||  cbOut != sizeof(*pOut))
    1296             {
    1297                 dprintf(("SUP_IOCTL_GIP_MAP: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    1298                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)0));
    1299                 return SUPDRV_ERR_INVALID_PARAM;
    1300             }
    1301             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1302                 ||  pIn->u32SessionCookie != pSession->u32Cookie)
    1303             {
    1304                 dprintf(("SUP_IOCTL_GIP_MAP: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1305                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1306                 return SUPDRV_ERR_INVALID_MAGIC;
    1307             }
    1308 
    1309             /*
    1310              * Execute.
    1311              */
    1312             rc = SUPR0GipMap(pSession, &pOut->pGipR3, &pOut->HCPhysGip);
    1313             if (!rc)
    1314             {
    1315                 pOut->pGipR0 = pDevExt->pGip;
    1316                 *pcbReturned = sizeof(*pOut);
    1317             }
    1318             return rc;
    1319         }
    1320 
    1321 
    1322         case SUP_IOCTL_GIP_UNMAP:
    1323         {
    1324             PSUPGIPUNMAP_IN pIn = (PSUPGIPUNMAP_IN)pvIn;
    1325 
    1326             /*
    1327              * Validate.
    1328              */
    1329             if (    cbIn != sizeof(*pIn)
    1330                 ||  cbOut != 0)
    1331             {
    1332                 dprintf(("SUP_IOCTL_GIP_UNMAP: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    1333                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)0));
    1334                 return SUPDRV_ERR_INVALID_PARAM;
    1335             }
    1336             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1337                 ||  pIn->u32SessionCookie != pSession->u32Cookie)
    1338             {
    1339                 dprintf(("SUP_IOCTL_GIP_UNMAP: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1340                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1341                 return SUPDRV_ERR_INVALID_MAGIC;
    1342             }
    1343 
    1344             /*
    1345              * Execute.
    1346              */
    1347             return SUPR0GipUnmap(pSession);
    1348         }
    1349 
    1350 
    1351         case SUP_IOCTL_SET_VM_FOR_FAST:
    1352         {
    1353             PSUPSETVMFORFAST_IN pIn = (PSUPSETVMFORFAST_IN)pvIn;
    1354 
    1355             /*
    1356              * Validate.
    1357              */
    1358             if (    cbIn != sizeof(*pIn)
    1359                 ||  cbOut != 0)
    1360             {
    1361                 dprintf(("SUP_IOCTL_SET_VM_FOR_FAST: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    1362                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)0));
    1363                 return SUPDRV_ERR_INVALID_PARAM;
    1364             }
    1365             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1366                 ||  pIn->u32SessionCookie != pSession->u32Cookie)
    1367             {
    1368                 dprintf(("SUP_IOCTL_SET_VM_FOR_FAST: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1369                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1370                 return SUPDRV_ERR_INVALID_MAGIC;
    1371             }
    1372             if (    pIn->pVMR0 != NULL
    1373                 && (    !VALID_PTR(pIn->pVMR0)
    1374                     ||  ((uintptr_t)pIn->pVMR0 & (PAGE_SIZE - 1))
    1375                    )
    1376                 )
    1377             {
    1378                 dprintf(("SUP_IOCTL_SET_VM_FOR_FAST: pVMR0=%p! Must be a valid, page aligned, pointer.\n", pIn->pVMR0));
    1379                 return SUPDRV_ERR_INVALID_POINTER;
    1380             }
    1381 
    1382             /*
    1383              * Execute.
    1384              */
     987        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_GET_PAGING_MODE):
     988        {
     989            /* validate */
     990            PSUPGETPAGINGMODE pReq = (PSUPGETPAGINGMODE)pReqHdr;
     991            REQ_CHECK_SIZES(SUP_IOCTL_GET_PAGING_MODE);
     992
     993            /* execute */
     994            pReq->Hdr.rc = VINF_SUCCESS;
     995            pReq->u.Out.enmMode = supdrvIOCtl_GetPagingMode();
     996            return 0;
     997        }
     998
     999        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_LOW_ALLOC):
     1000        {
     1001            /* validate */
     1002            PSUPLOWALLOC pReq = (PSUPLOWALLOC)pReqHdr;
     1003            REQ_CHECK_EXPR(SUP_IOCTL_LOW_ALLOC, pReq->Hdr.cbIn <= SUP_IOCTL_LOW_ALLOC_SIZE_IN);
     1004            REQ_CHECK_SIZES_EX(SUP_IOCTL_LOW_ALLOC, SUP_IOCTL_LOW_ALLOC_SIZE_IN, SUP_IOCTL_LOW_ALLOC_SIZE_OUT(pReq->u.In.cPages));
     1005
     1006            /* execute */
     1007            pReq->Hdr.rc = SUPR0LowAlloc(pSession, pReq->u.In.cPages, &pReq->u.Out.pvR0, &pReq->u.Out.pvR3, &pReq->u.Out.aPages[0]);
     1008            if (RT_FAILURE(pReq->Hdr.rc))
     1009                pReq->Hdr.cbOut = sizeof(pReq->Hdr);
     1010            return 0;
     1011        }
     1012
     1013        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_LOW_FREE):
     1014        {
     1015            /* validate */
     1016            PSUPLOWFREE pReq = (PSUPLOWFREE)pReqHdr;
     1017            REQ_CHECK_SIZES(SUP_IOCTL_LOW_FREE);
     1018
     1019            /* execute */
     1020            pReq->Hdr.rc = SUPR0LowFree(pSession, (RTHCUINTPTR)pReq->u.In.pvR3);
     1021            return 0;
     1022        }
     1023
     1024        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_GIP_MAP):
     1025        {
     1026            /* validate */
     1027            PSUPGIPMAP pReq = (PSUPGIPMAP)pReqHdr;
     1028            REQ_CHECK_SIZES(SUP_IOCTL_GIP_MAP);
     1029
     1030            /* execute */
     1031            pReq->Hdr.rc = SUPR0GipMap(pSession, &pReq->u.Out.pGipR3, &pReq->u.Out.HCPhysGip);
     1032            if (RT_SUCCESS(pReq->Hdr.rc))
     1033                pReq->u.Out.pGipR0 = pDevExt->pGip;
     1034            return 0;
     1035        }
     1036
     1037        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_GIP_UNMAP):
     1038        {
     1039            /* validate */
     1040            PSUPGIPUNMAP pReq = (PSUPGIPUNMAP)pReqHdr;
     1041            REQ_CHECK_SIZES(SUP_IOCTL_GIP_UNMAP);
     1042
     1043            /* execute */
     1044            pReq->Hdr.rc = SUPR0GipUnmap(pSession);
     1045            return 0;
     1046        }
     1047
     1048        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_SET_VM_FOR_FAST):
     1049        {
     1050            /* validate */
     1051            PSUPSETVMFORFAST pReq = (PSUPSETVMFORFAST)pReqHdr;
     1052            REQ_CHECK_SIZES(SUP_IOCTL_SET_VM_FOR_FAST);
     1053            REQ_CHECK_EXPR_FMT(     !pReq->u.In.pVMR0
     1054                               ||   (   VALID_PTR(pReq->u.In.pVMR0)
     1055                                     && !((uintptr_t)pReq->u.In.pVMR0 & (PAGE_SIZE - 1))),
     1056                               ("SUP_IOCTL_SET_VM_FOR_FAST: pVMR0=%p!\n", pReq->u.In.pVMR0));
     1057            /* execute */
    13851058#ifndef VBOX_WITHOUT_IDT_PATCHING
    13861059            OSDBGPRINT(("SUP_IOCTL_SET_VM_FOR_FAST: !VBOX_WITHOUT_IDT_PATCHING\n"));
    1387             return SUPDRV_ERR_GENERAL_FAILURE;
     1060            pReq->Hdr.rc = VERR_NOT_SUPPORTED;
    13881061#else
    1389             pSession->pVM = pIn->pVMR0;
     1062            pSession->pVM = pReq->u.In.pVMR0;
     1063            pReq->Hdr.rc = VINF_SUCCESS;
     1064#endif
    13901065            return 0;
    1391 #endif
    13921066        }
    13931067
    13941068#ifdef USE_NEW_OS_INTERFACE_FOR_MM
    1395         case SUP_IOCTL_PAGE_ALLOC:
    1396         {
    1397             int               rc;
    1398             PSUPALLOCPAGE_IN  pIn  = (PSUPALLOCPAGE_IN)pvIn;
    1399             PSUPALLOCPAGE_OUT pOut = (PSUPALLOCPAGE_OUT)pvOut;
    1400 
    1401             /*
    1402              * Validate.
    1403              */
    1404             if (    cbIn != sizeof(*pIn)
    1405                 ||  cbOut < sizeof(*pOut))
    1406             {
    1407                 dprintf(("SUP_IOCTL_PAGE_ALLOC: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    1408                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)sizeof(*pOut)));
    1409                 return SUPDRV_ERR_INVALID_PARAM;
    1410             }
    1411             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1412                 ||  pIn->u32SessionCookie != pSession->u32Cookie
    1413                 ||  pOut->u32Cookie != pDevExt->u32Cookie)
    1414             {
    1415                 dprintf(("SUP_IOCTL_PAGE_ALLOC: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1416                          pIn->u32Cookie,  pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1417                 return SUPDRV_ERR_INVALID_MAGIC;
    1418             }
    1419             /*
    1420              * Execute.
    1421              */
    1422             *pcbReturned = sizeof(*pOut);
    1423             rc = SUPR0PageAlloc(pSession, pIn->cPages, &pOut->pvR3);
    1424             if (rc)
    1425                 *pcbReturned = 0;
    1426             return rc;
    1427         }
    1428 
    1429         case SUP_IOCTL_PAGE_FREE:
    1430         {
    1431             PSUPFREEPAGE_IN pIn = (PSUPFREEPAGE_IN)pvIn;
    1432 
    1433             /*
    1434              * Validate.
    1435              */
    1436             if (    cbIn != sizeof(*pIn)
    1437                 ||  cbOut != 0)
    1438             {
    1439                 dprintf(("SUP_IOCTL_PAGE_FREE: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
    1440                          (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)0));
    1441                 return SUPDRV_ERR_INVALID_PARAM;
    1442             }
    1443             if (    pIn->u32Cookie != pDevExt->u32Cookie
    1444                 ||  pIn->u32SessionCookie != pSession->u32Cookie)
    1445             {
    1446                 dprintf(("SUP_IOCTL_PAGE_FREE: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
    1447                          pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
    1448                 return SUPDRV_ERR_INVALID_MAGIC;
    1449             }
    1450             /*
    1451              * Execute.
    1452              */
    1453             return SUPR0PageFree(pSession, (RTHCUINTPTR)pIn->pvR3);
     1069        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_PAGE_ALLOC):
     1070        {
     1071            /* validate */
     1072            PSUPPAGEALLOC pReq = (PSUPPAGEALLOC)pReqHdr;
     1073            REQ_CHECK_EXPR(SUP_IOCTL_PAGE_ALLOC, pReq->Hdr.cbIn <= SUP_IOCTL_PAGE_ALLOC_SIZE_IN);
     1074            REQ_CHECK_SIZES_EX(SUP_IOCTL_PAGE_ALLOC, SUP_IOCTL_PAGE_ALLOC_SIZE_IN, SUP_IOCTL_PAGE_ALLOC_SIZE_OUT(pReq->u.In.cPages));
     1075
     1076            /* execute */
     1077            pReq->Hdr.rc = SUPR0PageAlloc(pSession, pReq->u.In.cPages, &pReq->u.Out.pvR3, &pReq->u.Out.aPages[0]);
     1078            if (RT_FAILURE(pReq->Hdr.rc))
     1079                pReq->Hdr.cbOut = sizeof(pReq->Hdr);
     1080            return 0;
     1081        }
     1082
     1083        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_PAGE_FREE):
     1084        {
     1085            /* validate */
     1086            PSUPPAGEFREE pReq = (PSUPPAGEFREE)pReqHdr;
     1087            REQ_CHECK_SIZES(SUP_IOCTL_PAGE_FREE);
     1088
     1089            /* execute */
     1090            pReq->Hdr.rc = SUPR0PageFree(pSession, pReq->u.In.pvR3);
     1091            return 0;
    14541092        }
    14551093#endif /* USE_NEW_OS_INTERFACE_FOR_MM */
    14561094
    14571095        default:
    1458             dprintf(("Unknown IOCTL %#x\n", uIOCtl));
     1096            dprintf(("Unknown IOCTL %#lx\n", (long)uIOCtl));
    14591097            break;
    14601098    }
    … …  
    14841122     * Validate the input.
    14851123     */
    1486     if (!pSession)
    1487     {
    1488         AssertMsgFailed(("Invalid pSession=%p\n", pSession));
    1489         return NULL;
    1490     }
    1491     if (    enmType <= SUPDRVOBJTYPE_INVALID
    1492         ||  enmType >= SUPDRVOBJTYPE_END)
    1493     {
    1494         AssertMsgFailed(("Invalid enmType=%d\n", enmType));
    1495         return NULL;
    1496     }
    1497     if (!pfnDestructor)
    1498     {
    1499         AssertMsgFailed(("Invalid pfnDestructor=%d\n", pfnDestructor));
    1500         return NULL;
    1501     }
     1124    AssertReturn(SUP_IS_SESSION_VALID(pSession), NULL);
     1125    AssertReturn(enmType > SUPDRVOBJTYPE_INVALID && enmType < SUPDRVOBJTYPE_END, NULL);
     1126    AssertPtrReturn(pfnDestructor, NULL);
    15021127
    15031128    /*
    … …  
    15651190 * with the specified session.
    15661191 *
    1567  * @returns 0 on success.
    1568  * @returns SUPDRV_ERR_* on failure.
     1192 * @returns IPRT status code.
    15691193 * @param   pvObj           The identifier returned by SUPR0ObjRegister().
    15701194 * @param   pSession        The session which is referencing the object.
    … …  
    15811205     * Validate the input.
    15821206     */
    1583     if (!pSession)
    1584     {
    1585         AssertMsgFailed(("Invalid pSession=%p\n", pSession));
    1586         return SUPDRV_ERR_INVALID_PARAM;
    1587     }
    1588     if (!pObj || pObj->u32Magic != SUPDRVOBJ_MAGIC)
    1589     {
    1590         AssertMsgFailed(("Invalid pvObj=%p magic=%#x (exepcted %#x)\n",
    1591                          pvObj, pObj ? pObj->u32Magic : 0, SUPDRVOBJ_MAGIC));
    1592         return SUPDRV_ERR_INVALID_PARAM;
    1593     }
     1207    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     1208    AssertMsgReturn(VALID_PTR(pObj) && pObj->u32Magic == SUPDRVOBJ_MAGIC,
     1209                    ("Invalid pvObj=%p magic=%#x (exepcted %#x)\n", pvObj, pObj ? pObj->u32Magic : 0, SUPDRVOBJ_MAGIC),
     1210                    VERR_INVALID_PARAMETER);
    15941211
    15951212    /*
    … …  
    16061223        pUsagePre = (PSUPDRVUSAGE)RTMemAlloc(sizeof(*pUsagePre));
    16071224        if (!pUsagePre)
    1608             return SUPDRV_ERR_NO_MEMORY;
     1225            return VERR_NO_MEMORY;
    16091226        RTSpinlockAcquire(pDevExt->Spinlock, &SpinlockTmp);
    16101227    }
    … …  
    16491266    RTSpinlockRelease(pDevExt->Spinlock, &SpinlockTmp);
    16501267
    1651     return 0;
     1268    return VINF_SUCCESS;
    16521269}
    16531270
    … …  
    16581275 * The object is uniquely identified by pfnDestructor+pvUser1+pvUser2.
    16591276 *
    1660  * @returns 0 on success.
    1661  * @returns SUPDRV_ERR_* on failure.
     1277 * @returns IPRT status code.
    16621278 * @param   pvObj           The identifier returned by SUPR0ObjRegister().
    16631279 * @param   pSession        The session which is referencing the object.
    … …  
    16751291     * Validate the input.
    16761292     */
    1677     if (!pSession)
    1678     {
    1679         AssertMsgFailed(("Invalid pSession=%p\n", pSession));
    1680         return SUPDRV_ERR_INVALID_PARAM;
    1681     }
    1682     if (!pObj || pObj->u32Magic != SUPDRVOBJ_MAGIC)
    1683     {
    1684         AssertMsgFailed(("Invalid pvObj=%p magic=%#x (exepcted %#x)\n",
    1685                          pvObj, pObj ? pObj->u32Magic : 0, SUPDRVOBJ_MAGIC));
    1686         return SUPDRV_ERR_INVALID_PARAM;
    1687     }
     1293    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     1294    AssertMsgReturn(VALID_PTR(pObj) && pObj->u32Magic == SUPDRVOBJ_MAGIC,
     1295                    ("Invalid pvObj=%p magic=%#x (exepcted %#x)\n", pvObj, pObj ? pObj->u32Magic : 0, SUPDRVOBJ_MAGIC),
     1296                    VERR_INVALID_PARAMETER);
    16881297
    16891298    /*
    … …  
    17581367
    17591368    AssertMsg(pUsage, ("pvObj=%p\n", pvObj));
    1760     return pUsage ? 0 : SUPDRV_ERR_INVALID_PARAM;
     1369    return pUsage ? VINF_SUCCESS : VERR_INVALID_PARAMETER;
    17611370}
    17621371
    … …  
    17641373 * Verifies that the current process can access the specified object.
    17651374 *
    1766  * @returns 0 if access is granted.
    1767  * @returns SUPDRV_ERR_PERMISSION_DENIED if denied access.
    1768  * @returns SUPDRV_ERR_INVALID_PARAM if invalid parameter.
     1375 * @returns The following IPRT status code:
     1376 * @retval  VINF_SUCCESS if access was granted.
     1377 * @retval  VERR_PERMISSION_DENIED if denied access.
     1378 * @retval  VERR_INVALID_PARAMETER if invalid parameter.
    17691379 *
    17701380 * @param   pvObj           The identifier returned by SUPR0ObjRegister().
    … …  
    17781388{
    17791389    PSUPDRVOBJ  pObj = (PSUPDRVOBJ)pvObj;
    1780     int         rc   = SUPDRV_ERR_GENERAL_FAILURE;
     1390    int         rc;
    17811391
    17821392    /*
    17831393     * Validate the input.
    17841394     */
    1785     if (!pSession)
    1786     {
    1787         AssertMsgFailed(("Invalid pSession=%p\n", pSession));
    1788         return SUPDRV_ERR_INVALID_PARAM;
    1789     }
    1790     if (!pObj || pObj->u32Magic != SUPDRVOBJ_MAGIC)
    1791     {
    1792         AssertMsgFailed(("Invalid pvObj=%p magic=%#x (exepcted %#x)\n",
    1793                          pvObj, pObj ? pObj->u32Magic : 0, SUPDRVOBJ_MAGIC));
    1794         return SUPDRV_ERR_INVALID_PARAM;
    1795     }
     1395    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     1396    AssertMsgReturn(VALID_PTR(pObj) && pObj->u32Magic == SUPDRVOBJ_MAGIC,
     1397                    ("Invalid pvObj=%p magic=%#x (exepcted %#x)\n", pvObj, pObj ? pObj->u32Magic : 0, SUPDRVOBJ_MAGIC),
     1398                    VERR_INVALID_PARAMETER);
    17961399
    17971400    /*
    17981401     * Check access. (returns true if a decision has been made.)
    17991402     */
     1403    rc = VERR_INTERNAL_ERROR;
    18001404    if (supdrvOSObjCanAccess(pObj, pSession, pszObjName, &rc))
    18011405        return rc;
    … …  
    18061410     */
    18071411    if (pObj->CreatorUid == pSession->Uid)
    1808         return 0;
    1809     return SUPDRV_ERR_PERMISSION_DENIED;
     1412        return VINF_SUCCESS;
     1413    return VERR_PERMISSION_DENIED;
    18101414}
    18111415
    … …  
    18141418 * Lock pages.
    18151419 *
     1420 * @returns IPRT status code.
    18161421 * @param   pSession    Session to which the locked memory should be associated.
    18171422 * @param   pvR3        Start of the memory range to lock.
    … …  
    18201425 *                      This must be page aligned.
    18211426 */
    1822 SUPR0DECL(int) SUPR0LockMem(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PSUPPAGE paPages)
     1427SUPR0DECL(int) SUPR0LockMem(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages)
    18231428{
    18241429    int             rc;
    18251430    SUPDRVMEMREF    Mem = {0};
    18261431    const size_t    cb = (size_t)cPages << PAGE_SHIFT;
    1827     dprintf(("SUPR0LockMem: pSession=%p pvR3=%p cPages=%d paPages=%p\n",
    1828              pSession, (void *)pvR3, cPages, paPages));
     1432    dprintf(("SUPR0LockMem: pSession=%p pvR3=%p cPages=%d paPages=%p\n", pSession, (void *)pvR3, cPages, paPages));
    18291433
    18301434    /*
    18311435     * Verify input.
    18321436     */
    1833     if (RT_ALIGN_R3PT(pvR3, PAGE_SIZE, RTR3PTR) != pvR3 || !pvR3)
     1437    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     1438    AssertPtrReturn(paPages, VERR_INVALID_PARAMETER);
     1439    if (    RT_ALIGN_R3PT(pvR3, PAGE_SIZE, RTR3PTR) != pvR3
     1440        ||  !pvR3)
    18341441    {
    18351442        dprintf(("pvR3 (%p) must be page aligned and not NULL!\n", (void *)pvR3));
    1836         return SUPDRV_ERR_INVALID_PARAM;
    1837     }
    1838     if (!paPages)
    1839     {
    1840         dprintf(("paPages is NULL!\n"));
    1841         return SUPDRV_ERR_INVALID_PARAM;
     1443        return VERR_INVALID_PARAMETER;
    18421444    }
    18431445
    18441446#ifdef USE_NEW_OS_INTERFACE_FOR_MM
     1447# ifdef RT_OS_WINDOWS /* A temporary hack for windows, will be removed once all ring-3 code has been cleaned up. */
    18451448    /* First check if we allocated it using SUPPageAlloc; if so then we don't need to lock it again */
    1846     rc = SUPR0PageGetPhys(pSession, pvR3, cPages, paPages);
     1449    rc = supdrvPageGetPhys(pSession, pvR3, cPages, paPages);
    18471450    if (RT_SUCCESS(rc))
    18481451        return rc;
     1452# endif
    18491453
    18501454    /*
    … …  
    18551459    if (RT_SUCCESS(rc))
    18561460    {
    1857         unsigned iPage = cPages;
     1461        uint32_t iPage = cPages;
    18581462        AssertMsg(RTR0MemObjAddressR3(Mem.MemObj) == pvR3, ("%p == %p\n", RTR0MemObjAddressR3(Mem.MemObj), pvR3));
    18591463        AssertMsg(RTR0MemObjSize(Mem.MemObj) == cb, ("%x == %x\n", RTR0MemObjSize(Mem.MemObj), cb));
    … …  
    18611465        while (iPage-- > 0)
    18621466        {
    1863             paPages[iPage].uReserved = 0;
    1864             paPages[iPage].Phys = RTR0MemObjGetPagePhysAddr(Mem.MemObj, iPage);
    1865             if (RT_UNLIKELY(paPages[iPage].Phys == NIL_RTCCPHYS))
     1467            paPages[iPage] = RTR0MemObjGetPagePhysAddr(Mem.MemObj, iPage);
     1468            if (RT_UNLIKELY(paPages[iPage] == NIL_RTCCPHYS))
    18661469            {
    18671470                AssertMsgFailed(("iPage=%d\n", iPage));
    … …  
    19061509 * Unlocks the memory pointed to by pv.
    19071510 *
    1908  * @returns 0 on success.
    1909  * @returns SUPDRV_ERR_* on failure
     1511 * @returns IPRT status code.
    19101512 * @param   pSession    Session to which the memory was locked.
    19111513 * @param   pvR3        Memory to unlock.
    … …  
    19141516{
    19151517    dprintf(("SUPR0UnlockMem: pSession=%p pvR3=%p\n", pSession, (void *)pvR3));
    1916 
    1917     /* SUPR0PageFree will unlock SUPR0PageAlloc allocations; ignore this call */
    1918     if (SUPR0PageWasLockedByPageAlloc(pSession, pvR3))
     1518    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     1519#ifdef RT_OS_WINDOWS
     1520    /*
     1521     * Temporary hack for windows - SUPR0PageFree will unlock SUPR0PageAlloc
     1522     * allocations; ignore this call.
     1523     */
     1524    if (supdrvPageWasLockedByPageAlloc(pSession, pvR3))
    19191525    {
    19201526        dprintf(("Page will be unlocked in SUPR0PageFree -> ignore\n"));
    1921         return 0;
    1922     }
    1923 
     1527        return VINF_SUCCESS;
     1528    }
     1529#endif
    19241530    return supdrvMemRelease(pSession, (RTHCUINTPTR)pvR3, MEMREF_TYPE_LOCKED);
    19251531}
    … …  
    19301536 * backing.
    19311537 *
    1932  * @returns 0 on success.
    1933  * @returns SUPDRV_ERR_* on failure.
     1538 * @returns IPRT status code.
    19341539 * @param   pSession    Session data.
    19351540 * @param   cb          Number of bytes to allocate.
    … …  
    19471552     * Validate input.
    19481553     */
    1949     if (!pSession || !ppvR3 || !ppvR0 || !pHCPhys)
     1554    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     1555    if (!ppvR3 || !ppvR0 || !pHCPhys)
    19501556    {
    19511557        dprintf(("Null pointer. All of these should be set: pSession=%p ppvR0=%p ppvR3=%p pHCPhys=%p\n",
    19521558                 pSession, ppvR0, ppvR3, pHCPhys));
    1953         return SUPDRV_ERR_INVALID_PARAM;
    1954 
    1955     }
    1956     if (cPages == 0 || cPages >= 256)
     1559        return VERR_INVALID_PARAMETER;
     1560
     1561    }
     1562    if (cPages < 1 || cPages >= 256)
    19571563    {
    19581564        dprintf(("Illegal request cPages=%d, must be greater than 0 and smaller than 256\n", cPages));
    1959         return SUPDRV_ERR_INVALID_PARAM;
     1565        return VERR_INVALID_PARAMETER;
    19601566    }
    19611567
    … …  
    20191625 * Frees memory allocated using SUPR0ContAlloc().
    20201626 *
    2021  * @returns 0 on success.
    2022  * @returns SUPDRV_ERR_* on failure.
     1627 * @returns IPRT status code.
    20231628 * @param   pSession    The session to which the memory was allocated.
    20241629 * @param   uPtr        Pointer to the memory (ring-3 or ring-0).
    … …  
    20271632{
    20281633    dprintf(("SUPR0ContFree: pSession=%p uPtr=%p\n", pSession, (void *)uPtr));
     1634    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
    20291635    return supdrvMemRelease(pSession, uPtr, MEMREF_TYPE_CONT);
    20301636}
    … …  
    20341640 * Allocates a chunk of page aligned memory with fixed physical backing below 4GB.
    20351641 *
    2036  * @returns 0 on success.
    2037  * @returns SUPDRV_ERR_* on failure.
     1642 * @returns IPRT status code.
    20381643 * @param   pSession    Session data.
    20391644 * @param   cPages      Number of pages to allocate.
    … …  
    20421647 * @param   paPages     Where to put the physical addresses of allocated memory.
    20431648 */
    2044 SUPR0DECL(int) SUPR0LowAlloc(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PSUPPAGE paPages)
     1649SUPR0DECL(int) SUPR0LowAlloc(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS paPages)
    20451650{
    20461651    unsigned        iPage;
    … …  
    20521657     * Validate input.
    20531658     */
    2054     if (!pSession || !ppvR3 || !ppvR0 || !paPages)
     1659    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     1660    if (!ppvR3 || !ppvR0 || !paPages)
    20551661    {
    20561662        dprintf(("Null pointer. All of these should be set: pSession=%p ppvR3=%p ppvR0=%p paPages=%p\n",
    20571663                 pSession, ppvR3, ppvR0, paPages));
    2058         return SUPDRV_ERR_INVALID_PARAM;
     1664        return VERR_INVALID_PARAMETER;
    20591665
    20601666    }
    … …  
    20621668    {
    20631669        dprintf(("Illegal request cPages=%d, must be greater than 0 and smaller than 256.\n", cPages));
    2064         return SUPDRV_ERR_INVALID_PARAM;
     1670        return VERR_INVALID_PARAMETER;
    20651671    }
    20661672
    … …  
    20831689                for (iPage = 0; iPage < cPages; iPage++)
    20841690                {
    2085                     paPages[iPage].Phys = RTR0MemObjGetPagePhysAddr(Mem.MemObj, iPage);
    2086                     paPages[iPage].uReserved = 0;
    2087                     AssertMsg(!(paPages[iPage].Phys & (PAGE_SIZE - 1)), ("iPage=%d Phys=%VHp\n", paPages[iPage].Phys));
     1691                    paPages[iPage] = RTR0MemObjGetPagePhysAddr(Mem.MemObj, iPage);
     1692                    AssertMsg(!(paPages[iPage] & (PAGE_SIZE - 1)), ("iPage=%d Phys=%VHp\n", paPages[iPage]));
    20881693                }
    20891694                *ppvR0 = RTR0MemObjAddress(Mem.MemObj);
    … …  
    21311736 * Frees memory allocated using SUPR0LowAlloc().
    21321737 *
    2133  * @returns 0 on success.
    2134  * @returns SUPDRV_ERR_* on failure.
     1738 * @returns IPRT status code.
    21351739 * @param   pSession    The session to which the memory was allocated.
    21361740 * @param   uPtr        Pointer to the memory (ring-3 or ring-0).
    … …  
    21391743{
    21401744    dprintf(("SUPR0LowFree: pSession=%p uPtr=%p\n", pSession, (void *)uPtr));
     1745    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
    21411746    return supdrvMemRelease(pSession, uPtr, MEMREF_TYPE_LOW);
    21421747}
    … …  
    21481753 * The memory is fixed and it's possible to query the physical addresses using SUPR0MemGetPhys().
    21491754 *
    2150  * @returns 0 on success.
    2151  * @returns SUPDRV_ERR_* on failure.
     1755 * @returns IPRT status code.
    21521756 * @param   pSession    The session to associated the allocation with.
    21531757 * @param   cb          Number of bytes to allocate.
    … …  
    21641768     * Validate input.
    21651769     */
    2166     if (!pSession || !ppvR0 || !ppvR3)
    2167     {
    2168         dprintf(("Null pointer. All of these should be set: pSession=%p ppvR0=%p ppvR3=%p\n",
    2169                  pSession, ppvR0, ppvR3));
    2170         return SUPDRV_ERR_INVALID_PARAM;
    2171 
    2172     }
    2173     if (cb < 1 || cb >= PAGE_SIZE * 256)
     1770    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     1771    AssertPtrReturn(ppvR0, VERR_INVALID_POINTER);
     1772    AssertPtrReturn(ppvR3, VERR_INVALID_POINTER);
     1773    if (cb < 1 || cb >= _4M)
    21741774    {
    21751775        dprintf(("Illegal request cb=%u; must be greater than 0 and smaller than 4MB.\n", cb));
    2176         return SUPDRV_ERR_INVALID_PARAM;
     1776        return VERR_INVALID_PARAMETER;
    21771777    }
    21781778
    … …  
    21951795                *ppvR0 = RTR0MemObjAddress(Mem.MemObj);
    21961796                *ppvR3 = RTR0MemObjAddressR3(Mem.MapObjR3);
    2197                 return 0;
     1797                return VINF_SUCCESS;
    21981798            }
    21991799            rc2 = RTR0MemObjFree(Mem.MapObjR3, false);
    … …  
    22341834 * Get the physical addresses of memory allocated using SUPR0MemAlloc().
    22351835 *
    2236  * @returns 0 on success.
    2237  * @returns SUPDRV_ERR_* on failure.
     1836 * @returns IPRT status code.
    22381837 * @param   pSession        The session to which the memory was allocated.
    22391838 * @param   uPtr            The Ring-0 or Ring-3 address returned by SUPR0MemAlloc().
    22401839 * @param   paPages         Where to store the physical addresses.
    22411840 */
    2242 SUPR0DECL(int) SUPR0MemGetPhys(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, PSUPPAGE paPages)
     1841SUPR0DECL(int) SUPR0MemGetPhys(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, PSUPPAGE paPages) /** @todo switch this bugger to RTHCPHYS */
    22431842{
    22441843    PSUPDRVBUNDLE pBundle;
    … …  
    22491848     * Validate input.
    22501849     */
    2251     if (!pSession)
    2252     {
    2253         dprintf(("pSession must not be NULL!"));
    2254         return SUPDRV_ERR_INVALID_PARAM;
    2255     }
    2256     if (!uPtr || !paPages)
    2257     {
    2258         dprintf(("Illegal address uPtr=%p or/and paPages=%p\n", (void *)uPtr, paPages));
    2259         return SUPDRV_ERR_INVALID_PARAM;
    2260     }
     1850    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     1851    AssertPtrReturn(paPages, VERR_INVALID_POINTER);
     1852    AssertReturn(uPtr, VERR_INVALID_PARAMETER);
    22611853
    22621854    /*
    … …  
    22691861        {
    22701862            unsigned i;
    2271             for (i = 0; i < sizeof(pBundle->aMem) / sizeof(pBundle->aMem[0]); i++)
     1863            for (i = 0; i < RT_ELEMENTS(pBundle->aMem); i++)
    22721864            {
    22731865#ifdef USE_NEW_OS_INTERFACE_FOR_MM
    … …  
    22881880                    }
    22891881                    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
    2290                     return 0;
     1882                    return VINF_SUCCESS;
    22911883                }
    22921884#else /* !USE_NEW_OS_INTERFACE_FOR_MM */
    … …  
    23051897    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
    23061898    dprintf(("Failed to find %p!!!\n", (void *)uPtr));
    2307     return SUPDRV_ERR_INVALID_PARAM;
     1899    return VERR_INVALID_PARAMETER;
    23081900}
    23091901
    … …  
    23121904 * Free memory allocated by SUPR0MemAlloc().
    23131905 *
    2314  * @returns 0 on success.
    2315  * @returns SUPDRV_ERR_* on failure.
     1906 * @returns IPRT status code.
    23161907 * @param   pSession        The session owning the allocation.
    23171908 * @param   uPtr            The Ring-0 or Ring-3 address returned by SUPR0MemAlloc().
    … …  
    23201911{
    23211912    dprintf(("SUPR0MemFree: pSession=%p uPtr=%p\n", pSession, (void *)uPtr));
     1913    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
    23221914    return supdrvMemRelease(pSession, uPtr, MEMREF_TYPE_MEM);
    23231915}
    … …  
    23291921 * The memory is fixed and it's possible to query the physical addresses using SUPR0MemGetPhys().
    23301922 *
    2331  * @returns 0 on success.
    2332  * @returns SUPDRV_ERR_* on failure.
     1923 * @returns IPRT status code.
    23331924 * @param   pSession    The session to associated the allocation with.
    2334  * @param   cb          Number of bytes to allocate.
     1925 * @param   cPages      The number of pages to allocate.
    23351926 * @param   ppvR3       Where to store the address of the Ring-3 mapping.
    2336  */
    2337 SUPR0DECL(int) SUPR0PageAlloc(PSUPDRVSESSION pSession, uint32_t cb, PRTR3PTR ppvR3)
     1927 * @param   paPages     Where to store the addresses of the pages. Optional.
     1928 */
     1929SUPR0DECL(int) SUPR0PageAlloc(PSUPDRVSESSION pSession, uint32_t cPages, PRTR3PTR ppvR3, PRTHCPHYS paPages)
    23381930{
    23391931    int             rc;
    23401932    SUPDRVMEMREF    Mem = {0};
    2341     dprintf(("SUPR0PageAlloc: pSession=%p cb=%d ppvR3=%p\n", pSession, cb, ppvR3));
     1933    dprintf(("SUPR0PageAlloc: pSession=%p cb=%d ppvR3=%p\n", pSession, cPages, ppvR3));
    23421934
    23431935    /*
    23441936     * Validate input.
    23451937     */
    2346     if (!pSession || !ppvR3)
    2347     {
    2348         dprintf(("Null pointer. All of these should be set: pSession=%p ppvR3=%p\n",
    2349                  pSession, ppvR3));
    2350         return SUPDRV_ERR_INVALID_PARAM;
    2351 
    2352     }
    2353     if (cb < 1 || cb >= 4096)
    2354     {
    2355         dprintf(("Illegal request cb=%u; must be greater than 0 and smaller than 16MB.\n", cb));
    2356         return SUPDRV_ERR_INVALID_PARAM;
     1938    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     1939    AssertPtrReturn(ppvR3, VERR_INVALID_POINTER);
     1940    if (cPages < 1 || cPages >= 4096)
     1941    {
     1942        dprintf(("SUPR0PageAlloc: Illegal request cb=%u; must be greater than 0 and smaller than 16MB.\n", cPages));
     1943        return VERR_INVALID_PARAMETER;
    23571944    }
    23581945
    … …  
    23601947     * Let IPRT do the work.
    23611948     */
    2362     rc = RTR0MemObjAllocPhysNC(&Mem.MemObj, cb * PAGE_SIZE, NIL_RTHCPHYS);
     1949    rc = RTR0MemObjAllocPhysNC(&Mem.MemObj, (size_t)cPages * PAGE_SIZE, NIL_RTHCPHYS);
    23631950    if (RT_SUCCESS(rc))
    23641951    {
    … …  
    23731960            {
    23741961                *ppvR3 = RTR0MemObjAddressR3(Mem.MapObjR3);
    2375                 dprintf(("SUPR0PageAlloc returned %p\n", *ppvR3));
    2376                 return 0;
     1962                if (paPages)
     1963                {
     1964                    uint32_t iPage = cPages;
     1965                    while (iPage-- > 0)
     1966                    {
     1967                        paPages[iPage] = RTR0MemObjGetPagePhysAddr(Mem.MapObjR3, iPage);
     1968                        Assert(paPages[iPage] != NIL_RTHCPHYS);
     1969                    }
     1970                }
     1971                return VINF_SUCCESS;
    23771972            }
    23781973            rc2 = RTR0MemObjFree(Mem.MapObjR3, false);
    … …  
    23861981}
    23871982
     1983
     1984#ifdef RT_OS_WINDOWS
    23881985/**
    23891986 * Check if the pages were locked by SUPR0PageAlloc
     1987 *
     1988 * This function will be removed along with the lock/unlock hacks when
     1989 * we've cleaned up the ring-3 code properly.
    23901990 *
    23911991 * @returns boolean
    23921992 * @param   pSession        The session to which the memory was allocated.
    2393  * @param   uPtr            The Ring-3 address returned by SUPR0PageAlloc().
    2394  */
    2395 SUPR0DECL(bool) SUPR0PageWasLockedByPageAlloc(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr)
     1993 * @param   pvR3            The Ring-3 address returned by SUPR0PageAlloc().
     1994 */
     1995static bool supdrvPageWasLockedByPageAlloc(PSUPDRVSESSION pSession, RTR3PTR pvR3)
    23961996{
    23971997    PSUPDRVBUNDLE pBundle;
    23981998    RTSPINLOCKTMP SpinlockTmp = RTSPINLOCKTMP_INITIALIZER;
    2399     dprintf(("SUPR0PageIsLockedByPageAlloc: pSession=%p uPtr=%p\n", pSession, (void *)uPtr));
    2400 
    2401     /*
    2402      * Validate input.
    2403      */
    2404     if (!pSession)
    2405     {
    2406         dprintf(("pSession must not be NULL!"));
    2407         return false;
    2408     }
    2409     if (!uPtr)
    2410     {
    2411         dprintf(("Illegal address uPtr=%p\n", (void *)uPtr));
    2412         return false;
    2413     }
     1999    dprintf(("SUPR0PageIsLockedByPageAlloc: pSession=%p pvR3=%p\n", pSession, (void *)pvR3));
    24142000
    24152001    /*
    … …  
    24222008        {
    24232009            unsigned i;
    2424             for (i = 0; i < sizeof(pBundle->aMem) / sizeof(pBundle->aMem[0]); i++)
     2010            for (i = 0; i < RT_ELEMENTS(pBundle->aMem); i++)
    24252011            {
    24262012                if (    pBundle->aMem[i].eType == MEMREF_TYPE_LOCKED_SUP
    24272013                    &&  pBundle->aMem[i].MemObj != NIL_RTR0MEMOBJ
    2428                     &&  (   (RTHCUINTPTR)RTR0MemObjAddress(pBundle->aMem[i].MemObj) == uPtr
    2429                          || (   pBundle->aMem[i].MapObjR3 != NIL_RTR0MEMOBJ
    2430                              && RTR0MemObjAddressR3(pBundle->aMem[i].MapObjR3) == uPtr)
    2431                         )
    2432                    )
     2014                    &&  pBundle->aMem[i].MapObjR3 != NIL_RTR0MEMOBJ
     2015                    &&  RTR0MemObjAddressR3(pBundle->aMem[i].MapObjR3) == pvR3)
    24332016                {
    24342017                    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
    … …  
    24422025}
    24432026
     2027
    24442028/**
    24452029 * Get the physical addresses of memory allocated using SUPR0PageAlloc().
    24462030 *
    2447  * @returns 0 on success.
    2448  * @returns SUPDRV_ERR_* on failure.
     2031 * This function will be removed along with the lock/unlock hacks when
     2032 * we've cleaned up the ring-3 code properly.
     2033 *
     2034 * @returns IPRT status code.
    24492035 * @param   pSession        The session to which the memory was allocated.
    2450  * @param   uPtr            The Ring-3 address returned by SUPR0PageAlloc().
     2036 * @param   pvR3            The Ring-3 address returned by SUPR0PageAlloc().
    24512037 * @param   cPages          Number of pages in paPages
    24522038 * @param   paPages         Where to store the physical addresses.
    24532039 */
    2454 SUPR0DECL(int) SUPR0PageGetPhys(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, uint32_t cPages, PSUPPAGE paPages)
     2040static int supdrvPageGetPhys(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages)
    24552041{
    24562042    PSUPDRVBUNDLE pBundle;
    24572043    RTSPINLOCKTMP SpinlockTmp = RTSPINLOCKTMP_INITIALIZER;
    2458     dprintf(("SUPR0PageGetPhys: pSession=%p uPtr=%p paPages=%p\n", pSession, (void *)uPtr, paPages));
    2459 
    2460     /*
    2461      * Validate input.
    2462      */
    2463     if (!pSession)
    2464     {
    2465         dprintf(("pSession must not be NULL!"));
    2466         return SUPDRV_ERR_INVALID_PARAM;
    2467     }
    2468     if (!uPtr || !paPages)
    2469     {
    2470         dprintf(("Illegal address uPtr=%p or/and paPages=%p\n", (void *)uPtr, paPages));
    2471         return SUPDRV_ERR_INVALID_PARAM;
    2472     }
     2044    dprintf(("supdrvPageGetPhys: pSession=%p pvR3=%p cPages=%#lx paPages=%p\n", pSession, (void *)pvR3, (long)cPages, paPages));
    24732045
    24742046    /*
    … …  
    24812053        {
    24822054            unsigned i;
    2483             for (i = 0; i < sizeof(pBundle->aMem) / sizeof(pBundle->aMem[0]); i++)
     2055            for (i = 0; i < RT_ELEMENTS(pBundle->aMem); i++)
    24842056            {
    24852057                if (    pBundle->aMem[i].eType == MEMREF_TYPE_LOCKED_SUP
    24862058                    &&  pBundle->aMem[i].MemObj != NIL_RTR0MEMOBJ
    2487                     &&  (   (RTHCUINTPTR)RTR0MemObjAddress(pBundle->aMem[i].MemObj) == uPtr
    2488                          || (   pBundle->aMem[i].MapObjR3 != NIL_RTR0MEMOBJ
    2489                              && RTR0MemObjAddressR3(pBundle->aMem[i].MapObjR3) == uPtr)
    2490                         )
    2491                    )
     2059                    &&  pBundle->aMem[i].MapObjR3 != NIL_RTR0MEMOBJ
     2060                    &&  RTR0MemObjAddressR3(pBundle->aMem[i].MapObjR3) == pvR3)
    24922061                {
    2493                     unsigned iPage;
    2494                     cPages = RT_MIN(RTR0MemObjSize(pBundle->aMem[i].MemObj) >> PAGE_SHIFT, cPages);
     2062                    uint32_t iPage = RTR0MemObjSize(pBundle->aMem[i].MemObj) >> PAGE_SHIFT;
     2063                    cPages = RT_MIN(iPage, cPages);
    24952064                    for (iPage = 0; iPage < cPages; iPage++)
    2496                     {
    2497                         paPages[iPage].Phys = RTR0MemObjGetPagePhysAddr(pBundle->aMem[i].MemObj, iPage);
    2498                         paPages[iPage].uReserved = 0;
    2499                     }
     2065                        paPages[iPage] = RTR0MemObjGetPagePhysAddr(pBundle->aMem[i].MemObj, iPage);
    25002066                    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
    2501                     return 0;
     2067                    return VINF_SUCCESS;
    25022068                }
    25032069            }
    … …  
    25052071    }
    25062072    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
    2507     dprintf(("Failed to find %p!!!\n", (void *)uPtr));
    2508     return SUPDRV_ERR_INVALID_PARAM;
    2509 }
    2510 
     2073    return VERR_INVALID_PARAMETER;
     2074}
     2075#endif /* RT_OS_WINDOWS */
    25112076
    25122077/**
    25132078 * Free memory allocated by SUPR0PageAlloc().
    25142079 *
    2515  * @returns 0 on success.
    2516  * @returns SUPDRV_ERR_* on failure.
     2080 * @returns IPRT status code.
    25172081 * @param   pSession        The session owning the allocation.
    2518  * @param   uPtr            The Ring-3 address returned by SUPR0PageAlloc().
    2519  */
    2520 SUPR0DECL(int) SUPR0PageFree(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr)
    2521 {
    2522     dprintf(("SUPR0PageFree: pSession=%p uPtr=%p\n", pSession, (void *)uPtr));
    2523     return supdrvMemRelease(pSession, uPtr, MEMREF_TYPE_LOCKED_SUP);
     2082 * @param   pvR3             The Ring-3 address returned by SUPR0PageAlloc().
     2083 */
     2084SUPR0DECL(int) SUPR0PageFree(PSUPDRVSESSION pSession, RTR3PTR pvR3)
     2085{
     2086    dprintf(("SUPR0PageFree: pSession=%p pvR3=%p\n", pSession, (void *)pvR3));
     2087    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     2088    return supdrvMemRelease(pSession, (RTHCUINTPTR)pvR3, MEMREF_TYPE_LOCKED_SUP);
    25242089}
    25252090#endif /* USE_NEW_OS_INTERFACE_FOR_MM */
    … …  
    25292094 * Maps the GIP into userspace and/or get the physical address of the GIP.
    25302095 *
    2531  * @returns 0 on success.
    2532  * @returns SUPDRV_ERR_* on failure.
     2096 * @returns IPRT status code.
    25332097 * @param   pSession        Session to which the GIP mapping should belong.
    25342098 * @param   ppGipR3         Where to store the address of the ring-3 mapping. (optional)
    … …  
    25392103 *          and remove the session as a GIP user.
    25402104 */
    2541 SUPR0DECL(int) SUPR0GipMap(PSUPDRVSESSION pSession, PRTR3PTR ppGipR3, PRTHCPHYS pHCPhysGid)
     2105SUPR0DECL(int) SUPR0GipMap(PSUPDRVSESSION pSession, PRTR3PTR ppGipR3, PRTHCPHYS pHCPhysGip)
    25422106{
    25432107    int             rc = 0;
    … …  
    25452109    RTR3PTR         pGip = NIL_RTR3PTR;
    25462110    RTHCPHYS        HCPhys = NIL_RTHCPHYS;
    2547     dprintf(("SUPR0GipMap: pSession=%p ppGipR3=%p pHCPhysGid=%p\n", pSession, ppGipR3, pHCPhysGid));
     2111    dprintf(("SUPR0GipMap: pSession=%p ppGipR3=%p pHCPhysGip=%p\n", pSession, ppGipR3, pHCPhysGip));
    25482112
    25492113    /*
    25502114     * Validate
    25512115     */
    2552     if (!ppGipR3 && !pHCPhysGid)
    2553         return 0;
     2116    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     2117    AssertPtrNullReturn(ppGipR3, VERR_INVALID_POINTER);
     2118    AssertPtrNullReturn(pHCPhysGip, VERR_INVALID_POINTER);
    25542119
    25552120    RTSemFastMutexRequest(pDevExt->mtxGip);
    … …  
    25812146         * Get physical address.
    25822147         */
    2583         if (pHCPhysGid && !rc)
     2148        if (pHCPhysGip && !rc)
    25842149            HCPhys = pDevExt->HCPhysGip;
    25852150
    … …  
    26042169#ifdef USE_NEW_OS_INTERFACE_FOR_GIP
    26052170                rc = RTTimerStart(pDevExt->pGipTimer, 0);
    2606                 AssertRC(rc); rc = 0;
     2171                AssertRC(rc); rc = VINF_SUCCESS;
    26072172#else
    26082173                supdrvOSGipResume(pDevExt);
    … …  
    26212186     * Write returns.
    26222187     */
    2623     if (pHCPhysGid)
    2624         *pHCPhysGid = HCPhys;
     2188    if (pHCPhysGip)
     2189        *pHCPhysGip = HCPhys;
    26252190    if (ppGipR3)
    26262191        *ppGipR3 = pGip;
    26272192
    26282193#ifdef DEBUG_DARWIN_GIP
    2629     OSDBGPRINT(("SUPR0GipMap: returns %d *pHCPhysGid=%lx *ppGip=%p GipMapObjR3\n", rc, (unsigned long)HCPhys, pGip, pSession->GipMapObjR3));
     2194    OSDBGPRINT(("SUPR0GipMap: returns %d *pHCPhysGip=%lx *ppGip=%p GipMapObjR3\n", rc, (unsigned long)HCPhys, pGip, pSession->GipMapObjR3));
    26302195#else
    2631     dprintf(("SUPR0GipMap: returns %d *pHCPhysGid=%lx *ppGipR3=%p\n", rc, (unsigned long)HCPhys, (void *)(uintptr_t)pGip));
     2196    dprintf(("SUPR0GipMap: returns %d *pHCPhysGip=%lx *ppGipR3=%p\n", rc, (unsigned long)HCPhys, (void *)(uintptr_t)pGip));
    26322197#endif
    26332198    return rc;
    … …  
    26392204 * from this session.
    26402205 *
    2641  * @returns 0 on success.
    2642  * @returns SUPDRV_ERR_* on failure.
     2206 * @returns IPRT status code.
    26432207 * @param   pSession        Session to which the GIP mapping should belong.
    26442208 */
    26452209SUPR0DECL(int) SUPR0GipUnmap(PSUPDRVSESSION pSession)
    26462210{
    2647     int                     rc = 0;
     2211    int                     rc = VINF_SUCCESS;
    26482212    PSUPDRVDEVEXT           pDevExt = pSession->pDevExt;
    26492213#ifdef DEBUG_DARWIN_GIP
    … …  
    26552219    dprintf(("SUPR0GipUnmap: pSession=%p\n", pSession));
    26562220#endif
     2221    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
    26572222
    26582223    RTSemFastMutexRequest(pDevExt->mtxGip);
    … …  
    27052270 * Adds a memory object to the session.
    27062271 *
    2707  * @returns 0 on success.
    2708  * @returns SUPDRV_ERR_* on failure.
     2272 * @returns IPRT status code.
    27092273 * @param   pMem        Memory tracking structure containing the
    27102274 *                      information to track.
    … …  
    27222286    for (pBundle = &pSession->Bundle; pBundle; pBundle = pBundle->pNext)
    27232287    {
    2724         if (pBundle->cUsed < sizeof(pBundle->aMem) / sizeof(pBundle->aMem[0]))
     2288        if (pBundle->cUsed < RT_ELEMENTS(pBundle->aMem))
    27252289        {
    27262290            unsigned i;
    2727             for (i = 0; i < sizeof(pBundle->aMem) / sizeof(pBundle->aMem[0]); i++)
     2291            for (i = 0; i < RT_ELEMENTS(pBundle->aMem); i++)
    27282292            {
    27292293#ifdef USE_NEW_OS_INTERFACE_FOR_MM
    … …  
    27372301                    pBundle->aMem[i] = *pMem;
    27382302                    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
    2739                     return 0;
     2303                    return VINF_SUCCESS;
    27402304                }
    27412305            }
    … …  
    27512315    pBundle = (PSUPDRVBUNDLE)RTMemAllocZ(sizeof(*pBundle));
    27522316    if (!pBundle)
    2753         return SUPDRV_ERR_NO_MEMORY;
     2317        return VERR_NO_MEMORY;
    27542318
    27552319    /* take last entry. */
    27562320    pBundle->cUsed++;
    2757     pBundle->aMem[sizeof(pBundle->aMem) / sizeof(pBundle->aMem[0]) - 1] = *pMem;
     2321    pBundle->aMem[RT_ELEMENTS(pBundle->aMem) - 1] = *pMem;
    27582322
    27592323    /* insert into list. */
    … …  
    27632327    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
    27642328
    2765     return 0;
     2329    return VINF_SUCCESS;
    27662330}
    27672331
    … …  
    27702334 * Releases a memory object referenced by pointer and type.
    27712335 *
    2772  * @returns 0 on success.
    2773  * @returns SUPDRV_ERR_INVALID_PARAM on failure.
     2336 * @returns IPRT status code.
    27742337 * @param   pSession    Session data.
    27752338 * @param   uPtr        Pointer to memory. This is matched against both the R0 and R3 addresses.
    … …  
    27842347     * Validate input.
    27852348     */
    2786     if (!pSession)
    2787     {
    2788         dprintf(("pSession must not be NULL!"));
    2789         return SUPDRV_ERR_INVALID_PARAM;
    2790     }
    27912349    if (!uPtr)
    27922350    {
    27932351        dprintf(("Illegal address %p\n", (void *)uPtr));
    2794         return SUPDRV_ERR_INVALID_PARAM;
     2352        return VERR_INVALID_PARAMETER;
    27952353    }
    27962354
    … …  
    28042362        {
    28052363            unsigned i;
    2806             for (i = 0; i < sizeof(pBundle->aMem) / sizeof(pBundle->aMem[0]); i++)
     2364            for (i = 0; i < RT_ELEMENTS(pBundle->aMem); i++)
    28072365            {
    28082366#ifdef USE_NEW_OS_INTERFACE_FOR_MM
    … …  
    28312389                        AssertRC(rc); /** @todo figure out how to handle this. */
    28322390                    }
    2833                     return 0;
     2391                    return VINF_SUCCESS;
    28342392                }
    28352393#else /* !USE_NEW_OS_INTERFACE_FOR_MM */
    … …  
    28652423                            break;
    28662424                    }
    2867                     return 0;
     2425                    return VINF_SUCCESS;
    28682426               }
    28692427#endif /* !USE_NEW_OS_INTERFACE_FOR_MM */
    … …  
    28732431    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
    28742432    dprintf(("Failed to find %p!!! (eType=%d)\n", (void *)uPtr, eType));
    2875     return SUPDRV_ERR_INVALID_PARAM;
     2433    return VERR_INVALID_PARAMETER;
    28762434}
    28772435
    … …  
    28812439 * Install IDT for the current CPU.
    28822440 *
    2883  * @returns 0 on success.
    2884  * @returns SUPDRV_ERR_NO_MEMORY or SUPDRV_ERROR_IDT_FAILED on failure.
    2885  * @param   pIn         Input data.
    2886  * @param   pOut        Output data.
    2887  */
    2888 static int supdrvIOCtl_IdtInstall(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPIDTINSTALL_IN pIn, PSUPIDTINSTALL_OUT pOut)
     2441 * @returns One of the following IPRT status codes:
     2442 * @retval  VINF_SUCCESS on success.
     2443 * @retval  VERR_IDT_FAILED.
     2444 * @retval  VERR_NO_MEMORY.
     2445 * @param   pDevExt     The device extension.
     2446 * @param   pSession    The session data.
     2447 * @param   pReq        The request.
     2448 */
     2449static int supdrvIOCtl_IdtInstall(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPIDTINSTALL pReq)
    28892450{
    28902451    PSUPDRVPATCHUSAGE   pUsagePre;
    … …  
    29012462    pUsagePre = (PSUPDRVPATCHUSAGE)RTMemAlloc(sizeof(*pUsagePre));
    29022463    if (!pUsagePre)
    2903         return SUPDRV_ERR_NO_MEMORY;
     2464        return VERR_NO_MEMORY;
    29042465
    29052466    /*
    … …  
    29182479        pPatchPre = (PSUPDRVPATCH)RTMemExecAlloc(sizeof(*pPatchPre));
    29192480        if (!pPatchPre)
    2920             return SUPDRV_ERR_NO_MEMORY;
     2481            return VERR_NO_MEMORY;
    29212482
    29222483        RTSpinlockAcquireNoInts(pDevExt->Spinlock, &SpinlockTmp);
    … …  
    29952556        RTMemFree(pUsagePre);
    29962557
    2997     pOut->u8Idt = pDevExt->u8Idt;
    2998 
    2999     return pPatch ? 0 : SUPDRV_ERR_IDT_FAILED;
     2558    pReq->u.Out.u8Idt = pDevExt->u8Idt;
     2559
     2560    return pPatch ? VINF_SUCCESS : VERR_IDT_FAILED;
    30002561}
    30012562
    … …  
    33732934 * This will uninstall our IDT patch if we left unreferenced.
    33742935 *
    3375  * @returns 0 indicating success.
     2936 * @returns VINF_SUCCESS.
    33762937 * @param   pDevExt     Device globals.
    33772938 * @param   pSession    Session data.
    … …  
    33892950
    33902951    /*
    3391      * Walk usage list.
     2952     * Walk usage list, removing patches as their usage count reaches zero.
    33922953     */
    33932954    pUsage = pSession->pPatchUsage;
    … …  
    34232984    }
    34242985
    3425     return 0;
     2986    return VINF_SUCCESS;
    34262987}
    34272988
    … …  
    34292990/**
    34302991 * Remove one patch.
     2992 *
     2993 * Worker for supdrvIOCtl_IdtRemoveAll.
    34312994 *
    34322995 * @param   pDevExt     Device globals.
    … …  
    35403103 * This is the 1st step of the loading.
    35413104 *
    3542  * @returns 0 on success.
    3543  * @returns SUPDRV_ERR_* on failure.
     3105 * @returns IPRT status code.
    35443106 * @param   pDevExt     Device globals.
    35453107 * @param   pSession    Session data.
    3546  * @param   pIn         Input.
    3547  * @param   pOut        Output. (May overlap pIn.)
    3548  */
    3549 static int supdrvIOCtl_LdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDROPEN_IN pIn, PSUPLDROPEN_OUT pOut)
     3108 * @param   pReq        The open request.
     3109 */
     3110static int supdrvIOCtl_LdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDROPEN pReq)
    35503111{
    35513112    PSUPDRVLDRIMAGE pImage;
    35523113    unsigned        cb;
    35533114    void           *pv;
    3554     dprintf(("supdrvIOCtl_LdrOpen: szName=%s cbImage=%d\n", pIn->szName, pIn->cbImage));
     3115    dprintf(("supdrvIOCtl_LdrOpen: szName=%s cbImage=%d\n", pReq->u.In.szName, pReq->u.In.cbImage));
    35553116
    35563117    /*
    … …  
    35603121    for (pImage = pDevExt->pLdrImages; pImage; pImage = pImage->pNext)
    35613122    {
    3562         if (!strcmp(pImage->szName, pIn->szName))
     3123        if (!strcmp(pImage->szName, pReq->u.In.szName))
    35633124        {
    35643125            pImage->cUsage++;
    3565             pOut->pvImageBase   = pImage->pvImage;
    3566             pOut->fNeedsLoading = pImage->uState == SUP_IOCTL_LDR_OPEN;
     3126            pReq->u.Out.pvImageBase   = pImage->pvImage;
     3127            pReq->u.Out.fNeedsLoading = pImage->uState == SUP_IOCTL_LDR_OPEN;
    35673128            supdrvLdrAddUsage(pSession, pImage);
    35683129            RTSemFastMutexRelease(pDevExt->mtxLdr);
    3569             return 0;
     3130            return VINF_SUCCESS;
    35703131        }
    35713132    }
    … …  
    35753136     * Allocate memory.
    35763137     */
    3577     cb = pIn->cbImage + sizeof(SUPDRVLDRIMAGE) + 31;
     3138    cb = pReq->u.In.cbImage + sizeof(SUPDRVLDRIMAGE) + 31;
    35783139    pv = RTMemExecAlloc(cb);
    35793140    if (!pv)
    35803141    {
    35813142        RTSemFastMutexRelease(pDevExt->mtxLdr);
    3582         return SUPDRV_ERR_NO_MEMORY;
     3143        return VERR_NO_MEMORY;
    35833144    }
    35843145
    … …  
    35883149    pImage = (PSUPDRVLDRIMAGE)pv;
    35893150    pImage->pvImage         = ALIGNP(pImage + 1, 32);
    3590     pImage->cbImage         = pIn->cbImage;
     3151    pImage->cbImage         = pReq->u.In.cbImage;
    35913152    pImage->pfnModuleInit   = NULL;
    35923153    pImage->pfnModuleTerm   = NULL;
    35933154    pImage->uState          = SUP_IOCTL_LDR_OPEN;
    35943155    pImage->cUsage          = 1;
    3595     strcpy(pImage->szName, pIn->szName);
     3156    strcpy(pImage->szName, pReq->u.In.szName);
    35963157
    35973158    pImage->pNext           = pDevExt->pLdrImages;
    … …  
    36003161    supdrvLdrAddUsage(pSession, pImage);
    36013162
    3602     pOut->pvImageBase      = pImage->pvImage;
    3603     pOut->fNeedsLoading     = 1;
     3163    pReq->u.Out.pvImageBase = pImage->pvImage;
     3164    pReq->u.Out.fNeedsLoading = true;
    36043165    RTSemFastMutexRelease(pDevExt->mtxLdr);
    3605     return 0;
     3166    return VINF_SUCCESS;
    36063167}
    36073168
    … …  
    36123173 * This is the 2nd step of the loading.
    36133174 *
    3614  * @returns 0 on success.
    3615  * @returns SUPDRV_ERR_* on failure.
     3175 * @returns IPRT status code.
    36163176 * @param   pDevExt     Device globals.
    36173177 * @param   pSession    Session data.
    3618  * @param   pIn         Input.
    3619  */
    3620 static int supdrvIOCtl_LdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRLOAD_IN pIn)
     3178 * @param   pReq        The request.
     3179 */
     3180static int supdrvIOCtl_LdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRLOAD pReq)
    36213181{
    36223182    PSUPDRVLDRUSAGE pUsage;
    36233183    PSUPDRVLDRIMAGE pImage;
    36243184    int             rc;
    3625     dprintf(("supdrvIOCtl_LdrLoad: pvImageBase=%p cbImage=%d\n", pIn->pvImageBase, pIn->cbImage));
     3185    dprintf(("supdrvIOCtl_LdrLoad: pvImageBase=%p cbImage=%d\n", pReq->u.In.pvImageBase, pReq->u.In.cbImage));
    36263186
    36273187    /*
    … …  
    36303190    RTSemFastMutexRequest(pDevExt->mtxLdr);
    36313191    pUsage = pSession->pLdrUsage;
    3632     while (pUsage && pUsage->pImage->pvImage != pIn->pvImageBase)
     3192    while (pUsage && pUsage->pImage->pvImage != pReq->u.In.pvImageBase)
    36333193        pUsage = pUsage->pNext;
    36343194    if (!pUsage)
    … …  
    36363196        RTSemFastMutexRelease(pDevExt->mtxLdr);
    36373197        dprintf(("SUP_IOCTL_LDR_LOAD: couldn't find image!\n"));
    3638         return SUPDRV_ERR_INVALID_HANDLE;
     3198        return VERR_INVALID_HANDLE;
    36393199    }
    36403200    pImage = pUsage->pImage;
    3641     if (pImage->cbImage != pIn->cbImage)
     3201    if (pImage->cbImage != pReq->u.In.cbImage)
    36423202    {
    36433203        RTSemFastMutexRelease(pDevExt->mtxLdr);
    3644         dprintf(("SUP_IOCTL_LDR_LOAD: image size mismatch!! %d(prep) != %d(load)\n", pImage->cbImage, pIn->cbImage));
    3645         return SUPDRV_ERR_INVALID_HANDLE;
     3204        dprintf(("SUP_IOCTL_LDR_LOAD: image size mismatch!! %d(prep) != %d(load)\n", pImage->cbImage, pReq->u.In.cbImage));
     3205        return VERR_INVALID_HANDLE;
    36463206    }
    36473207    if (pImage->uState != SUP_IOCTL_LDR_OPEN)
    … …  
    36533213        return SUPDRV_ERR_ALREADY_LOADED;
    36543214    }
    3655     switch (pIn->eEPType)
     3215    switch (pReq->u.In.eEPType)
    36563216    {
    36573217        case EP_NOTHING:
    36583218            break;
    36593219        case EP_VMMR0:
    3660             if (!pIn->EP.VMMR0.pvVMMR0 || !pIn->EP.VMMR0.pvVMMR0Entry)
     3220            if (!pReq->u.In.EP.VMMR0.pvVMMR0 || !pReq->u.In.EP.VMMR0.pvVMMR0Entry)
    36613221            {
    36623222                RTSemFastMutexRelease(pDevExt->mtxLdr);
    3663                 dprintf(("pvVMMR0=%p or pIn->EP.VMMR0.pvVMMR0Entry=%p is NULL!\n",
    3664                          pIn->EP.VMMR0.pvVMMR0, pIn->EP.VMMR0.pvVMMR0Entry));
    3665                 return SUPDRV_ERR_INVALID_PARAM;
     3223                dprintf(("pvVMMR0=%p or pReq->u.In.EP.VMMR0.pvVMMR0Entry=%p is NULL!\n",
     3224                         pReq->u.In.EP.VMMR0.pvVMMR0, pReq->u.In.EP.VMMR0.pvVMMR0Entry));
     3225                return VERR_INVALID_PARAMETER;
    36663226            }
    3667             if ((uintptr_t)pIn->EP.VMMR0.pvVMMR0Entry - (uintptr_t)pImage->pvImage >= pIn->cbImage)
     3227            if ((uintptr_t)pReq->u.In.EP.VMMR0.pvVMMR0Entry - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage)
    36683228            {
    36693229                RTSemFastMutexRelease(pDevExt->mtxLdr);
    36703230                dprintf(("SUP_IOCTL_LDR_LOAD: pvVMMR0Entry=%p is outside the image (%p %d bytes)\n",
    3671                          pIn->EP.VMMR0.pvVMMR0Entry, pImage->pvImage, pIn->cbImage));
    3672                 return SUPDRV_ERR_INVALID_PARAM;
     3231                         pReq->u.In.EP.VMMR0.pvVMMR0Entry, pImage->pvImage, pReq->u.In.cbImage));
     3232                return VERR_INVALID_PARAMETER;
    36733233            }
    36743234            break;
    36753235        default:
    36763236            RTSemFastMutexRelease(pDevExt->mtxLdr);
    3677             dprintf(("Invalid eEPType=%d\n", pIn->eEPType));
    3678             return SUPDRV_ERR_INVALID_PARAM;
    3679     }
    3680     if (    pIn->pfnModuleInit
    3681         &&  (uintptr_t)pIn->pfnModuleInit - (uintptr_t)pImage->pvImage >= pIn->cbImage)
     3237            dprintf(("Invalid eEPType=%d\n", pReq->u.In.eEPType));
     3238            return VERR_INVALID_PARAMETER;
     3239    }
     3240    if (    pReq->u.In.pfnModuleInit
     3241        &&  (uintptr_t)pReq->u.In.pfnModuleInit - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage)
    36823242    {
    36833243        RTSemFastMutexRelease(pDevExt->mtxLdr);
    36843244        dprintf(("SUP_IOCTL_LDR_LOAD: pfnModuleInit=%p is outside the image (%p %d bytes)\n",
    3685                  pIn->pfnModuleInit, pImage->pvImage, pIn->cbImage));
    3686         return SUPDRV_ERR_INVALID_PARAM;
    3687     }
    3688     if (    pIn->pfnModuleTerm
    3689         &&  (uintptr_t)pIn->pfnModuleTerm - (uintptr_t)pImage->pvImage >= pIn->cbImage)
     3245                 pReq->u.In.pfnModuleInit, pImage->pvImage, pReq->u.In.cbImage));
     3246        return VERR_INVALID_PARAMETER;
     3247    }
     3248    if (    pReq->u.In.pfnModuleTerm
     3249        &&  (uintptr_t)pReq->u.In.pfnModuleTerm - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage)
    36903250    {
    36913251        RTSemFastMutexRelease(pDevExt->mtxLdr);
    36923252        dprintf(("SUP_IOCTL_LDR_LOAD: pfnModuleTerm=%p is outside the image (%p %d bytes)\n",
    3693                  pIn->pfnModuleTerm, pImage->pvImage, pIn->cbImage));
    3694         return SUPDRV_ERR_INVALID_PARAM;
     3253                 pReq->u.In.pfnModuleTerm, pImage->pvImage, pReq->u.In.cbImage));
     3254        return VERR_INVALID_PARAMETER;
    36953255    }
    36963256
    … …  
    36993259     */
    37003260    /* no need to do try/except as this is a buffered request. */
    3701     memcpy(pImage->pvImage, &pIn->achImage[0], pImage->cbImage);
     3261    memcpy(pImage->pvImage, &pReq->u.In.achImage[0], pImage->cbImage);
    37023262    pImage->uState = SUP_IOCTL_LDR_LOAD;
    3703     pImage->pfnModuleInit = pIn->pfnModuleInit;
    3704     pImage->pfnModuleTerm = pIn->pfnModuleTerm;
    3705     pImage->offSymbols    = pIn->offSymbols;
    3706     pImage->cSymbols      = pIn->cSymbols;
    3707     pImage->offStrTab     = pIn->offStrTab;
    3708     pImage->cbStrTab      = pIn->cbStrTab;
     3263    pImage->pfnModuleInit = pReq->u.In.pfnModuleInit;
     3264    pImage->pfnModuleTerm = pReq->u.In.pfnModuleTerm;
     3265    pImage->offSymbols    = pReq->u.In.offSymbols;
     3266    pImage->cSymbols      = pReq->u.In.cSymbols;
     3267    pImage->offStrTab     = pReq->u.In.offStrTab;
     3268    pImage->cbStrTab      = pReq->u.In.cbStrTab;
    37093269
    37103270    /*
    37113271     * Update any entry points.
    37123272     */
    3713     switch (pIn->eEPType)
     3273    switch (pReq->u.In.eEPType)
    37143274    {
    37153275        default:
    37163276        case EP_NOTHING:
    3717             rc = 0;
     3277            rc = VINF_SUCCESS;
    37183278            break;
    37193279        case EP_VMMR0:
    3720             rc = supdrvLdrSetR0EP(pDevExt, pIn->EP.VMMR0.pvVMMR0, pIn->EP.VMMR0.pvVMMR0Entry);
     3280            rc = supdrvLdrSetR0EP(pDevExt, pReq->u.In.EP.VMMR0.pvVMMR0, pReq->u.In.EP.VMMR0.pvVMMR0Entry);
    37213281            break;
    37223282    }
    … …  
    37453305 * Frees a previously loaded (prep'ed) image.
    37463306 *
    3747  * @returns 0 on success.
    3748  * @returns SUPDRV_ERR_* on failure.
     3307 * @returns IPRT status code.
    37493308 * @param   pDevExt     Device globals.
    37503309 * @param   pSession    Session data.
    3751  * @param   pIn         Input.
    3752  */
    3753 static int supdrvIOCtl_LdrFree(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRFREE_IN pIn)
     3310 * @param   pReq        The request.
     3311 */
     3312static int supdrvIOCtl_LdrFree(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRFREE pReq)
    37543313{
    37553314    PSUPDRVLDRUSAGE pUsagePrev;
    37563315    PSUPDRVLDRUSAGE pUsage;
    37573316    PSUPDRVLDRIMAGE pImage;
    3758     dprintf(("supdrvIOCtl_LdrFree: pvImageBase=%p\n", pIn->pvImageBase));
     3317    dprintf(("supdrvIOCtl_LdrFree: pvImageBase=%p\n", pReq->u.In.pvImageBase));
    37593318
    37603319    /*
    … …  
    37643323    pUsagePrev = NULL;
    37653324    pUsage = pSession->pLdrUsage;
    3766     while (pUsage && pUsage->pImage->pvImage != pIn->pvImageBase)
     3325    while (pUsage && pUsage->pImage->pvImage != pReq->u.In.pvImageBase)
    37673326    {
    37683327        pUsagePrev = pUsage;
    … …  
    37733332        RTSemFastMutexRelease(pDevExt->mtxLdr);
    37743333        dprintf(("SUP_IOCTL_LDR_FREE: couldn't find image!\n"));
    3775         return SUPDRV_ERR_INVALID_HANDLE;
     3334        return VERR_INVALID_HANDLE;
    37763335    }
    37773336
    … …  
    38103369
    38113370    RTSemFastMutexRelease(pDevExt->mtxLdr);
    3812     return 0;
     3371    return VINF_SUCCESS;
    38133372}
    38143373
    … …  
    38213380 * @param   pDevExt     Device globals.
    38223381 * @param   pSession    Session data.
    3823  * @param   pIn         Input.
    3824  * @param   pOut        Output. (May overlap pIn.)
    3825  */
    3826 static int supdrvIOCtl_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRGETSYMBOL_IN pIn, PSUPLDRGETSYMBOL_OUT pOut)
     3382 * @param   pReq        The request buffer.
     3383 */
     3384static int supdrvIOCtl_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRGETSYMBOL pReq)
    38273385{
    38283386    PSUPDRVLDRIMAGE pImage;
    … …  
    38313389    PSUPLDRSYM      paSyms;
    38323390    const char     *pchStrings;
    3833     const size_t    cbSymbol = strlen(pIn->szSymbol) + 1;
     3391    const size_t    cbSymbol = strlen(pReq->u.In.szSymbol) + 1;
    38343392    void           *pvSymbol = NULL;
    3835     int             rc = SUPDRV_ERR_GENERAL_FAILURE; /** @todo better error code. */
    3836     dprintf2(("supdrvIOCtl_LdrGetSymbol: pvImageBase=%p szSymbol=\"%s\"\n", pIn->pvImageBase, pIn->szSymbol));
     3393    int             rc = VERR_GENERAL_FAILURE;
     3394    dprintf2(("supdrvIOCtl_LdrGetSymbol: pvImageBase=%p szSymbol=\"%s\"\n", pReq->u.In.pvImageBase, pReq->u.In.szSymbol));
    38373395
    38383396    /*
    … …  
    38413399    RTSemFastMutexRequest(pDevExt->mtxLdr);
    38423400    pUsage = pSession->pLdrUsage;
    3843     while (pUsage && pUsage->pImage->pvImage != pIn->pvImageBase)
     3401    while (pUsage && pUsage->pImage->pvImage != pReq->u.In.pvImageBase)
    38443402        pUsage = pUsage->pNext;
    38453403    if (!pUsage)
    … …  
    38473405        RTSemFastMutexRelease(pDevExt->mtxLdr);
    38483406        dprintf(("SUP_IOCTL_LDR_GET_SYMBOL: couldn't find image!\n"));
    3849         return SUPDRV_ERR_INVALID_HANDLE;
     3407        return VERR_INVALID_HANDLE;
    38503408    }
    38513409    pImage = pUsage->pImage;
    … …  
    38553413        RTSemFastMutexRelease(pDevExt->mtxLdr);
    38563414        dprintf(("SUP_IOCTL_LDR_GET_SYMBOL: invalid image state %d (%#x)!\n", uState, uState)); NOREF(uState);
    3857         return SUPDRV_ERR_ALREADY_LOADED;
     3415        return VERR_ALREADY_LOADED;
    38583416    }
    38593417
    … …  
    38673425        if (    paSyms[i].offSymbol < pImage->cbImage /* paranoia */
    38683426            &&  paSyms[i].offName + cbSymbol <= pImage->cbStrTab
    3869             &&  !memcmp(pchStrings + paSyms[i].offName, pIn->szSymbol, cbSymbol))
     3427            &&  !memcmp(pchStrings + paSyms[i].offName, pReq->u.In.szSymbol, cbSymbol))
    38703428        {
    38713429            pvSymbol = (uint8_t *)pImage->pvImage + paSyms[i].offSymbol;
    3872             rc = 0;
     3430            rc = VINF_SUCCESS;
    38733431            break;
    38743432        }
    38753433    }
    38763434    RTSemFastMutexRelease(pDevExt->mtxLdr);
    3877     pOut->pvSymbol = pvSymbol;
     3435    pReq->u.Out.pvSymbol = pvSymbol;
    38783436    return rc;
    38793437}
    … …  
    38843442 * point (i.e. VMMR0Enter()).
    38853443 *
    3886  * @returns 0 on success.
    3887  * @returns SUPDRV_ERR_* on failure.
     3444 * @returns IPRT status code.
    38883445 * @param   pDevExt     Device globals.
    38893446 * @param   pSession    Session data.
    … …  
    38943451static int supdrvLdrSetR0EP(PSUPDRVDEVEXT pDevExt, void *pvVMMR0, void *pvVMMR0Entry)
    38953452{
    3896     int     rc;
     3453    int rc = VINF_SUCCESS;
    38973454    dprintf(("supdrvLdrSetR0EP pvVMMR0=%p pvVMMR0Entry=%p\n", pvVMMR0, pvVMMR0Entry));
    38983455
    … …  
    39013458     * Check if not yet set.
    39023459     */
    3903     rc = 0;
    39043460    if (!pDevExt->pvVMMR0)
    39053461    {
    … …  
    39353491        {
    39363492            AssertMsgFailed(("SUP_IOCTL_LDR_SETR0EP: Already set pointing to a different module!\n"));
    3937             rc = SUPDRV_ERR_INVALID_PARAM;
     3493            rc = VERR_INVALID_PARAMETER;
    39383494        }
    39393495    }
    … …  
    40653621 * Gets the current paging mode of the CPU and stores in in pOut.
    40663622 */
    4067 static int supdrvIOCtl_GetPagingMode(PSUPGETPAGINGMODE_OUT pOut)
    4068 {
     3623static SUPPAGINGMODE supdrvIOCtl_GetPagingMode(void)
     3624{
     3625    SUPPAGINGMODE enmMode;
     3626
    40693627    RTUINTREG cr0 = ASMGetCR0();
    40703628    if ((cr0 & (X86_CR0_PG | X86_CR0_PE)) != (X86_CR0_PG | X86_CR0_PE))
    4071         pOut->enmMode = SUPPAGINGMODE_INVALID;
     3629        enmMode = SUPPAGINGMODE_INVALID;
    40723630    else
    40733631    {
    … …  
    40903648        {
    40913649            case 0:
    4092                 pOut->enmMode = SUPPAGINGMODE_32_BIT;
     3650                enmMode = SUPPAGINGMODE_32_BIT;
    40933651                break;
    40943652
    40953653            case X86_CR4_PGE:
    4096                 pOut->enmMode = SUPPAGINGMODE_32_BIT_GLOBAL;
     3654                enmMode = SUPPAGINGMODE_32_BIT_GLOBAL;
    40973655                break;
    40983656
    40993657            case X86_CR4_PAE:
    4100                 pOut->enmMode = SUPPAGINGMODE_PAE;
     3658                enmMode = SUPPAGINGMODE_PAE;
    41013659                break;
    41023660
    41033661            case X86_CR4_PAE | BIT(0):
    4104                 pOut->enmMode = SUPPAGINGMODE_PAE_NX;
     3662                enmMode = SUPPAGINGMODE_PAE_NX;
    41053663                break;
    41063664
    41073665            case X86_CR4_PAE | X86_CR4_PGE:
    4108                 pOut->enmMode = SUPPAGINGMODE_PAE_GLOBAL;
     3666                enmMode = SUPPAGINGMODE_PAE_GLOBAL;
    41093667                break;
    41103668
    41113669            case X86_CR4_PAE | X86_CR4_PGE | BIT(0):
    4112                 pOut->enmMode = SUPPAGINGMODE_PAE_GLOBAL;
     3670                enmMode = SUPPAGINGMODE_PAE_GLOBAL;
    41133671                break;
    41143672
    41153673            case BIT(1) | X86_CR4_PAE:
    4116                 pOut->enmMode = SUPPAGINGMODE_AMD64;
     3674                enmMode = SUPPAGINGMODE_AMD64;
    41173675                break;
    41183676
    41193677            case BIT(1) | X86_CR4_PAE | BIT(0):
    4120                 pOut->enmMode = SUPPAGINGMODE_AMD64_NX;
     3678                enmMode = SUPPAGINGMODE_AMD64_NX;
    41213679                break;
    41223680
    41233681            case BIT(1) | X86_CR4_PAE | X86_CR4_PGE:
    4124                 pOut->enmMode = SUPPAGINGMODE_AMD64_GLOBAL;
     3682                enmMode = SUPPAGINGMODE_AMD64_GLOBAL;
    41253683                break;
    41263684
    41273685            case BIT(1) | X86_CR4_PAE | X86_CR4_PGE | BIT(0):
    4128                 pOut->enmMode = SUPPAGINGMODE_AMD64_GLOBAL_NX;
     3686                enmMode = SUPPAGINGMODE_AMD64_GLOBAL_NX;
    41293687                break;
    41303688
    41313689            default:
    41323690                AssertMsgFailed(("Cannot happen! cr4=%#x fNXEPlusLMA=%d\n", cr4, fNXEPlusLMA));
    4133                 pOut->enmMode = SUPPAGINGMODE_INVALID;
     3691                enmMode = SUPPAGINGMODE_INVALID;
    41343692                break;
    41353693        }
    41363694    }
    4137     return 0;
     3695    return enmMode;
    41383696}
    41393697
    … …  
    41783736                *ppvR0 = RTR0MemObjAddress(pMem->u.iprt.MemObj);
    41793737                *ppvR3 = RTR0MemObjAddressR3(pMem->u.iprt.MapObjR3);
    4180                 return 0;
     3738                return VINF_SUCCESS;
    41813739            }
    41823740
    … …  
    43043862     */
    43053863    supdrvGipInit(pDevExt, pGip, HCPhysGip, RTTimeSystemNanoTS(), 1000000000 / u32Interval /*=Hz*/);
    4306     return 0;
     3864    return VINF_SUCCESS;
    43073865}
    43083866
    … …  
    43113869 * Terminates the GIP.
    43123870 *
    4313  * @returns negative errno.
    43143871 * @param   pDevExt     Instance data. GIP stuff may be updated.
    43153872 */
    4316 static int supdrvGipDestroy(PSUPDRVDEVEXT pDevExt)
     3873static void supdrvGipDestroy(PSUPDRVDEVEXT pDevExt)
    43173874{
    43183875    int rc;
    … …  
    43293886    {
    43303887        supdrvGipTerm(pDevExt->pGip);
    4331         pDevExt->pGip = 0;
     3888        pDevExt->pGip = NULL;
    43323889    }
    43333890
    … …  
    43553912        pDevExt->u32SystemTimerGranularityGrant = 0;
    43563913    }
    4357 
    4358     return 0;
    43593914}
    43603915
    … …  
    43763931 * Initializes the GIP data.
    43773932 *
    4378  * @returns VBox status code.
     3933 * @returns IPRT status code.
    43793934 * @param   pDevExt     Pointer to the device instance data.
    43803935 * @param   pGip        Pointer to the read-write kernel mapping of the GIP.
    … …  
    44323987    pDevExt->cGipUsers = 0;
    44333988
    4434     return 0;
     3989    return VINF_SUCCESS;
    44353990}
    44363991
    … …  
    46004155 * @param   u64NanoTS   The current nanosecond timesamp.
    46014156 */
    4602 void VBOXCALL   supdrvGipUpdate(PSUPGLOBALINFOPAGE pGip, uint64_t u64NanoTS)
     4157void VBOXCALL supdrvGipUpdate(PSUPGLOBALINFOPAGE pGip, uint64_t u64NanoTS)
    46034158{
    46044159    /*
    … …  
    46674222 * @param   iCpu        The CPU index.
    46684223 */
    4669 void VBOXCALL   supdrvGipUpdatePerCpu(PSUPGLOBALINFOPAGE pGip, uint64_t u64NanoTS, unsigned iCpu)
     4224void VBOXCALL supdrvGipUpdatePerCpu(PSUPGLOBALINFOPAGE pGip, uint64_t u64NanoTS, unsigned iCpu)
    46704225{
    46714226    PSUPGIPCPU  pGipCpu;

  • trunk/src/VBox/HostDrivers/Support/SUPLib.cpp

    r4765 r4800  
    4242#include <VBox/err.h>
    4343#include <VBox/param.h>
    44 #ifdef VBOX_WITHOUT_IDT_PATCHING
    45 # include <VBox/vmm.h>
    46 #endif
     44#include <VBox/vmm.h>
    4745#include <VBox/log.h>
    4846
    … …  
    5755#include <iprt/string.h>
    5856#include <iprt/env.h>
     57#include <iprt/rand.h>
    5958
    6059#include "SUPLibInternal.h"
    … …  
    101100PSUPDRVSESSION      g_pSession;
    102101/** R0 SUP Functions used for resolving referenced to the SUPR0 module. */
    103 static PSUPQUERYFUNCS_OUT g_pFunctions;
     102static PSUPQUERYFUNCS g_pFunctions;
    104103
    105104#ifndef VBOX_WITHOUT_IDT_PATCHING
    … …  
    113112/** Init counter. */
    114113static unsigned     g_cInits = 0;
     114/** PAGE_ALLOC support indicator. */
     115static bool         g_fSupportsPageAllocLocked = true;
    115116/** Fake mode indicator. (~0 at first, 0 or 1 after first test) */
    116117static uint32_t     g_u32FakeMode = ~0;
    … …  
    183184     */
    184185    int rc = suplibOsInit(cbReserve);
    185     if (VBOX_SUCCESS(rc))
     186    if (RT_SUCCESS(rc))
    186187    {
    187188        /*
    188189         * Negotiate the cookie.
    189190         */
    190         SUPCOOKIE_IN    In;
    191         SUPCOOKIE_OUT   Out = {0,0,0,0,0,NIL_RTR0PTR};
    192         strcpy(In.szMagic, SUPCOOKIE_MAGIC);
    193         In.u32ReqVersion = SUPDRVIOC_VERSION;
    194         In.u32MinVersion = SUPDRVIOC_VERSION & 0xffff0000;
    195         rc = suplibOsIOCtl(SUP_IOCTL_COOKIE, &In, sizeof(In), &Out, sizeof(Out));
    196         if (VBOX_SUCCESS(rc))
     191        SUPCOOKIE CookieReq;
     192        memset(&CookieReq, 0xff, sizeof(CookieReq));
     193        CookieReq.Hdr.u32Cookie = SUPCOOKIE_INITIAL_COOKIE;
     194        CookieReq.Hdr.u32SessionCookie = RTRandU32();
     195        CookieReq.Hdr.cbIn = SUP_IOCTL_COOKIE_SIZE_IN;
     196        CookieReq.Hdr.cbOut = SUP_IOCTL_COOKIE_SIZE_OUT;
     197        CookieReq.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     198        CookieReq.Hdr.rc = VERR_INTERNAL_ERROR;
     199        strcpy(CookieReq.u.In.szMagic, SUPCOOKIE_MAGIC);
     200        CookieReq.u.In.u32ReqVersion = SUPDRVIOC_VERSION;
     201        CookieReq.u.In.u32MinVersion = SUPDRVIOC_VERSION & 0xffff0000;
     202        rc = suplibOsIOCtl(SUP_IOCTL_COOKIE, &CookieReq, SUP_IOCTL_COOKIE_SIZE);
     203        if (    RT_SUCCESS(rc)
     204            &&  RT_SUCCESS(CookieReq.Hdr.rc))
    197205        {
    198             if ((Out.u32SessionVersion & 0xffff0000) == (SUPDRVIOC_VERSION & 0xffff0000))
     206            if ((CookieReq.u.Out.u32SessionVersion & 0xffff0000) == (SUPDRVIOC_VERSION & 0xffff0000))
    199207            {
    200208                /*
    201209                 * Query the functions.
    202210                 */
    203                 SUPQUERYFUNCS_IN    FuncsIn;
    204                 FuncsIn.u32Cookie           = Out.u32Cookie;
    205                 FuncsIn.u32SessionCookie    = Out.u32SessionCookie;
    206                 unsigned            cbFuncsOut = RT_OFFSETOF(SUPQUERYFUNCS_OUT, aFunctions[Out.cFunctions]);
    207                 PSUPQUERYFUNCS_OUT  pFuncsOut = (PSUPQUERYFUNCS_OUT)RTMemAllocZ(cbFuncsOut);
    208                 if (pFuncsOut)
     211                PSUPQUERYFUNCS pFuncsReq = (PSUPQUERYFUNCS)RTMemAllocZ(SUP_IOCTL_QUERY_FUNCS_SIZE(CookieReq.u.Out.cFunctions));
     212                if (pFuncsReq)
    209213                {
    210                     rc = suplibOsIOCtl(SUP_IOCTL_QUERY_FUNCS, &FuncsIn, sizeof(FuncsIn), pFuncsOut, cbFuncsOut);
    211                     if (VBOX_SUCCESS(rc))
     214                    pFuncsReq->Hdr.u32Cookie            = CookieReq.u.Out.u32Cookie;
     215                    pFuncsReq->Hdr.u32SessionCookie     = CookieReq.u.Out.u32SessionCookie;
     216                    pFuncsReq->Hdr.cbIn                 = SUP_IOCTL_QUERY_FUNCS_SIZE_IN;
     217                    pFuncsReq->Hdr.cbOut                = SUP_IOCTL_QUERY_FUNCS_SIZE_OUT(CookieReq.u.Out.cFunctions);
     218                    pFuncsReq->Hdr.fFlags               = SUPREQHDR_FLAGS_DEFAULT;
     219                    pFuncsReq->Hdr.rc                   = VERR_INTERNAL_ERROR;
     220                    rc = suplibOsIOCtl(SUP_IOCTL_QUERY_FUNCS(CookieReq.u.Out.cFunctions), pFuncsReq, SUP_IOCTL_QUERY_FUNCS_SIZE(CookieReq.u.Out.cFunctions));
     221                    if (RT_SUCCESS(rc))
     222                        rc = pFuncsReq->Hdr.rc;
     223                    if (RT_SUCCESS(rc))
    212224                    {
    213                         g_u32Cookie         = Out.u32Cookie;
    214                         g_u32SessionCookie  = Out.u32SessionCookie;
    215                         g_pSession          = Out.pSession;
    216                         g_pFunctions        = pFuncsOut;
     225                        g_u32Cookie         = CookieReq.u.Out.u32Cookie;
     226                        g_u32SessionCookie  = CookieReq.u.Out.u32SessionCookie;
     227                        g_pSession          = CookieReq.u.Out.pSession;
     228                        g_pFunctions        = pFuncsReq;
    217229                        if (ppSession)
    218                             *ppSession = Out.pSession;
     230                            *ppSession = CookieReq.u.Out.pSession;
    219231
    220232                        /*
    … …  
    224236                        if (!g_pSUPGlobalInfoPage)
    225237                        {
    226                             SUPGIPMAP_IN GipIn = {0};
    227                             SUPGIPMAP_OUT GipOut = {NULL, 0};
    228                             GipIn.u32Cookie           = Out.u32Cookie;
    229                             GipIn.u32SessionCookie    = Out.u32SessionCookie;
    230                             rc = suplibOsIOCtl(SUP_IOCTL_GIP_MAP, &GipIn, sizeof(GipIn), &GipOut, sizeof(GipOut));
    231                             if (VBOX_SUCCESS(rc))
     238                            SUPGIPMAP GipMapReq;
     239                            GipMapReq.Hdr.u32Cookie = g_u32Cookie;
     240                            GipMapReq.Hdr.u32SessionCookie = g_u32SessionCookie;
     241                            GipMapReq.Hdr.cbIn = SUP_IOCTL_GIP_MAP_SIZE_IN;
     242                            GipMapReq.Hdr.cbOut = SUP_IOCTL_GIP_MAP_SIZE_OUT;
     243                            GipMapReq.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     244                            GipMapReq.Hdr.rc = VERR_INTERNAL_ERROR;
     245                            GipMapReq.u.Out.HCPhysGip = NIL_RTHCPHYS;
     246                            GipMapReq.u.Out.pGipR0 = NIL_RTR0PTR;
     247                            GipMapReq.u.Out.pGipR3 = NULL;
     248                            rc = suplibOsIOCtl(SUP_IOCTL_GIP_MAP, &GipMapReq, SUP_IOCTL_GIP_MAP_SIZE);
     249                            if (RT_SUCCESS(rc))
     250                                rc = pFuncsReq->Hdr.rc;
     251                            if (RT_SUCCESS(rc))
    232252                            {
    233                                 AssertRelease(GipOut.pGipR3->u32Magic == SUPGLOBALINFOPAGE_MAGIC);
    234                                 AssertRelease(GipOut.pGipR3->u32Version >= SUPGLOBALINFOPAGE_VERSION);
    235                                 ASMAtomicXchgSize(&g_HCPhysSUPGlobalInfoPage, GipOut.HCPhysGip);
    236                                 ASMAtomicCmpXchgPtr((void * volatile *)&g_pSUPGlobalInfoPage, (void *)GipOut.pGipR3, NULL);
    237                                 ASMAtomicCmpXchgPtr((void * volatile *)&g_pSUPGlobalInfoPageR0, (void *)GipOut.pGipR0, NULL);
     253                                AssertRelease(GipMapReq.u.Out.pGipR3->u32Magic == SUPGLOBALINFOPAGE_MAGIC);
     254                                AssertRelease(GipMapReq.u.Out.pGipR3->u32Version >= SUPGLOBALINFOPAGE_VERSION);
     255                                ASMAtomicXchgSize(&g_HCPhysSUPGlobalInfoPage, GipMapReq.u.Out.HCPhysGip);
     256                                ASMAtomicCmpXchgPtr((void * volatile *)&g_pSUPGlobalInfoPage, GipMapReq.u.Out.pGipR3, NULL);
     257                                ASMAtomicCmpXchgPtr((void * volatile *)&g_pSUPGlobalInfoPageR0, (void *)GipMapReq.u.Out.pGipR0, NULL);
    238258                            }
    239                             else
    240                                 rc = VINF_SUCCESS;
    241259                        }
    242                         return rc;
     260                        return VINF_SUCCESS;
    243261                    }
    244                     RTMemFree(pFuncsOut);
     262
     263                    /* bailout */
     264                    RTMemFree(pFuncsReq);
    245265                }
    246266                else
    … …  
    250270            {
    251271                LogRel(("Support driver version mismatch: SessionVersion=%#x DriverVersion=%#x ClientVersion=%#x\n",
    252                         Out.u32SessionVersion, Out.u32DriverVersion, SUPDRVIOC_VERSION));
     272                        CookieReq.u.Out.u32SessionVersion, CookieReq.u.Out.u32DriverVersion, SUPDRVIOC_VERSION));
    253273                rc = VERR_VM_DRIVER_VERSION_MISMATCH;
    254274            }
    … …  
    256276        else
    257277        {
    258              if (rc == VERR_INVALID_PARAMETER) /* for pre 0x00040002 drivers */
    259                  rc = VERR_VM_DRIVER_VERSION_MISMATCH;
    260              if (rc == VERR_VM_DRIVER_VERSION_MISMATCH)
    261                  LogRel(("Support driver version mismatch: DriverVersion=%#x ClientVersion=%#x\n",
    262                          Out.u32DriverVersion, SUPDRVIOC_VERSION));
    263              else
    264                  LogRel(("Support driver version/Cookie negotiations error: rc=%Vrc\n", rc));
     278            if (RT_SUCCESS(rc))
     279            {
     280                rc = CookieReq.Hdr.rc;
     281                LogRel(("Support driver version mismatch: DriverVersion=%#x ClientVersion=%#x rc=%Rrc\n",
     282                        CookieReq.u.Out.u32DriverVersion, SUPDRVIOC_VERSION, rc));
     283                if (rc != VERR_VM_DRIVER_VERSION_MISMATCH)
     284                    rc = VERR_VM_DRIVER_VERSION_MISMATCH;
     285            }
     286            else
     287            {
     288                /* for pre 0x00060000 drivers */
     289                LogRel(("Support driver version mismatch: DriverVersion=too-old ClientVersion=%#x\n", SUPDRVIOC_VERSION));
     290                rc = VERR_VM_DRIVER_VERSION_MISMATCH;
     291            }
    265292        }
    266293
    … …  
    325352
    326353    /* fake r0 functions. */
    327     g_pFunctions = (PSUPQUERYFUNCS_OUT)RTMemAllocZ(RT_OFFSETOF(SUPQUERYFUNCS_OUT, aFunctions[RT_ELEMENTS(s_aFakeFunctions)]));
     354    g_pFunctions = (PSUPQUERYFUNCS)RTMemAllocZ(SUP_IOCTL_QUERY_FUNCS_SIZE(RT_ELEMENTS(s_aFakeFunctions)));
    328355    if (g_pFunctions)
    329356    {
    330         g_pFunctions->cFunctions = RT_ELEMENTS(s_aFakeFunctions);
    331         memcpy(&g_pFunctions->aFunctions[0], &s_aFakeFunctions[0], sizeof(s_aFakeFunctions));
     357        g_pFunctions->u.Out.cFunctions = RT_ELEMENTS(s_aFakeFunctions);
     358        memcpy(&g_pFunctions->u.Out.aFunctions[0], &s_aFakeFunctions[0], sizeof(s_aFakeFunctions));
    332359        g_pSession = (PSUPDRVSESSION)(void *)g_pFunctions;
    333360        if (ppSession)
    … …  
    338365
    339366        /* fake the GIP. */
    340         g_pSUPGlobalInfoPage = (PSUPGLOBALINFOPAGE)RTMemPageAlloc(PAGE_SIZE);
     367        g_pSUPGlobalInfoPage = (PSUPGLOBALINFOPAGE)RTMemPageAllocZ(PAGE_SIZE);
    341368        if (g_pSUPGlobalInfoPage)
    342369        {
    … …  
    399426SUPR3DECL(SUPPAGINGMODE) SUPGetPagingMode(void)
    400427{
     428    /* fake */
     429    if (RT_UNLIKELY(g_u32FakeMode))
     430#ifdef RT_ARCH_AMD64
     431        return SUPPAGINGMODE_AMD64_GLOBAL_NX;
     432#else
     433        return SUPPAGINGMODE_32_BIT_GLOBAL;
     434#endif
     435
    401436    /*
    402437     * Issue IOCtl to the SUPDRV kernel module.
    403438     */
    404     SUPGETPAGINGMODE_IN In;
    405     In.u32Cookie        = g_u32Cookie;
    406     In.u32SessionCookie = g_u32SessionCookie;
    407     SUPGETPAGINGMODE_OUT Out = {SUPPAGINGMODE_INVALID};
     439    SUPGETPAGINGMODE Req;
     440    Req.Hdr.u32Cookie = g_u32Cookie;
     441    Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     442    Req.Hdr.cbIn = SUP_IOCTL_GET_PAGING_MODE_SIZE_IN;
     443    Req.Hdr.cbOut = SUP_IOCTL_GET_PAGING_MODE_SIZE_OUT;
     444    Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     445    Req.Hdr.rc = VERR_INTERNAL_ERROR;
     446    int rc = suplibOsIOCtl(SUP_IOCTL_GET_PAGING_MODE, &Req, SUP_IOCTL_GET_PAGING_MODE_SIZE);
     447    if (    RT_FAILURE(rc)
     448        ||  RT_FAILURE(Req.Hdr.rc))
     449    {
     450        LogRel(("SUPGetPagingMode: %Rrc %Rrc\n", rc, Req.Hdr.rc));
     451        Req.u.Out.enmMode = SUPPAGINGMODE_INVALID;
     452    }
     453
     454    return Req.u.Out.enmMode;
     455}
     456
     457
     458/**
     459 * For later.
     460 */
     461static int supCallVMMR0ExFake(PVMR0 pVMR0, unsigned uOperation, void *pvVMMReq, size_t cbVMMReq)
     462{
     463    AssertMsgFailed(("%d\n", uOperation));
     464    return VERR_NOT_SUPPORTED;
     465}
     466
     467
     468SUPR3DECL(int) SUPCallVMMR0Ex(PVMR0 pVMR0, unsigned uOperation, void *pvVMMReq, size_t cbVMMReq)
     469{
     470    /*
     471     * The following operations don't belong here.
     472     */
     473    AssertMsgReturn(    uOperation != VMMR0_DO_RAW_RUN
     474                    &&  uOperation != VMMR0_DO_HWACC_RUN
     475                    &&  uOperation != VMMR0_DO_NOP,
     476                    ("%#x\n", uOperation),
     477                    VERR_INTERNAL_ERROR);
     478    /* fake */
     479    if (RT_UNLIKELY(g_u32FakeMode))
     480        return supCallVMMR0ExFake(pVMR0, uOperation, pvVMMReq, cbVMMReq);
     481
    408482    int rc;
    409     if (!g_u32FakeMode)
    410     {
    411         rc = suplibOsIOCtl(SUP_IOCTL_GET_PAGING_MODE, &In, sizeof(In), &Out, sizeof(Out));
    412         if (VBOX_FAILURE(rc))
    413             Out.enmMode = SUPPAGINGMODE_INVALID;
    414     }
    415     else
    416 #ifdef RT_ARCH_AMD64
    417         Out.enmMode = SUPPAGINGMODE_AMD64_GLOBAL_NX;
    418 #else
    419         Out.enmMode = SUPPAGINGMODE_32_BIT_GLOBAL;
    420 #endif
    421 
    422     return Out.enmMode;
    423 }
    424 
    425 SUPR3DECL(int) SUPCallVMMR0Ex(PVMR0 pVMR0, unsigned uOperation, void *pvArg, unsigned cbArg)
    426 {
    427     /*
    428      * Issue IOCtl to the SUPDRV kernel module.
    429      */
    430     SUPCALLVMMR0_IN In;
    431     In.u32Cookie        = g_u32Cookie;
    432     In.u32SessionCookie = g_u32SessionCookie;
    433     In.pVMR0            = pVMR0;
    434     In.uOperation       = uOperation;
    435     In.cbArg            = cbArg;
    436     In.pvArg            = pvArg;
    437     Assert(!g_u32FakeMode);
    438     SUPCALLVMMR0_OUT Out = {VINF_SUCCESS};
    439     int rc = suplibOsIOCtl(SUP_IOCTL_CALL_VMMR0, &In, sizeof(In), &Out, sizeof(Out));
    440     if (VBOX_SUCCESS(rc))
    441         rc = Out.rc;
     483    if (!cbVMMReq)
     484    {
     485        /* no data. */
     486        SUPCALLVMMR0 Req;
     487        Req.Hdr.u32Cookie = g_u32Cookie;
     488        Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     489        Req.Hdr.cbIn = SUP_IOCTL_CALL_VMMR0_SIZE_IN(0);
     490        Req.Hdr.cbOut = SUP_IOCTL_CALL_VMMR0_SIZE_OUT(0);
     491        Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     492        Req.Hdr.rc = VERR_INTERNAL_ERROR;
     493        Req.u.In.pVMR0 = pVMR0;
     494        Req.u.In.uOperation = uOperation;
     495        Req.u.In.uArg = (uintptr_t)pvVMMReq;
     496        rc = suplibOsIOCtl(SUP_IOCTL_CALL_VMMR0(0), &Req, SUP_IOCTL_CALL_VMMR0_SIZE(0));
     497        if (RT_SUCCESS(rc))
     498            rc = Req.Hdr.rc;
     499    }
     500    else if (SUP_IOCTL_CALL_VMMR0_SIZE(cbVMMReq) < _4K) /* FreeBSD won't copy more than 4K. */
     501    {
     502        AssertPtr(pvVMMReq);
     503        PSUPCALLVMMR0 pReq = (PSUPCALLVMMR0)alloca(SUP_IOCTL_CALL_VMMR0_SIZE(cbVMMReq));
     504        pReq->Hdr.u32Cookie = g_u32Cookie;
     505        pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
     506        pReq->Hdr.cbIn = SUP_IOCTL_CALL_VMMR0_SIZE_IN(cbVMMReq);
     507        pReq->Hdr.cbOut = SUP_IOCTL_CALL_VMMR0_SIZE_OUT(cbVMMReq);
     508        pReq->Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     509        pReq->Hdr.rc = VERR_INTERNAL_ERROR;
     510        pReq->u.In.pVMR0 = pVMR0;
     511        pReq->u.In.uOperation = uOperation;
     512        pReq->u.In.uArg = 0;
     513        memcpy(&pReq->abReqPkt[0], pvVMMReq, cbVMMReq);
     514        rc = suplibOsIOCtl(SUP_IOCTL_CALL_VMMR0(cbVMMReq), pReq, SUP_IOCTL_CALL_VMMR0_SIZE(cbVMMReq));
     515        if (RT_SUCCESS(rc))
     516            rc = pReq->Hdr.rc;
     517        memcpy(pvVMMReq, &pReq->abReqPkt[0], cbVMMReq);
     518    }
     519    else /** @todo may have to remove the size limits one this request... */
     520        AssertMsgFailedReturn(("cbVMMReq=%#x\n", cbVMMReq), VERR_INTERNAL_ERROR);
    442521    return rc;
    443522}
    … …  
    460539        return suplibOSIOCtlFast(SUP_IOCTL_FAST_DO_HWACC_RUN);
    461540    }
    462     if (uOperation == VMMR0_DO_NOP)
     541    if (RT_LIKELY(uOperation == VMMR0_DO_NOP))
    463542    {
    464543        Assert(!pvArg);
    465544        return suplibOSIOCtlFast(SUP_IOCTL_FAST_DO_NOP);
    466545    }
    467     return SUPCallVMMR0Ex(pVMR0, uOperation, pvArg, pvArg ? sizeof(pvArg) : 0);
     546    AssertMsgFailedReturn(("uOperation=%#x\n", uOperation), VERR_INTERNAL_ERROR);
    468547#endif
    469548}
    … …  
    472551SUPR3DECL(int) SUPSetVMForFastIOCtl(PVMR0 pVMR0)
    473552{
    474     SUPSETVMFORFAST_IN In;
    475     In.u32Cookie        = g_u32Cookie;
    476     In.u32SessionCookie = g_u32SessionCookie;
    477     In.pVMR0            = pVMR0;
    478     int rc;
    479     if (RT_LIKELY(!g_u32FakeMode))
    480         rc = suplibOsIOCtl(SUP_IOCTL_SET_VM_FOR_FAST, &In, sizeof(In), NULL, 0);
    481     else
    482         rc = VINF_SUCCESS;
     553    if (RT_UNLIKELY(g_u32FakeMode))
     554        return VINF_SUCCESS;
     555
     556    SUPSETVMFORFAST Req;
     557    Req.Hdr.u32Cookie = g_u32Cookie;
     558    Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     559    Req.Hdr.cbIn = SUP_IOCTL_SET_VM_FOR_FAST_SIZE_IN;
     560    Req.Hdr.cbOut = SUP_IOCTL_SET_VM_FOR_FAST_SIZE_OUT;
     561    Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     562    Req.Hdr.rc = VERR_INTERNAL_ERROR;
     563    Req.u.In.pVMR0 = pVMR0;
     564    int rc = suplibOsIOCtl(SUP_IOCTL_SET_VM_FOR_FAST, &Req, SUP_IOCTL_SET_VM_FOR_FAST_SIZE);
     565    if (RT_SUCCESS(rc))
     566        rc = Req.Hdr.rc;
    483567    return rc;
     568}
     569
     570
     571SUPR3DECL(int) SUPPageAlloc(size_t cPages, void **ppvPages)
     572{
     573    /*
     574     * Validate.
     575     */
     576    AssertPtrReturn(ppvPages, VERR_INVALID_POINTER);
     577    *ppvPages = NULL;
     578    AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
     579
     580#ifdef RT_OS_WINDOWS
     581    /*
     582     * Temporary hack for windows until we've sorted out the
     583     * locked memory that doesn't need to be accessible from kernel space.
     584     */
     585    return SUPPageAllocLockedEx(cPages, ppvPages, NULL);
     586#else
     587    /*
     588     * Call OS specific worker.
     589     */
     590    return suplibOsPageAlloc(cPages, ppvPages);
     591#endif
     592}
     593
     594
     595SUPR3DECL(int) SUPPageFree(void *pvPages, size_t cPages)
     596{
     597    /*
     598     * Validate.
     599     */
     600    AssertPtrReturn(pvPages, VERR_INVALID_POINTER);
     601    AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
     602
     603#ifdef RT_OS_WINDOWS
     604    /*
     605     * Temporary hack for windows, see above.
     606     */
     607    return SUPPageFreeLocked(pvPages, cPages);
     608#else
     609    /*
     610     * Call OS specific worker.
     611     */
     612    return suplibOsPageFree(pvPages, cPages);
     613#endif
    484614}
    485615
    … …  
    494624    AssertPtr(paPages);
    495625
    496     /*
    497      * Issue IOCtl to the SUPDRV kernel module.
    498      */
    499     SUPPINPAGES_IN      In;
    500     In.u32Cookie        = g_u32Cookie;
    501     In.u32SessionCookie = g_u32SessionCookie;
    502     In.pvR3             = pvStart;
    503     In.cPages           = cPages; AssertRelease(In.cPages == cPages);
    504     int rc;
    505     if (!g_u32FakeMode)
    506     {
    507         PSUPPINPAGES_OUT pOut;
    508         AssertCompile(sizeof(paPages[0]) == sizeof(pOut->aPages[0]));
    509 
    510 #if 0
    511         size_t cbOut = RT_OFFSETOF(SUPPINPAGES_OUT, aPages[cPages]);
    512         pOut = (PSUPPINPAGES_OUT)RTMemTmpAllocZ(cbOut);
    513         if (!pOut)
    514             return VERR_NO_TMP_MEMORY;
    515 
    516         rc = suplibOsIOCtl(SUP_IOCTL_PINPAGES, &In, sizeof(In), pOut, cbOut);
    517         if (RT_SUCCESS(rc))
    518             memcpy(paPages, &pOut->aPages[0], sizeof(paPages[0]) * cPages);
    519         RTMemTmpFree(pOut);
    520 
    521 #else
    522         /* a hack to save some time. */
    523         pOut = (PSUPPINPAGES_OUT)(void*)paPages;
    524         Assert(RT_OFFSETOF(SUPPINPAGES_OUT, aPages) == 0 && sizeof(paPages[0]) == sizeof(pOut->aPages[0]));
    525         rc = suplibOsIOCtl(SUP_IOCTL_PINPAGES, &In, sizeof(In), pOut, RT_OFFSETOF(SUPPINPAGES_OUT, aPages[cPages]));
    526 #endif
    527     }
    528     else
    529     {
    530         /* fake a successfull result. */
     626    /* fake */
     627    if (RT_UNLIKELY(g_u32FakeMode))
     628    {
    531629        RTHCPHYS    Phys = (uintptr_t)pvStart + PAGE_SIZE * 1024;
    532630        unsigned    iPage = cPages;
    533631        while (iPage-- > 0)
    534632            paPages[iPage].Phys = Phys + (iPage << PAGE_SHIFT);
    535         rc = VINF_SUCCESS;
    536     }
     633        return VINF_SUCCESS;
     634    }
     635
     636    /*
     637     * Issue IOCtl to the SUPDRV kernel module.
     638     */
     639    int rc;
     640    PSUPPAGELOCK pReq = (PSUPPAGELOCK)RTMemTmpAllocZ(SUP_IOCTL_PAGE_LOCK_SIZE(cPages));
     641    if (RT_LIKELY(pReq))
     642    {
     643        pReq->Hdr.u32Cookie = g_u32Cookie;
     644        pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
     645        pReq->Hdr.cbIn = SUP_IOCTL_PAGE_LOCK_SIZE_IN;
     646        pReq->Hdr.cbOut = SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages);
     647        pReq->Hdr.fFlags = SUPREQHDR_FLAGS_MAGIC | SUPREQHDR_FLAGS_EXTRA_OUT;
     648        pReq->Hdr.rc = VERR_INTERNAL_ERROR;
     649        pReq->u.In.pvR3 = pvStart;
     650        pReq->u.In.cPages = cPages; AssertRelease(pReq->u.In.cPages == cPages);
     651        rc = suplibOsIOCtl(SUP_IOCTL_PAGE_LOCK, pReq, SUP_IOCTL_PAGE_LOCK_SIZE(cPages));
     652        if (RT_SUCCESS(rc))
     653            rc = pReq->Hdr.rc;
     654        if (RT_SUCCESS(rc))
     655        {
     656            for (uint32_t iPage = 0; iPage < cPages; iPage++)
     657            {
     658                paPages[iPage].uReserved = 0;
     659                paPages[iPage].Phys = pReq->u.Out.aPages[iPage];
     660                Assert(!(paPages[iPage].Phys & ~X86_PTE_PAE_PG_MASK));
     661            }
     662        }
     663        RTMemTmpFree(pReq);
     664    }
     665    else
     666        rc = VERR_NO_TMP_MEMORY;
    537667
    538668    return rc;
    … …  
    548678    AssertMsg(RT_ALIGN_P(pvStart, PAGE_SIZE) == pvStart, ("pvStart (%p) must be page aligned\n", pvStart));
    549679
     680    /* fake */
     681    if (RT_UNLIKELY(g_u32FakeMode))
     682        return VINF_SUCCESS;
     683
    550684    /*
    551685     * Issue IOCtl to the SUPDRV kernel module.
    552686     */
    553     SUPUNPINPAGES_IN  In;
    554     In.u32Cookie        = g_u32Cookie;
    555     In.u32SessionCookie = g_u32SessionCookie;
    556     In.pvR3             = pvStart;
     687    SUPPAGEUNLOCK Req;
     688    Req.Hdr.u32Cookie = g_u32Cookie;
     689    Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     690    Req.Hdr.cbIn = SUP_IOCTL_PAGE_UNLOCK_SIZE_IN;
     691    Req.Hdr.cbOut = SUP_IOCTL_PAGE_UNLOCK_SIZE_OUT;
     692    Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     693    Req.Hdr.rc = VERR_INTERNAL_ERROR;
     694    Req.u.In.pvR3 = pvStart;
     695    int rc = suplibOsIOCtl(SUP_IOCTL_PAGE_UNLOCK, &Req, SUP_IOCTL_PAGE_UNLOCK_SIZE);
     696    if (RT_SUCCESS(rc))
     697        rc = Req.Hdr.rc;
     698    return rc;
     699}
     700
     701
     702SUPR3DECL(int) SUPPageAllocLocked(size_t cPages, void **ppvPages)
     703{
     704    return SUPPageAllocLockedEx(cPages, ppvPages, NULL);
     705}
     706
     707
     708/**
     709 * Fallback for SUPPageAllocLockedEx on systems where RTR0MemObjPhysAllocNC isn't supported.
     710 */
     711static int supPageAllocLockedFallback(size_t cPages, void **ppvPages, PSUPPAGE paPages)
     712{
     713    int rc = suplibOsPageAlloc(cPages, ppvPages);
     714    if (RT_SUCCESS(rc))
     715    {
     716        if (!paPages)
     717            paPages = (PSUPPAGE)alloca(sizeof(paPages[0]) * cPages);
     718        rc = SUPPageLock(*ppvPages, cPages, paPages);
     719        if (RT_FAILURE(rc))
     720            suplibOsPageFree(*ppvPages, cPages);
     721    }
     722    return rc;
     723}
     724
     725
     726SUPR3DECL(int) SUPPageAllocLockedEx(size_t cPages, void **ppvPages, PSUPPAGE paPages)
     727{
     728    /*
     729     * Validate.
     730     */
     731    AssertPtrReturn(ppvPages, VERR_INVALID_POINTER);
     732    *ppvPages = NULL;
     733    AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
     734
     735    /* fake */
     736    if (RT_UNLIKELY(g_u32FakeMode))
     737    {
     738        *ppvPages = RTMemPageAllocZ((size_t)cPages * PAGE_SIZE);
     739        if (!*ppvPages)
     740            return VERR_NO_MEMORY;
     741        if (paPages)
     742            for (size_t iPage = 0; iPage < cPages; iPage++)
     743            {
     744                paPages[iPage].uReserved = 0;
     745                paPages[iPage].Phys = (iPage + 1234) << PAGE_SHIFT;
     746                Assert(!(paPages[iPage].Phys & ~X86_PTE_PAE_PG_MASK));
     747            }
     748        return VINF_SUCCESS;
     749    }
     750
     751    /* use fallback? */
     752    if (!g_fSupportsPageAllocLocked)
     753        return supPageAllocLockedFallback(cPages, ppvPages, paPages);
     754
     755    /*
     756     * Issue IOCtl to the SUPDRV kernel module.
     757     */
    557758    int rc;
    558     if (!g_u32FakeMode)
    559         rc = suplibOsIOCtl(SUP_IOCTL_UNPINPAGES, &In, sizeof(In), NULL, 0);
     759    PSUPPAGEALLOC pReq = (PSUPPAGEALLOC)RTMemTmpAllocZ(SUP_IOCTL_PAGE_ALLOC_SIZE(cPages));
     760    if (pReq)
     761    {
     762        pReq->Hdr.u32Cookie = g_u32Cookie;
     763        pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
     764        pReq->Hdr.cbIn = SUP_IOCTL_PAGE_ALLOC_SIZE_IN;
     765        pReq->Hdr.cbOut = SUP_IOCTL_PAGE_ALLOC_SIZE_OUT(cPages);
     766        pReq->Hdr.fFlags = SUPREQHDR_FLAGS_MAGIC | SUPREQHDR_FLAGS_EXTRA_OUT;
     767        pReq->Hdr.rc = VERR_INTERNAL_ERROR;
     768        pReq->u.In.cPages = cPages; AssertRelease(pReq->u.In.cPages == cPages);
     769        rc = suplibOsIOCtl(SUP_IOCTL_PAGE_ALLOC, pReq, SUP_IOCTL_PAGE_ALLOC_SIZE(cPages));
     770        if (RT_SUCCESS(rc))
     771        {
     772            rc = pReq->Hdr.rc;
     773            if (RT_SUCCESS(rc))
     774            {
     775                *ppvPages = pReq->u.Out.pvR3;
     776                if (paPages)
     777                    for (size_t iPage = 0; iPage < cPages; iPage++)
     778                    {
     779                        paPages[iPage].uReserved = 0;
     780                        paPages[iPage].Phys = pReq->u.Out.aPages[iPage];
     781                        Assert(!(paPages[iPage].Phys & ~X86_PTE_PAE_PG_MASK));
     782                    }
     783            }
     784            else if (rc == VERR_NOT_SUPPORTED)
     785            {
     786                g_fSupportsPageAllocLocked = false;
     787                rc = supPageAllocLockedFallback(cPages, ppvPages, paPages);
     788            }
     789        }
     790
     791        RTMemTmpFree(pReq);
     792    }
    560793    else
    561         rc = VINF_SUCCESS;
    562 
     794        rc = VERR_NO_TMP_MEMORY;
    563795    return rc;
    564796}
    565797
    566798
     799SUPR3DECL(int) SUPPageFreeLocked(void *pvPages, size_t cPages)
     800{
     801    /*
     802     * Validate.
     803     */
     804    AssertPtrReturn(pvPages, VERR_INVALID_POINTER);
     805    AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
     806
     807    /* fake */
     808    if (RT_UNLIKELY(g_u32FakeMode))
     809    {
     810        RTMemPageFree(pvPages);
     811        return VINF_SUCCESS;
     812    }
     813
     814    /*
     815     * Issue IOCtl to the SUPDRV kernel module.
     816     */
     817    int rc;
     818    if (g_fSupportsPageAllocLocked)
     819    {
     820        SUPPAGEFREE Req;
     821        Req.Hdr.u32Cookie = g_u32Cookie;
     822        Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     823        Req.Hdr.cbIn = SUP_IOCTL_PAGE_FREE_SIZE_IN;
     824        Req.Hdr.cbOut = SUP_IOCTL_PAGE_FREE_SIZE_OUT;
     825        Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     826        Req.Hdr.rc = VERR_INTERNAL_ERROR;
     827        Req.u.In.pvR3 = pvPages;
     828        rc = suplibOsIOCtl(SUP_IOCTL_PAGE_FREE, &Req, SUP_IOCTL_PAGE_FREE_SIZE);
     829        if (RT_SUCCESS(rc))
     830            rc = Req.Hdr.rc;
     831    }
     832    else
     833    {
     834        /* fallback */
     835        rc = SUPPageUnlock(pvPages);
     836        if (RT_SUCCESS(rc))
     837            rc = suplibOsPageFree(pvPages, cPages);
     838    }
     839    return rc;
     840}
     841
     842
    567843SUPR3DECL(void *) SUPContAlloc(size_t cPages, PRTHCPHYS pHCPhys)
    568844{
    … …  
    576852     * Validate.
    577853     */
    578     AssertMsg(cPages > 0 && cPages < 256, ("cPages=%d must be > 0 and < 256\n", cPages));
    579     AssertPtr(pHCPhys);
     854    AssertPtrReturn(pHCPhys, NULL);
    580855    *pHCPhys = NIL_RTHCPHYS;
    581     AssertPtrNull(pR0Ptr);
     856    AssertPtrNullReturn(pR0Ptr, NULL);
    582857    if (pR0Ptr)
    583858        *pR0Ptr = NIL_RTR0PTR;
     859    AssertPtrNullReturn(pHCPhys, NULL);
     860    AssertMsgReturn(cPages > 0 && cPages < 256, ("cPages=%d must be > 0 and < 256\n", cPages), NULL);
     861
     862    /* fake */
     863    if (RT_UNLIKELY(g_u32FakeMode))
     864    {
     865        void *pv = RTMemPageAllocZ(cPages * PAGE_SIZE);
     866        if (pR0Ptr)
     867            *pR0Ptr = (RTR0PTR)pv;
     868        if (pHCPhys)
     869            *pHCPhys = (uintptr_t)pv + (PAGE_SHIFT * 1024);
     870        return pv;
     871    }
    584872
    585873    /*
    586874     * Issue IOCtl to the SUPDRV kernel module.
    587875     */
    588     SUPCONTALLOC_IN     In;
    589     In.u32Cookie        = g_u32Cookie;
    590     In.u32SessionCookie = g_u32SessionCookie;
    591     In.cPages           = cPages;
    592     SUPCONTALLOC_OUT    Out;
    593     int rc;
    594     if (!g_u32FakeMode)
    595         rc = suplibOsIOCtl(SUP_IOCTL_CONT_ALLOC, &In, sizeof(In), &Out, sizeof(Out));
    596     else
    597     {
    598         rc = SUPPageAlloc(In.cPages, &Out.pvR3);
    599         Out.HCPhys = (uintptr_t)Out.pvR3 + (PAGE_SHIFT * 1024);
    600         Out.pvR0 = (uintptr_t)Out.pvR3;
    601     }
    602     if (VBOX_SUCCESS(rc))
    603     {
    604         *pHCPhys = (RTHCPHYS)Out.HCPhys;
     876    SUPCONTALLOC Req;
     877    Req.Hdr.u32Cookie = g_u32Cookie;
     878    Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     879    Req.Hdr.cbIn = SUP_IOCTL_CONT_ALLOC_SIZE_IN;
     880    Req.Hdr.cbOut = SUP_IOCTL_CONT_ALLOC_SIZE_OUT;
     881    Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     882    Req.Hdr.rc = VERR_INTERNAL_ERROR;
     883    Req.u.In.cPages = cPages;
     884    int rc = suplibOsIOCtl(SUP_IOCTL_CONT_ALLOC, &Req, SUP_IOCTL_CONT_ALLOC_SIZE);
     885    if (    RT_SUCCESS(rc)
     886        &&  RT_SUCCESS(Req.Hdr.rc))
     887    {
     888        *pHCPhys = Req.u.Out.HCPhys;
    605889        if (pR0Ptr)
    606             *pR0Ptr = Out.pvR0;
    607         return Out.pvR3;
     890            *pR0Ptr = Req.u.Out.pvR0;
     891        return Req.u.Out.pvR3;
    608892    }
    609893
    … …  
    617901     * Validate.
    618902     */
    619     AssertPtr(pv);
    620903    if (!pv)
    621904        return VINF_SUCCESS;
     905    AssertPtrReturn(pv, VERR_INVALID_POINTER);
     906    AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
     907
     908    /* fake */
     909    if (RT_UNLIKELY(g_u32FakeMode))
     910    {
     911        RTMemPageFree(pv);
     912        return VINF_SUCCESS;
     913    }
    622914
    623915    /*
    624916     * Issue IOCtl to the SUPDRV kernel module.
    625917     */
    626     SUPCONTFREE_IN     In;
    627     In.u32Cookie        = g_u32Cookie;
    628     In.u32SessionCookie = g_u32SessionCookie;
    629     In.pvR3             = pv;
     918    SUPCONTFREE Req;
     919    Req.Hdr.u32Cookie = g_u32Cookie;
     920    Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     921    Req.Hdr.cbIn = SUP_IOCTL_CONT_FREE_SIZE_IN;
     922    Req.Hdr.cbOut = SUP_IOCTL_CONT_FREE_SIZE_OUT;
     923    Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     924    Req.Hdr.rc = VERR_INTERNAL_ERROR;
     925    Req.u.In.pvR3 = pv;
     926    int rc = suplibOsIOCtl(SUP_IOCTL_CONT_FREE, &Req, SUP_IOCTL_CONT_FREE_SIZE);
     927    if (RT_SUCCESS(rc))
     928        rc = Req.Hdr.rc;
     929    return rc;
     930}
     931
     932
     933SUPR3DECL(int) SUPLowAlloc(size_t cPages, void **ppvPages, PRTR0PTR ppvPagesR0, PSUPPAGE paPages)
     934{
     935    /*
     936     * Validate.
     937     */
     938    AssertPtrReturn(ppvPages, VERR_INVALID_POINTER);
     939    *ppvPages = NULL;
     940    AssertPtrReturn(paPages, VERR_INVALID_POINTER);
     941    AssertMsgReturn(cPages > 0 && cPages < 256, ("cPages=%d must be > 0 and < 256\n", cPages), VERR_INVALID_PARAMETER);
     942
     943    /* fake */
     944    if (RT_UNLIKELY(g_u32FakeMode))
     945    {
     946        *ppvPages = RTMemPageAllocZ((size_t)cPages * PAGE_SIZE);
     947        if (!*ppvPages)
     948            return VERR_NO_LOW_MEMORY;
     949
     950        /* fake physical addresses. */
     951        RTHCPHYS    Phys = (uintptr_t)*ppvPages + PAGE_SIZE * 1024;
     952        unsigned    iPage = cPages;
     953        while (iPage-- > 0)
     954            paPages[iPage].Phys = Phys + (iPage << PAGE_SHIFT);
     955        return VINF_SUCCESS;
     956    }
     957
     958    /*
     959     * Issue IOCtl to the SUPDRV kernel module.
     960     */
    630961    int rc;
    631     if (!g_u32FakeMode)
    632         rc = suplibOsIOCtl(SUP_IOCTL_CONT_FREE, &In, sizeof(In), NULL, 0);
     962    PSUPLOWALLOC pReq = (PSUPLOWALLOC)RTMemTmpAllocZ(SUP_IOCTL_LOW_ALLOC_SIZE(cPages));
     963    if (pReq)
     964    {
     965        pReq->Hdr.u32Cookie = g_u32Cookie;
     966        pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
     967        pReq->Hdr.cbIn = SUP_IOCTL_LOW_ALLOC_SIZE_IN;
     968        pReq->Hdr.cbOut = SUP_IOCTL_LOW_ALLOC_SIZE_OUT(cPages);
     969        pReq->Hdr.fFlags = SUPREQHDR_FLAGS_MAGIC | SUPREQHDR_FLAGS_EXTRA_OUT;
     970        pReq->Hdr.rc = VERR_INTERNAL_ERROR;
     971        pReq->u.In.cPages = cPages; AssertRelease(pReq->u.In.cPages == cPages);
     972        rc = suplibOsIOCtl(SUP_IOCTL_LOW_ALLOC, pReq, SUP_IOCTL_LOW_ALLOC_SIZE(cPages));
     973        if (RT_SUCCESS(rc))
     974            rc = pReq->Hdr.rc;
     975        if (RT_SUCCESS(rc))
     976        {
     977            *ppvPages = pReq->u.Out.pvR3;
     978            if (ppvPagesR0)
     979                *ppvPagesR0 = pReq->u.Out.pvR0;
     980            if (paPages)
     981                for (size_t iPage = 0; iPage < cPages; iPage++)
     982                {
     983                    paPages[iPage].uReserved = 0;
     984                    paPages[iPage].Phys = pReq->u.Out.aPages[iPage];
     985                    Assert(!(paPages[iPage].Phys & ~X86_PTE_PAE_PG_MASK));
     986                    Assert(paPages[iPage].Phys <= UINT32_C(0xffffff000));
     987                }
     988        }
     989        RTMemTmpFree(pReq);
     990    }
    633991    else
    634         rc = SUPPageFree(pv, cPages);
     992        rc = VERR_NO_TMP_MEMORY;
    635993
    636994    return rc;
    … …  
    638996
    639997
    640 SUPR3DECL(int) SUPLowAlloc(size_t cPages, void **ppvPages, PRTR0PTR ppvPagesR0, PSUPPAGE paPages)
     998SUPR3DECL(int) SUPLowFree(void *pv, size_t cPages)
    641999{
    6421000    /*
    6431001     * Validate.
    6441002     */
    645     AssertMsg(cPages > 0 && cPages < 256, ("cPages=%d must be > 0 and < 256\n", cPages));
    646     AssertPtr(ppvPages);
    647     *ppvPages = NULL;
    648     AssertPtr(paPages);
    649 
    650     int rc;
    651     if (!g_u32FakeMode)
    652     {
    653         /*
    654          * Issue IOCtl to the SUPDRV kernel module.
    655          */
    656         SUPLOWALLOC_IN      In;
    657         In.u32Cookie        = g_u32Cookie;
    658         In.u32SessionCookie = g_u32SessionCookie;
    659         In.cPages           = cPages;
    660         size_t              cbOut = RT_OFFSETOF(SUPLOWALLOC_OUT, aPages[cPages]);
    661         PSUPLOWALLOC_OUT    pOut = (PSUPLOWALLOC_OUT)RTMemTmpAllocZ(cbOut);
    662         if (pOut)
    663         {
    664             rc = suplibOsIOCtl(SUP_IOCTL_LOW_ALLOC, &In, sizeof(In), pOut, cbOut);
    665             if (VBOX_SUCCESS(rc))
    666             {
    667                 *ppvPages = pOut->pvR3;
    668                 if (ppvPagesR0)
    669                     *ppvPagesR0 = pOut->pvR0;
    670                 AssertCompile(sizeof(paPages[0]) == sizeof(pOut->aPages[0]));
    671                 memcpy(paPages, &pOut->aPages[0], sizeof(paPages[0]) * cPages);
    672 #ifdef VBOX_STRICT
    673                 for (unsigned i = 0; i < cPages; i++)
    674                     AssertReleaseMsg(   paPages[i].Phys <= 0xfffff000
    675                                      && !(paPages[i].Phys & PAGE_OFFSET_MASK)
    676                                      && paPages[i].Phys > 0,
    677                                      ("[%d]=%VHp\n", paPages[i].Phys));
    678 #endif
    679             }
    680             RTMemTmpFree(pOut);
    681         }
    682         else
    683             rc = VERR_NO_TMP_MEMORY;
    684     }
    685     else
    686     {
    687         rc = SUPPageAlloc(cPages, ppvPages);
    688         if (VBOX_SUCCESS(rc))
    689         {
    690             /* fake physical addresses. */
    691             RTHCPHYS    Phys = (uintptr_t)*ppvPages + PAGE_SIZE * 1024;
    692             unsigned    iPage = cPages;
    693             while (iPage-- > 0)
    694                 paPages[iPage].Phys = Phys + (iPage << PAGE_SHIFT);
    695         }
    696     }
    697 
    698     return rc;
    699 }
    700 
    701 
    702 SUPR3DECL(int) SUPLowFree(void *pv, size_t cPages)
    703 {
    704     /*
    705      * Validate.
    706      */
    707     AssertPtr(pv);
    7081003    if (!pv)
    7091004        return VINF_SUCCESS;
     1005    AssertPtrReturn(pv, VERR_INVALID_POINTER);
     1006    AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
     1007
     1008    /* fake */
     1009    if (RT_UNLIKELY(g_u32FakeMode))
     1010    {
     1011        RTMemPageFree(pv);
     1012        return VINF_SUCCESS;
     1013    }
    7101014
    7111015    /*
    7121016     * Issue IOCtl to the SUPDRV kernel module.
    7131017     */
    714     SUPLOWFREE_IN     In;
    715     In.u32Cookie        = g_u32Cookie;
    716     In.u32SessionCookie = g_u32SessionCookie;
    717     In.pvR3             = pv;
    718     int rc;
    719     if (!g_u32FakeMode)
    720         rc = suplibOsIOCtl(SUP_IOCTL_LOW_FREE, &In, sizeof(In), NULL, 0);
    721     else
    722         rc = SUPPageFree(pv, cPages);
    723 
     1018    SUPCONTFREE Req;
     1019    Req.Hdr.u32Cookie = g_u32Cookie;
     1020    Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     1021    Req.Hdr.cbIn = SUP_IOCTL_LOW_FREE_SIZE_IN;
     1022    Req.Hdr.cbOut = SUP_IOCTL_LOW_FREE_SIZE_OUT;
     1023    Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     1024    Req.Hdr.rc = VERR_INTERNAL_ERROR;
     1025    Req.u.In.pvR3 = pv;
     1026    int rc = suplibOsIOCtl(SUP_IOCTL_LOW_FREE, &Req, SUP_IOCTL_LOW_FREE_SIZE);
     1027    if (RT_SUCCESS(rc))
     1028        rc = Req.Hdr.rc;
    7241029    return rc;
    725 }
    726 
    727 SUPR3DECL(int) SUPPageAlloc(size_t cPages, void **ppvPages)
    728 {
    729     /*
    730      * Validate.
    731      */
    732     if (cPages == 0)
    733     {
    734         AssertMsgFailed(("Invalid param cPages=0, must be > 0\n"));
    735         return VERR_INVALID_PARAMETER;
    736     }
    737     AssertPtr(ppvPages);
    738     if (!ppvPages)
    739         return VERR_INVALID_PARAMETER;
    740     *ppvPages = NULL;
    741 
    742 #ifdef RT_OS_WINDOWS
    743     SUPALLOCPAGE_IN  In;
    744     SUPALLOCPAGE_OUT Out;
    745 
    746     In.u32Cookie        = g_u32Cookie;
    747     In.u32SessionCookie = g_u32SessionCookie;
    748     In.cPages           = cPages;
    749     Out.u32Cookie       = g_u32Cookie;
    750     int rc = suplibOsIOCtl(SUP_IOCTL_PAGE_ALLOC, &In, sizeof(In), &Out, sizeof(Out));
    751     if (VBOX_SUCCESS(rc))
    752         *ppvPages = Out.pvR3;
    753 
    754     return rc;
    755 #else
    756     /*
    757      * Call OS specific worker.
    758      */
    759     return suplibOsPageAlloc(cPages, ppvPages);
    760 #endif
    761 }
    762 
    763 
    764 SUPR3DECL(int) SUPPageFree(void *pvPages, size_t cPages)
    765 {
    766     /*
    767      * Validate.
    768      */
    769     AssertPtr(pvPages);
    770     if (!pvPages)
    771         return VINF_SUCCESS;
    772 
    773 #ifdef RT_OS_WINDOWS
    774     SUPFREEPAGE_IN  In;
    775 
    776     In.u32Cookie        = g_u32Cookie;
    777     In.u32SessionCookie = g_u32SessionCookie;
    778     In.pvR3             = pvPages;
    779     return suplibOsIOCtl(SUP_IOCTL_PAGE_FREE, &In, sizeof(In), NULL, 0);
    780 #else
    781     /*
    782      * Call OS specific worker.
    783      */
    784     return suplibOsPageFree(pvPages, cPages);
    785 #endif
    786 }
    787 
    788 SUPR3DECL(int) SUPPageAllocLocked(size_t cPages, void **ppvPages)
    789 {
    790     /*
    791      * Validate.
    792      */
    793     if (cPages == 0)
    794     {
    795         AssertMsgFailed(("Invalid param cPages=0, must be > 0\n"));
    796         return VERR_INVALID_PARAMETER;
    797     }
    798     AssertPtr(ppvPages);
    799     if (!ppvPages)
    800         return VERR_INVALID_PARAMETER;
    801     *ppvPages = NULL;
    802 
    803     SUPALLOCPAGE_IN  In;
    804     SUPALLOCPAGE_OUT Out;
    805 
    806     In.u32Cookie        = g_u32Cookie;
    807     In.u32SessionCookie = g_u32SessionCookie;
    808     In.cPages           = cPages;
    809     Out.u32Cookie       = g_u32Cookie;
    810     int rc = suplibOsIOCtl(SUP_IOCTL_PAGE_ALLOC, &In, sizeof(In), &Out, sizeof(Out));
    811     if (VBOX_SUCCESS(rc))
    812         *ppvPages = Out.pvR3;
    813 
    814     return rc;
    815 }
    816 
    817 SUPR3DECL(int) SUPPageFreeLocked(void *pvPages, size_t cPages)
    818 {
    819     /*
    820      * Validate.
    821      */
    822     AssertPtr(pvPages);
    823     if (!pvPages)
    824         return VINF_SUCCESS;
    825 
    826     SUPFREEPAGE_IN  In;
    827 
    828     In.u32Cookie        = g_u32Cookie;
    829     In.u32SessionCookie = g_u32SessionCookie;
    830     In.pvR3             = pvPages;
    831     return suplibOsIOCtl(SUP_IOCTL_PAGE_FREE, &In, sizeof(In), NULL, 0);
    8321030}
    8331031
    … …  
    8411039    int rc = supLoadModule(pszFilename, pszModule, ppvImageBase);
    8421040#ifndef VBOX_WITHOUT_IDT_PATCHING
    843     if (    VBOX_SUCCESS(rc)
     1041    if (    RT_SUCCESS(rc)
    8441042        &&  !strcmp(pszModule, "VMMR0.r0"))
    8451043    {
    8461044        rc = supInstallIDTE();
    847         if (VBOX_FAILURE(rc))
     1045        if (RT_FAILURE(rc))
    8481046            SUPFreeModule(*ppvImageBase);
    8491047    }
    … …  
    9531151    {
    9541152        /* UNI */
    955         SUPIDTINSTALL_IN  In;
    956         In.u32Cookie        = g_u32Cookie;
    957         In.u32SessionCookie = g_u32SessionCookie;
    958         SUPIDTINSTALL_OUT Out = {3};
    959 
    960         rc = suplibOsIOCtl(SUP_IOCTL_IDT_INSTALL, &In, sizeof(In), &Out, sizeof(Out));
    961         if (VBOX_SUCCESS(rc))
     1153        SUPIDTINSTALL Req;
     1154        Req.Hdr.u32Cookie = g_u32Cookie;
     1155        Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     1156        Req.Hdr.cbIn = SUP_IOCTL_IDT_INSTALL_SIZE_IN;
     1157        Req.Hdr.cbOut = SUP_IOCTL_IDT_INSTALL_SIZE_OUT;
     1158        Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     1159        Req.Hdr.rc = VERR_INTERNAL_ERROR;
     1160        rc = suplibOsIOCtl(SUP_IOCTL_IDT_INSTALL, &Req, SUP_IOCTL_IDT_INSTALL_SIZE);
     1161        if (RT_SUCCESS(rc))
     1162            rc = Req.Hdr.rc;
     1163        if (RT_SUCCESS(rc))
    9621164        {
    963             g_u8Interrupt = Out.u8Idt;
    964             rc = suplibGenerateCallVMMR0(Out.u8Idt);
     1165            g_u8Interrupt = Req.u.Out.u8Idt;
     1166            rc = suplibGenerateCallVMMR0(Req.u.Out.u8Idt);
    9651167        }
    9661168    }
    … …  
    9811183            /* Change CPU */
    9821184            int rc2 = RTThreadSetAffinity(u64Mask);
    983             if (VBOX_FAILURE(rc2))
     1185            if (RT_FAILURE(rc2))
    9841186            {
    9851187                u64AffMaskPatched &= ~u64Mask;
    986                 Log(("SUPLoadVMM: Failed to set affinity to cpu no. %d, rc=%Vrc.\n", i, rc2));
     1188                LogRel(("SUPLoadVMM: Failed to set affinity to cpu no. %d, rc=%Vrc.\n", i, rc2));
    9871189                continue;
    9881190            }
    9891191
    9901192            /* Patch the CPU. */
    991             SUPIDTINSTALL_IN  In;
    992             In.u32Cookie        = g_u32Cookie;
    993             In.u32SessionCookie = g_u32SessionCookie;
    994             SUPIDTINSTALL_OUT Out = {3};
    995 
    996             rc2 = suplibOsIOCtl(SUP_IOCTL_IDT_INSTALL, &In, sizeof(In), &Out, sizeof(Out));
    997             if (VBOX_SUCCESS(rc2))
     1193            SUPIDTINSTALL Req;
     1194            Req.Hdr.u32Cookie = g_u32Cookie;
     1195            Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     1196            Req.Hdr.cbIn = SUP_IOCTL_IDT_INSTALL_SIZE_IN;
     1197            Req.Hdr.cbOut = SUP_IOCTL_IDT_INSTALL_SIZE_OUT;
     1198            Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     1199            Req.Hdr.rc = VERR_INTERNAL_ERROR;
     1200            rc2 = suplibOsIOCtl(SUP_IOCTL_IDT_INSTALL, &Req, SUP_IOCTL_IDT_INSTALL_SIZE);
     1201            if (RT_SUCCESS(rc2))
     1202                rc2 = Req.Hdr.rc;
     1203            if (RT_SUCCESS(rc2))
    9981204            {
    9991205                if (!cCpusPatched)
    10001206                {
    1001                     g_u8Interrupt = Out.u8Idt;
    1002                     rc2 = suplibGenerateCallVMMR0(Out.u8Idt);
    1003                     if (VBOX_FAILURE(rc))
    1004                         rc2 = rc;
     1207                    g_u8Interrupt = Req.u.Out.u8Idt;
     1208                    rc2 = suplibGenerateCallVMMR0(Req.u.Out.u8Idt);
     1209                    if (RT_FAILURE(rc2))
     1210                    {
     1211                        LogRel(("suplibGenerateCallVMMR0 failed with rc=%Vrc.\n", i, rc2));
     1212                        rc = rc2;
     1213                    }
    10051214                }
    10061215                else
    1007                     Assert(g_u8Interrupt == Out.u8Idt);
     1216                    Assert(g_u8Interrupt == Req.u.Out.u8Idt);
    10081217                cCpusPatched++;
    10091218            }
    … …  
    10111220            {
    10121221
    1013                 Log(("SUPLoadVMM: Failed to patch cpu no. %d, rc=%Vrc.\n", i, rc2));
    1014                 if (VBOX_SUCCESS(rc))
     1222                LogRel(("SUPLoadVMM: Failed to patch cpu no. %d, rc=%Vrc.\n", i, rc2));
     1223                if (RT_SUCCESS(rc))
    10151224                    rc = rc2;
    10161225            }
    … …  
    10181227
    10191228        /* Fail if no CPUs was patched! */
    1020         if (VBOX_SUCCESS(rc) && cCpusPatched <= 0)
     1229        if (RT_SUCCESS(rc) && cCpusPatched <= 0)
    10211230            rc = VERR_GENERAL_FAILURE;
    10221231        /* Ignore failures if a CPU was patched. */
    1023         else if (VBOX_FAILURE(rc) && cCpusPatched > 0)
    1024         {
    1025             /** @todo add an eventlog/syslog line out this. */
     1232        else if (RT_FAILURE(rc) && cCpusPatched > 0)
    10261233            rc = VINF_SUCCESS;
    1027         }
    10281234
    10291235        /* Set/restore the thread affinity. */
    1030         if (VBOX_SUCCESS(rc))
     1236        if (RT_SUCCESS(rc))
    10311237        {
    10321238            rc = RTThreadSetAffinity(u64AffMaskPatched);
    … …  
    11051311
    11061312    /* iterate the function table. */
    1107     int c = g_pFunctions->cFunctions;
    1108     PSUPFUNC pFunc = &g_pFunctions->aFunctions[0];
     1313    int c = g_pFunctions->u.Out.cFunctions;
     1314    PSUPFUNC pFunc = &g_pFunctions->u.Out.aFunctions[0];
    11091315    while (c-- > 0)
    11101316    {
    … …  
    11331339     * Despair.
    11341340     */
    1135     c = g_pFunctions->cFunctions;
    1136     pFunc = &g_pFunctions->aFunctions[0];
     1341    c = g_pFunctions->u.Out.cFunctions;
     1342    pFunc = &g_pFunctions->u.Out.aFunctions[0];
    11371343    while (c-- > 0)
    11381344    {
    1139         AssertMsg2("%d: %s\n", g_pFunctions->cFunctions - c, pFunc->szName);
     1345        AssertMsg2("%d: %s\n", g_pFunctions->u.Out.cFunctions - c, pFunc->szName);
    11401346        pFunc++;
    11411347    }
    … …  
    12241430    AssertPtrReturn(pszModule, VERR_INVALID_PARAMETER);
    12251431    AssertPtrReturn(ppvImageBase, VERR_INVALID_PARAMETER);
    1226     AssertReturn(strlen(pszModule) < SIZEOFMEMB(SUPLDROPEN_IN, szName), VERR_FILENAME_TOO_LONG);
     1432    AssertReturn(strlen(pszModule) < RT_SIZEOFMEMB(SUPLDROPEN, u.In.szName), VERR_FILENAME_TOO_LONG);
    12271433
    12281434    const bool fIsVMMR0 = !strcmp(pszModule, "VMMR0.r0");
    … …  
    12341440    RTLDRMOD hLdrMod;
    12351441    int rc = RTLdrOpen(pszFilename, &hLdrMod);
    1236     if (!VBOX_SUCCESS(rc))
     1442    if (!RT_SUCCESS(rc))
    12371443        return rc;
    12381444
    … …  
    12421448    CalcArgs.cbImage = RTLdrSize(hLdrMod);
    12431449    rc = RTLdrEnumSymbols(hLdrMod, 0, NULL, 0, supLoadModuleCalcSizeCB, &CalcArgs);
    1244     if (VBOX_SUCCESS(rc))
     1450    if (RT_SUCCESS(rc))
    12451451    {
    12461452        const uint32_t  offSymTab = RT_ALIGN_32(CalcArgs.cbImage, 8);
    … …  
    12511457         * Open the R0 image.
    12521458         */
    1253         SUPLDROPEN_IN OpenIn;
    1254         OpenIn.u32Cookie        = g_u32Cookie;
    1255         OpenIn.u32SessionCookie = g_u32SessionCookie;
    1256         OpenIn.cbImage          = cbImage;
    1257         strcpy(OpenIn.szName, pszModule);
    1258         SUPLDROPEN_OUT OpenOut;
     1459        SUPLDROPEN OpenReq;
     1460        OpenReq.Hdr.u32Cookie = g_u32Cookie;
     1461        OpenReq.Hdr.u32SessionCookie = g_u32SessionCookie;
     1462        OpenReq.Hdr.cbIn = SUP_IOCTL_LDR_OPEN_SIZE_IN;
     1463        OpenReq.Hdr.cbOut = SUP_IOCTL_LDR_OPEN_SIZE_OUT;
     1464        OpenReq.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     1465        OpenReq.Hdr.rc = VERR_INTERNAL_ERROR;
     1466        OpenReq.u.In.cbImage = cbImage;
     1467        strcpy(OpenReq.u.In.szName, pszModule);
    12591468        if (!g_u32FakeMode)
    1260             rc = suplibOsIOCtl(SUP_IOCTL_LDR_OPEN, &OpenIn, sizeof(OpenIn), &OpenOut, sizeof(OpenOut));
     1469        {
     1470            rc = suplibOsIOCtl(SUP_IOCTL_LDR_OPEN, &OpenReq, SUP_IOCTL_LDR_OPEN_SIZE);
     1471            if (RT_SUCCESS(rc))
     1472                rc = OpenReq.Hdr.rc;
     1473        }
    12611474        else
    12621475        {
    1263             OpenOut.fNeedsLoading = true;
    1264             OpenOut.pvImageBase = 0xef423420;
     1476            OpenReq.u.Out.fNeedsLoading = true;
     1477            OpenReq.u.Out.pvImageBase = 0xef423420;
    12651478        }
    1266         *ppvImageBase = (void *)OpenOut.pvImageBase;
    1267         if (    VBOX_SUCCESS(rc)
    1268             &&  OpenOut.fNeedsLoading)
     1479        *ppvImageBase = (void *)OpenReq.u.Out.pvImageBase;
     1480        if (    RT_SUCCESS(rc)
     1481            &&  OpenReq.u.Out.fNeedsLoading)
    12691482        {
    12701483            /*
    … …  
    12721485             * Allocate memory for the image bits.
    12731486             */
    1274             unsigned        cbIn = RT_OFFSETOF(SUPLDRLOAD_IN, achImage[cbImage]);
    1275             PSUPLDRLOAD_IN  pIn = (PSUPLDRLOAD_IN)RTMemTmpAlloc(cbIn);
    1276             if (pIn)
     1487            PSUPLDRLOAD pLoadReq = (PSUPLDRLOAD)RTMemTmpAlloc(SUP_IOCTL_LDR_LOAD_SIZE(cbImage));
     1488            if (pLoadReq)
    12771489            {
    12781490                /*
    12791491                 * Get the image bits.
    12801492                 */
    1281                 rc = RTLdrGetBits(hLdrMod, &pIn->achImage[0], (uintptr_t)OpenOut.pvImageBase,
     1493                rc = RTLdrGetBits(hLdrMod, &pLoadReq->u.In.achImage[0], (uintptr_t)OpenReq.u.Out.pvImageBase,
    12821494                                  supLoadModuleResolveImport, (void *)pszModule);
    12831495
    1284                 if (VBOX_SUCCESS(rc))
     1496                if (RT_SUCCESS(rc))
    12851497                {
    12861498                    /*
    … …  
    12911503                    RTUINTPTR ModuleTerm = 0;
    12921504                    if (fIsVMMR0)
    1293                         rc = RTLdrGetSymbolEx(hLdrMod, &pIn->achImage[0], (uintptr_t)OpenOut.pvImageBase, "VMMR0Entry", &VMMR0Entry);
    1294                     if (VBOX_SUCCESS(rc))
     1505                        rc = RTLdrGetSymbolEx(hLdrMod, &pLoadReq->u.In.achImage[0], (uintptr_t)OpenReq.u.Out.pvImageBase, "VMMR0Entry", &VMMR0Entry);
     1506                    if (RT_SUCCESS(rc))
    12951507                    {
    1296                         int rc2 = RTLdrGetSymbolEx(hLdrMod, &pIn->achImage[0], (uintptr_t)OpenOut.pvImageBase, "ModuleInit", &ModuleInit);
    1297                         if (VBOX_FAILURE(rc2))
     1508                        int rc2 = RTLdrGetSymbolEx(hLdrMod, &pLoadReq->u.In.achImage[0], (uintptr_t)OpenReq.u.Out.pvImageBase, "ModuleInit", &ModuleInit);
     1509                        if (RT_FAILURE(rc2))
    12981510                            ModuleInit = 0;
    12991511
    1300                         rc2 = RTLdrGetSymbolEx(hLdrMod, &pIn->achImage[0], (uintptr_t)OpenOut.pvImageBase, "ModuleTerm", &ModuleTerm);
    1301                         if (VBOX_FAILURE(rc2))
     1512                        rc2 = RTLdrGetSymbolEx(hLdrMod, &pLoadReq->u.In.achImage[0], (uintptr_t)OpenReq.u.Out.pvImageBase, "ModuleTerm", &ModuleTerm);
     1513                        if (RT_FAILURE(rc2))
    13021514                            ModuleTerm = 0;
    13031515                    }
    1304                     if (VBOX_SUCCESS(rc))
     1516                    if (RT_SUCCESS(rc))
    13051517                    {
    13061518                        /*
    … …  
    13091521                        SUPLDRCREATETABSARGS CreateArgs;
    13101522                        CreateArgs.cbImage = CalcArgs.cbImage;
    1311                         CreateArgs.pSym    = (PSUPLDRSYM)&pIn->achImage[offSymTab];
    1312                         CreateArgs.pszBase =     (char *)&pIn->achImage[offStrTab];
     1523                        CreateArgs.pSym    = (PSUPLDRSYM)&pLoadReq->u.In.achImage[offSymTab];
     1524                        CreateArgs.pszBase =     (char *)&pLoadReq->u.In.achImage[offStrTab];
    13131525                        CreateArgs.psz     = CreateArgs.pszBase;
    13141526                        rc = RTLdrEnumSymbols(hLdrMod, 0, NULL, 0, supLoadModuleCreateTabsCB, &CreateArgs);
    1315                         if (VBOX_SUCCESS(rc))
     1527                        if (RT_SUCCESS(rc))
    13161528                        {
    13171529                            AssertRelease((size_t)(CreateArgs.psz - CreateArgs.pszBase) <= CalcArgs.cbStrings);
    1318                             AssertRelease((size_t)(CreateArgs.pSym - (PSUPLDRSYM)&pIn->achImage[offSymTab]) <= CalcArgs.cSymbols);
     1530                            AssertRelease((size_t)(CreateArgs.pSym - (PSUPLDRSYM)&pLoadReq->u.In.achImage[offSymTab]) <= CalcArgs.cSymbols);
    13191531
    13201532                            /*
    13211533                             * Upload the image.
    13221534                             */
    1323                             pIn->u32Cookie                  = g_u32Cookie;
    1324                             pIn->u32SessionCookie           = g_u32SessionCookie;
    1325                             pIn->pfnModuleInit              = (RTR0PTR)ModuleInit;
    1326                             pIn->pfnModuleTerm              = (RTR0PTR)ModuleTerm;
     1535                            pLoadReq->Hdr.u32Cookie = g_u32Cookie;
     1536                            pLoadReq->Hdr.u32SessionCookie = g_u32SessionCookie;
     1537                            pLoadReq->Hdr.cbIn = SUP_IOCTL_LDR_LOAD_SIZE_IN(cbImage);
     1538                            pLoadReq->Hdr.cbOut = SUP_IOCTL_LDR_LOAD_SIZE_OUT;
     1539                            pLoadReq->Hdr.fFlags = SUPREQHDR_FLAGS_MAGIC | SUPREQHDR_FLAGS_EXTRA_IN;
     1540                            pLoadReq->Hdr.rc = VERR_INTERNAL_ERROR;
     1541
     1542                            pLoadReq->u.In.pfnModuleInit              = (RTR0PTR)ModuleInit;
     1543                            pLoadReq->u.In.pfnModuleTerm              = (RTR0PTR)ModuleTerm;
    13271544                            if (fIsVMMR0)
    13281545                            {
    1329                                 pIn->eEPType                = pIn->EP_VMMR0;
    1330                                 pIn->EP.VMMR0.pvVMMR0       = OpenOut.pvImageBase;
    1331                                 pIn->EP.VMMR0.pvVMMR0Entry  = (RTR0PTR)VMMR0Entry;
     1546                                pLoadReq->u.In.eEPType                = pLoadReq->u.In.EP_VMMR0;
     1547                                pLoadReq->u.In.EP.VMMR0.pvVMMR0       = OpenReq.u.Out.pvImageBase;
     1548                                pLoadReq->u.In.EP.VMMR0.pvVMMR0Entry  = (RTR0PTR)VMMR0Entry;
    13321549                            }
    13331550                            else
    1334                                 pIn->eEPType                = pIn->EP_NOTHING;
    1335                             pIn->offStrTab                  = offStrTab;
    1336                             pIn->cbStrTab                   = (uint32_t)CalcArgs.cbStrings;
    1337                             AssertRelease(pIn->cbStrTab == CalcArgs.cbStrings);
    1338                             pIn->offSymbols                 = offSymTab;
    1339                             pIn->cSymbols                   = CalcArgs.cSymbols;
    1340                             pIn->cbImage                    = cbImage;
    1341                             pIn->pvImageBase                = OpenOut.pvImageBase;
     1551                                pLoadReq->u.In.eEPType                = pLoadReq->u.In.EP_NOTHING;
     1552                            pLoadReq->u.In.offStrTab                  = offStrTab;
     1553                            pLoadReq->u.In.cbStrTab                   = (uint32_t)CalcArgs.cbStrings;
     1554                            AssertRelease(pLoadReq->u.In.cbStrTab == CalcArgs.cbStrings);
     1555                            pLoadReq->u.In.offSymbols                 = offSymTab;
     1556                            pLoadReq->u.In.cSymbols                   = CalcArgs.cSymbols;
     1557                            pLoadReq->u.In.cbImage                    = cbImage;
     1558                            pLoadReq->u.In.pvImageBase                = OpenReq.u.Out.pvImageBase;
    13421559                            if (!g_u32FakeMode)
    1343                                 rc = suplibOsIOCtl(SUP_IOCTL_LDR_LOAD, pIn, cbIn, NULL, 0);
     1560                            {
     1561                                rc = suplibOsIOCtl(SUP_IOCTL_LDR_LOAD, pLoadReq, SUP_IOCTL_LDR_LOAD_SIZE(cbImage));
     1562                                if (RT_SUCCESS(rc))
     1563                                    rc = pLoadReq->Hdr.rc;
     1564                            }
    13441565                            else
    13451566                                rc = VINF_SUCCESS;
    1346                             if (    VBOX_SUCCESS(rc)
    1347                                 ||  rc == VERR_ALREADY_LOADED /* this is because of a competing process. */
     1567                            if (    RT_SUCCESS(rc)
     1568                                ||  rc == VERR_ALREADY_LOADED /* A competing process. */
    13481569                               )
    13491570                            {
    13501571                                if (fIsVMMR0)
    1351                                     g_pvVMMR0 = OpenOut.pvImageBase;
    1352                                 RTMemTmpFree(pIn);
     1572                                    g_pvVMMR0 = OpenReq.u.Out.pvImageBase;
     1573                                RTMemTmpFree(pLoadReq);
    13531574                                RTLdrClose(hLdrMod);
    13541575                                return VINF_SUCCESS;
    … …  
    13571578                    }
    13581579                }
    1359                 RTMemTmpFree(pIn);
     1580                RTMemTmpFree(pLoadReq);
    13601581            }
    13611582            else
    13621583            {
    1363                 AssertMsgFailed(("failed to allocated %d bytes for SUPLDRLOAD_IN structure!\n", cbIn));
     1584                AssertMsgFailed(("failed to allocated %d bytes for SUPLDRLOAD_IN structure!\n", SUP_IOCTL_LDR_LOAD_SIZE(cbImage)));
    13641585                rc = VERR_NO_TMP_MEMORY;
    13651586            }
    13661587        }
    1367         else if (VBOX_SUCCESS(rc) && fIsVMMR0)
    1368             g_pvVMMR0 = OpenOut.pvImageBase;
     1588        else if (RT_SUCCESS(rc) && fIsVMMR0)
     1589            g_pvVMMR0 = OpenReq.u.Out.pvImageBase;
    13691590    }
    13701591    RTLdrClose(hLdrMod);
    … …  
    13751596SUPR3DECL(int) SUPFreeModule(void *pvImageBase)
    13761597{
     1598    /* fake */
     1599    if (RT_UNLIKELY(g_u32FakeMode))
     1600    {
     1601#ifndef VBOX_WITHOUT_IDT_PATCHING
     1602        g_u8Interrupt = 3;
     1603        RTMemExecFree(*(void **)&g_pfnCallVMMR0);
     1604        g_pfnCallVMMR0 = NULL;
     1605#endif
     1606        g_pvVMMR0 = NIL_RTR0PTR;
     1607        return VINF_SUCCESS;
     1608    }
     1609
     1610#ifndef VBOX_WITHOUT_IDT_PATCHING
    13771611    /*
    13781612     * There is one special module. When this is freed we'll
    … …  
    13821616     *      first unload will free it.
    13831617     */
    1384     if ((RTR0PTR)pvImageBase == g_pvVMMR0)
    1385     {
    1386         /*
    1387          * This is the point where we remove the IDT hook. We do
    1388          * that before unloading the R0 VMM part.
    1389          */
    1390         if (g_u32FakeMode)
    1391         {
    1392 #ifndef VBOX_WITHOUT_IDT_PATCHING
    1393             g_u8Interrupt = 3;
    1394             RTMemExecFree(*(void **)&g_pfnCallVMMR0);
    1395             g_pfnCallVMMR0 = NULL;
    1396 #endif
    1397             g_pvVMMR0 = NIL_RTR0PTR;
    1398             return VINF_SUCCESS;
    1399         }
    1400 
    1401 #ifndef VBOX_WITHOUT_IDT_PATCHING
    1402         /*
    1403          * Uninstall IDT entry.
    1404          */
    1405         int rc = 0;
    1406         if (g_u8Interrupt != 3)
    1407         {
    1408             SUPIDTREMOVE_IN  In;
    1409             In.u32Cookie        = g_u32Cookie;
    1410             In.u32SessionCookie = g_u32SessionCookie;
    1411             rc = suplibOsIOCtl(SUP_IOCTL_IDT_REMOVE, &In, sizeof(In), NULL, 0);
    1412             g_u8Interrupt = 3;
    1413             RTMemExecFree(*(void **)&g_pfnCallVMMR0);
    1414             g_pfnCallVMMR0 = NULL;
    1415         }
    1416 #endif
    1417     }
     1618    if (    (RTR0PTR)pvImageBase == g_pvVMMR0
     1619        &&  g_u8Interrupt != 3)
     1620    {
     1621        SUPIDTREMOVE Req;
     1622        Req.Hdr.u32Cookie = g_u32Cookie;
     1623        Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     1624        Req.Hdr.cbIn = SUP_IOCTL_IDT_REMOVE_SIZE_IN;
     1625        Req.Hdr.cbOut = SUP_IOCTL_IDT_REMOVE_SIZE_OUT;
     1626        Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     1627        Req.Hdr.rc = VERR_INTERNAL_ERROR;
     1628        int rc = suplibOsIOCtl(SUP_IOCTL_IDT_REMOVE, &Req, SUP_IOCTL_IDT_REMOVE_SIZE);
     1629        if (RT_SUCCESS(rc))
     1630            rc = Req.Hdr.rc;
     1631        AssertRC(rc);
     1632        g_u8Interrupt = 3;
     1633        RTMemExecFree(*(void **)&g_pfnCallVMMR0);
     1634        g_pfnCallVMMR0 = NULL;
     1635    }
     1636#endif /* VBOX_WITHOUT_IDT_PATCHING */
    14181637
    14191638    /*
    14201639     * Free the requested module.
    14211640     */
    1422     SUPLDRFREE_IN In;
    1423     In.u32Cookie        = g_u32Cookie;
    1424     In.u32SessionCookie = g_u32SessionCookie;
    1425     In.pvImageBase      = (RTR0PTR)pvImageBase;
    1426     int rc = VINF_SUCCESS;
    1427     if (!g_u32FakeMode)
    1428         rc = suplibOsIOCtl(SUP_IOCTL_LDR_FREE, &In, sizeof(In), NULL, 0);
    1429     if (    VBOX_SUCCESS(rc)
     1641    SUPLDRFREE Req;
     1642    Req.Hdr.u32Cookie = g_u32Cookie;
     1643    Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     1644    Req.Hdr.cbIn = SUP_IOCTL_LDR_FREE_SIZE_IN;
     1645    Req.Hdr.cbOut = SUP_IOCTL_LDR_FREE_SIZE_OUT;
     1646    Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     1647    Req.Hdr.rc = VERR_INTERNAL_ERROR;
     1648    Req.u.In.pvImageBase = (RTR0PTR)pvImageBase;
     1649    int rc = suplibOsIOCtl(SUP_IOCTL_LDR_FREE, &Req, SUP_IOCTL_LDR_FREE_SIZE);
     1650    if (RT_SUCCESS(rc))
     1651        rc = Req.Hdr.rc;
     1652    if (    RT_SUCCESS(rc)
    14301653        &&  (RTR0PTR)pvImageBase == g_pvVMMR0)
    14311654        g_pvVMMR0 = NIL_RTR0PTR;
    … …  
    14381661    *ppvValue = NULL;
    14391662
     1663    /* fake */
     1664    if (RT_UNLIKELY(g_u32FakeMode))
     1665    {
     1666        *ppvValue = (void *)(uintptr_t)0xdeadf00d;
     1667        return VINF_SUCCESS;
     1668    }
     1669
    14401670    /*
    14411671     * Do ioctl.
    14421672     */
    1443     size_t              cchSymbol = strlen(pszSymbol);
    1444     const size_t        cbIn = RT_OFFSETOF(SUPLDRGETSYMBOL_IN, szSymbol[cchSymbol + 1]);
    1445     SUPLDRGETSYMBOL_OUT Out = { NIL_RTR0PTR };
    1446     PSUPLDRGETSYMBOL_IN pIn = (PSUPLDRGETSYMBOL_IN)alloca(cbIn);
    1447     pIn->u32Cookie        = g_u32Cookie;
    1448     pIn->u32SessionCookie = g_u32SessionCookie;
    1449     pIn->pvImageBase      = (RTR0PTR)pvImageBase;
    1450     memcpy(pIn->szSymbol, pszSymbol, cchSymbol + 1);
    1451     int rc;
    1452     if (RT_LIKELY(!g_u32FakeMode))
    1453         rc = suplibOsIOCtl(SUP_IOCTL_LDR_GET_SYMBOL, pIn, cbIn, &Out, sizeof(Out));
    1454     else
    1455     {
    1456         rc = VINF_SUCCESS;
    1457         Out.pvSymbol = 0xdeadf00d;
    1458     }
    1459     if (VBOX_SUCCESS(rc))
    1460         *ppvValue = (void *)Out.pvSymbol;
     1673    SUPLDRGETSYMBOL Req;
     1674    Req.Hdr.u32Cookie = g_u32Cookie;
     1675    Req.Hdr.u32SessionCookie = g_u32SessionCookie;
     1676    Req.Hdr.cbIn = SUP_IOCTL_LDR_GET_SYMBOL_SIZE_IN;
     1677    Req.Hdr.cbOut = SUP_IOCTL_LDR_GET_SYMBOL_SIZE_OUT;
     1678    Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
     1679    Req.Hdr.rc = VERR_INTERNAL_ERROR;
     1680    Req.u.In.pvImageBase = (RTR0PTR)pvImageBase;
     1681    size_t cchSymbol = strlen(pszSymbol);
     1682    if (cchSymbol >= sizeof(Req.u.In.szSymbol))
     1683        return VERR_SYMBOL_NOT_FOUND;
     1684    memcpy(Req.u.In.szSymbol, pszSymbol, cchSymbol + 1);
     1685    int rc = suplibOsIOCtl(SUP_IOCTL_LDR_GET_SYMBOL, &Req, SUP_IOCTL_LDR_GET_SYMBOL_SIZE);
     1686    if (RT_SUCCESS(rc))
     1687        rc = Req.Hdr.rc;
     1688    if (RT_SUCCESS(rc))
     1689        *ppvValue = (void *)Req.u.Out.pvSymbol;
    14611690    return rc;
    14621691}

  • trunk/src/VBox/HostDrivers/Support/SUPLibInternal.h

    r4071 r4800  
    4444int     suplibOsInit(size_t cbReserve);
    4545int     suplibOsTerm(void);
    46 int     suplibOsIOCtl(unsigned uFunction, void *pvIn, size_t cbIn, void *pvOut, size_t cbOut);
     46int     suplibOsIOCtl(uintptr_t uFunction, void *pvReq, size_t cbReq);
    4747#ifdef VBOX_WITHOUT_IDT_PATCHING
    48 int     suplibOSIOCtlFast(unsigned uFunction);
     48int     suplibOSIOCtlFast(uintptr_t uFunction);
    4949#endif
    5050int     suplibOsPageAlloc(size_t cPages, void **ppvPages);

  • trunk/src/VBox/HostDrivers/Support/darwin/SUPDrv-darwin.cpp

    r4071 r4800  
    271271    g_iMajorDeviceNo = -1;
    272272
    273     rc = supdrvDeleteDevExt(&g_DevExt);
    274     AssertRC(rc);
     273    supdrvDeleteDevExt(&g_DevExt);
    275274
    276275    rc = RTSpinlockDestroy(g_Spinlock);
    … …  
    385384    if (!pSession)
    386385    {
    387         OSDBGPRINT(("VBoxSupDrvClose: WHAT?!? pSession == NULL! This must be a mistake... pid=%d (close)\n", 
     386        OSDBGPRINT(("VBoxSupDrvClose: WHAT?!? pSession == NULL! This must be a mistake... pid=%d (close)\n",
    388387                    (int)Process));
    389388        return EINVAL;
    … …  
    428427    if (!pSession)
    429428    {
    430         OSDBGPRINT(("VBoxSupDrvIOCtl: WHAT?!? pSession == NULL! This must be a mistake... pid=%d iCmd=%#x\n", 
     429        OSDBGPRINT(("VBoxSupDrvIOCtl: WHAT?!? pSession == NULL! This must be a mistake... pid=%d iCmd=%#x\n",
    431430                    (int)Process, iCmd));
    432431        return EINVAL;

  • trunk/src/VBox/HostDrivers/Support/darwin/SUPLib-darwin.cpp

    r4071 r4800  
    171171
    172172
    173 /**
    174  * Installs anything required by the support library.
    175  *
    176  * @returns 0 on success.
    177  * @returns error code on failure.
    178  */
    179173int suplibOsInstall(void)
    180174{
    181 //    int rc = mknod(DEVICE_NAME, S_IFCHR, );
    182 
    183175    return VERR_NOT_IMPLEMENTED;
    184176}
    185177
    186178
    187 /**
    188  * Installs anything required by the support library.
    189  *
    190  * @returns 0 on success.
    191  * @returns error code on failure.
    192  */
    193179int suplibOsUninstall(void)
    194180{
    195 //    int rc = unlink(DEVICE_NAME);
    196 
    197181    return VERR_NOT_IMPLEMENTED;
    198182}
    199183
    200184
    201 /**
    202  * Send a I/O Control request to the device.
    203  *
    204  * @returns 0 on success.
    205  * @returns VBOX error code on failure.
    206  * @param   uFunction   IO Control function.
    207  * @param   pvIn        Input data buffer.
    208  * @param   cbIn        Size of input data.
    209  * @param   pvOut       Output data buffer.
    210  * @param   cbOut       Size of output data.
    211  */
    212 int suplibOsIOCtl(unsigned uFunction, void *pvIn, size_t cbIn, void *pvOut, size_t cbOut)
     185int suplibOsIOCtl(uintptr_t uFunction, void *pvReq, size_t cbReq)
    213186{
    214187    AssertMsg(g_hDevice != -1, ("SUPLIB not initiated successfully!\n"));
    215     /*
    216      * Issue device iocontrol.
    217      */
    218     SUPDRVIOCTLDATA Args;
    219     Args.pvIn = pvIn;
    220     Args.cbIn = cbIn;
    221     Args.pvOut = pvOut;
    222     Args.cbOut = cbOut;
    223 
    224     if (ioctl(g_hDevice, uFunction, &Args) >= 0)
    225         return 0;
    226     /* This is the reverse operation of the one found in SUPDrv-linux.c */
    227     switch (errno)
    228     {
    229         case EACCES: return VERR_GENERAL_FAILURE;
    230         case EINVAL: return VERR_INVALID_PARAMETER;
    231         case ENOSYS: return VERR_INVALID_MAGIC;
    232         case ENXIO:  return VERR_INVALID_HANDLE;
    233         case EFAULT: return VERR_INVALID_POINTER;
    234         case ENOLCK: return VERR_LOCK_FAILED;
    235         case EEXIST: return VERR_ALREADY_LOADED;
    236     }
    237 
     188
     189    if (RT_LIKELY(ioctl(g_hDevice, uFunction, pvReq) >= 0))
     190        return VINF_SUCCESS;
    238191    return RTErrConvertFromErrno(errno);
    239192}
    240193
    241194#ifdef VBOX_WITHOUT_IDT_PATCHING
    242 int suplibOSIOCtlFast(unsigned uFunction)
     195int suplibOSIOCtlFast(uintptr_t uFunction)
    243196{
    244197    int rc = ioctl(g_hDevice, uFunction, NULL);
    … …  
    250203
    251204
    252 /**
    253  * Allocate a number of zero-filled pages in user space.
    254  *
    255  * @returns VBox status code.
    256  * @param   cPages      Number of pages to allocate.
    257  * @param   ppvPages    Where to return the base pointer.
    258  */
    259205int suplibOsPageAlloc(size_t cPages, void **ppvPages)
    260206{
    … …  
    269215
    270216
    271 /**
    272  * Frees pages allocated by suplibOsPageAlloc().
    273  *
    274  * @returns VBox status code.
    275  * @param   pvPages     Pointer to pages.
    276  */
    277217int suplibOsPageFree(void *pvPages, size_t /* cPages */)
    278218{

  • trunk/src/VBox/HostDrivers/Support/freebsd/SUPDrv-freebsd.c

    r4016 r4800  
    217217    }
    218218
    219     rc = supdrvDeleteDevExt(&g_DevExt);
    220     AssertRC(rc);
     219    supdrvDeleteDevExt(&g_DevExt);
    221220
    222221    rc = RTSpinlockDestroy(g_Spinlock);
    … …  
    306305    cch = RTStrPrintfV(szMsg, sizeof(szMsg), pszFormat, va);
    307306    va_end(va);
    308    
     307
    309308    printf("%s", szMsg);
    310309

  • trunk/src/VBox/HostDrivers/Support/freebsd/SUPLib-freebsd.cpp

    r4071 r4800  
    9696
    9797
    98 /**
    99  * Installs anything required by the support library.
    100  *
    101  * @returns 0 on success.
    102  * @returns error code on failure.
    103  */
    10498int suplibOsInstall(void)
    10599{
    106 //    int rc = mknod(DEVICE_NAME, S_IFCHR, );
    107 
    108100    return VERR_NOT_IMPLEMENTED;
    109101}
    110102
    111103
    112 /**
    113  * Installs anything required by the support library.
    114  *
    115  * @returns 0 on success.
    116  * @returns error code on failure.
    117  */
    118104int suplibOsUninstall(void)
    119105{
    120 //    int rc = unlink(DEVICE_NAME);
    121 
    122106    return VERR_NOT_IMPLEMENTED;
    123107}
    124108
    125109
    126 /**
    127  * Send a I/O Control request to the device.
    128  *
    129  * @returns 0 on success.
    130  * @returns VBOX error code on failure.
    131  * @param   uFunction   IO Control function.
    132  * @param   pvIn        Input data buffer.
    133  * @param   cbIn        Size of input data.
    134  * @param   pvOut       Output data buffer.
    135  * @param   cbOut       Size of output data.
    136  */
    137 int suplibOsIOCtl(unsigned uFunction, void *pvIn, size_t cbIn, void *pvOut, size_t cbOut)
     110int suplibOsIOCtl(uintptr_t uFunction, void *pvReq, size_t cbReq)
    138111{
    139112    AssertMsg(g_hDevice != -1, ("SUPLIB not initiated successfully!\n"));
    140     /*
    141      * Issue device iocontrol.
    142      */
    143     SUPDRVIOCTLDATA Args;
    144     Args.pvIn = pvIn;
    145     Args.cbIn = cbIn;
    146     Args.pvOut = pvOut;
    147     Args.cbOut = cbOut;
    148113
    149     if (ioctl(g_hDevice, uFunction, &Args) >= 0)
    150         return 0;
    151     /* This is the reverse operation of the one found in SUPDrv-linux.c */
    152     switch (errno)
    153     {
    154         case EACCES: return VERR_GENERAL_FAILURE;
    155         case EINVAL: return VERR_INVALID_PARAMETER;
    156         case ENOSYS: return VERR_INVALID_MAGIC;
    157         case ENXIO:  return VERR_INVALID_HANDLE;
    158         case EFAULT: return VERR_INVALID_POINTER;
    159         case ENOLCK: return VERR_LOCK_FAILED;
    160         case EEXIST: return VERR_ALREADY_LOADED;
    161     }
    162 
     114    if (RT_LIKELY(ioctl((g_hDevice, uFunction, pvReq) >= 0))
     115        return VINF_SUCCESS;
    163116    return RTErrConvertFromErrno(errno);
    164117}
    165118
    166119#ifdef VBOX_WITHOUT_IDT_PATCHING
    167 int suplibOSIOCtlFast(unsigned uFunction)
     120int suplibOSIOCtlFast(uintptr_t uFunction)
    168121{
    169122    int rc = ioctl(g_hDevice, uFunction, NULL);
    … …  
    175128
    176129
    177 /**
    178  * Allocate a number of zero-filled pages in user space.
    179  *
    180  * @returns VBox status code.
    181  * @param   cPages      Number of pages to allocate.
    182  * @param   ppvPages    Where to return the base pointer.
    183  */
    184130int suplibOsPageAlloc(size_t cPages, void **ppvPages)
    185131{
    … …  
    191137
    192138
    193 /**
    194  * Frees pages allocated by suplibOsPageAlloc().
    195  *
    196  * @returns VBox status code.
    197  * @param   pvPages     Pointer to pages.
    198  */
    199139int suplibOsPageFree(void *pvPages, size_t /* cPages */)
    200140{

  • trunk/src/VBox/HostDrivers/Support/linux/SUPDrv-linux.c

    r4791 r4800  
    6666#endif
    6767
     68#include <iprt/mem.h>
     69
     70
    6871/* devfs defines */
    6972#if defined(CONFIG_DEVFS_FS) && !defined(CONFIG_VBOXDRV_AS_MISC)
    … …  
    236239 * Device extention & session data association structure.
    237240 */
    238 static SUPDRVDEVEXT     g_DevExt;
     241static SUPDRVDEVEXT         g_DevExt;
    239242
    240243/** Timer structure for the GIP update. */
    241 static struct timer_list g_GipTimer;
     244static struct timer_list    g_GipTimer;
    242245/** Pointer to the page structure for the GIP. */
    243 struct page            *g_pGipPage;
     246struct page                *g_pGipPage;
    244247
    245248/** Registered devfs device handle. */
    246249#if defined(CONFIG_DEVFS_FS) && !defined(CONFIG_VBOXDRV_AS_MISC)
    247250# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
    248 static void            *g_hDevFsVBoxDrv = NULL;
     251static void                *g_hDevFsVBoxDrv = NULL;
    249252# else
    250 static devfs_handle_t   g_hDevFsVBoxDrv = NULL;
     253static devfs_handle_t       g_hDevFsVBoxDrv = NULL;
    251254# endif
    252255#endif
    … …  
    254257#ifndef CONFIG_VBOXDRV_AS_MISC
    255258/** Module major number */
    256 #define DEVICE_MAJOR   234
     259#define DEVICE_MAJOR        234
    257260/** Saved major device number */
    258 static int              g_iModuleMajor;
     261static int                  g_iModuleMajor;
    259262#endif /* !CONFIG_VBOXDRV_AS_MISC */
    260263
    261264/** The module name. */
    262 #define DEVICE_NAME    "vboxdrv"
     265#define DEVICE_NAME         "vboxdrv"
    263266
    264267#ifdef RT_ARCH_AMD64
    … …  
    281284*   Internal Functions                                                         *
    282285*******************************************************************************/
    283 static int      VBoxSupDrvInit(void);
    284 static void     VBoxSupDrvUnload(void);
    285 static int      VBoxSupDrvCreate(struct inode *pInode, struct file *pFilp);
    286 static int      VBoxSupDrvClose(struct inode *pInode, struct file *pFilp);
    287 static int      VBoxSupDrvDeviceControl(struct inode *pInode, struct file *pFilp,
    288                                         unsigned int IOCmd, unsigned long IOArg);
     286static int      VBoxDrvLinuxInit(void);
     287static void     VBoxDrvLinuxUnload(void);
     288static int      VBoxDrvLinuxCreate(struct inode *pInode, struct file *pFilp);
     289static int      VBoxDrvLinuxClose(struct inode *pInode, struct file *pFilp);
     290static int      VBoxDrvLinuxIOCtl(struct inode *pInode, struct file *pFilp, unsigned int uCmd, unsigned long ulArg);
     291static int      VBoxDrvLinuxIOCtlSlow(struct inode *pInode, struct file *pFilp, unsigned int uCmd, unsigned long ulArg);
    289292#ifndef USE_NEW_OS_INTERFACE_FOR_MM
    290 static RTR3PTR  VBoxSupDrvMapUser(struct page **papPages, unsigned cPages, unsigned fProt, pgprot_t pgFlags);
     293static RTR3PTR  VBoxDrvLinuxMapUser(struct page **papPages, unsigned cPages, unsigned fProt, pgprot_t pgFlags);
    291294#endif /* !USE_NEW_OS_INTERFACE_FOR_MM */
    292 static int      VBoxSupDrvInitGip(PSUPDRVDEVEXT pDevExt);
    293 static int      VBoxSupDrvTermGip(PSUPDRVDEVEXT pDevExt);
    294 static void     VBoxSupGipTimer(unsigned long ulUser);
     295static int      VBoxDrvLinuxInitGip(PSUPDRVDEVEXT pDevExt);
     296static int      VBoxDrvLinuxTermGip(PSUPDRVDEVEXT pDevExt);
     297static void     VBoxDrvLinuxGipTimer(unsigned long ulUser);
    295298#ifdef CONFIG_SMP
    296 static void     VBoxSupGipTimerPerCpu(unsigned long ulUser);
    297 static void     VBoxSupGipResumePerCpu(void *pvUser);
    298 #endif
    299 static int      VBoxSupDrvErr2LinuxErr(int);
     299static void     VBoxDrvLinuxGipTimerPerCpu(unsigned long ulUser);
     300static void     VBoxDrvLinuxGipResumePerCpu(void *pvUser);
     301#endif
     302static int      VBoxDrvLinuxErr2LinuxErr(int);
    300303
    301304
    … …  
    304307{
    305308    owner:      THIS_MODULE,
    306     open:       VBoxSupDrvCreate,
    307     release:    VBoxSupDrvClose,
    308     ioctl:      VBoxSupDrvDeviceControl,
     309    open:       VBoxDrvLinuxCreate,
     310    release:    VBoxDrvLinuxClose,
     311    ioctl:      VBoxDrvLinuxIOCtl,
    309312};
    310313
    … …  
    433436 * @returns appropriate status code.
    434437 */
    435 static int __init VBoxSupDrvInit(void)
     438static int __init VBoxDrvLinuxInit(void)
    436439{
    437440    int                 rc;
    … …  
    617620                 * Create the GIP page.
    618621                 */
    619                 rc = VBoxSupDrvInitGip(&g_DevExt);
     622                rc = VBoxDrvLinuxInitGip(&g_DevExt);
    620623                if (!rc)
    621624                {
    … …  
    654657 * Unload the module.
    655658 */
    656 static void __exit VBoxSupDrvUnload(void)
     659static void __exit VBoxDrvLinuxUnload(void)
    657660{
    658661    int                 rc;
    659     dprintf(("VBoxSupDrvUnload\n"));
     662    dprintf(("VBoxDrvLinuxUnload\n"));
    660663
    661664    /*
    … …  
    686689     * Destroy GIP, delete the device extension and terminate IPRT.
    687690     */
    688     VBoxSupDrvTermGip(&g_DevExt);
     691    VBoxDrvLinuxTermGip(&g_DevExt);
    689692    supdrvDeleteDevExt(&g_DevExt);
    690693    RTR0Term();
    … …  
    698701 * @param   pFilp       Associated file pointer.
    699702 */
    700 static int VBoxSupDrvCreate(struct inode *pInode, struct file *pFilp)
     703static int VBoxDrvLinuxCreate(struct inode *pInode, struct file *pFilp)
    701704{
    702705    int                 rc;
    703706    PSUPDRVSESSION      pSession;
    704     dprintf(("VBoxSupDrvCreate: pFilp=%p\n", pFilp));
     707    dprintf(("VBoxDrvLinuxCreate: pFilp=%p\n", pFilp));
    705708
    706709    /*
    … …  
    716719    }
    717720
    718     dprintf(("VBoxSupDrvCreate: g_DevExt=%p pSession=%p rc=%d\n", &g_DevExt, pSession, rc));
     721    dprintf(("VBoxDrvLinuxCreate: g_DevExt=%p pSession=%p rc=%d\n", &g_DevExt, pSession, rc));
    719722    pFilp->private_data = pSession;
    720723
    721     return VBoxSupDrvErr2LinuxErr(rc);
     724    return VBoxDrvLinuxErr2LinuxErr(rc);
    722725}
    723726
    … …  
    729732 * @param   pFilp       Associated file pointer.
    730733 */
    731 static int VBoxSupDrvClose(struct inode *pInode, struct file *pFilp)
    732 {
    733     dprintf(("VBoxSupDrvClose: pFilp=%p private_data=%p\n", pFilp, pFilp->private_data));
     734static int VBoxDrvLinuxClose(struct inode *pInode, struct file *pFilp)
     735{
     736    dprintf(("VBoxDrvLinuxClose: pFilp=%p private_data=%p\n", pFilp, pFilp->private_data));
    734737    supdrvCloseSession(&g_DevExt, (PSUPDRVSESSION)pFilp->private_data);
    735738    pFilp->private_data = NULL;
    … …  
    743746 * @param   pInode      Pointer to inode info structure.
    744747 * @param   pFilp       Associated file pointer.
    745  * @param   IOCmd       The function specified to ioctl().
    746  * @param   IOArg       The argument specified to ioctl().
    747  */
    748 static int VBoxSupDrvDeviceControl(struct inode *pInode, struct file *pFilp,
    749                                    unsigned int IOCmd, unsigned long IOArg)
     748 * @param   uCmd        The function specified to ioctl().
     749 * @param   ulArg       The argument specified to ioctl().
     750 */
     751static int VBoxDrvLinuxIOCtl(struct inode *pInode, struct file *pFilp, unsigned int uCmd, unsigned long ulArg)
     752{
     753#ifdef VBOX_WITHOUT_IDT_PATCHING
     754    /*
     755     * Deal with the two high-speed IOCtl that takes it's arguments from
     756     * the session and iCmd, and only returns a VBox status code.
     757     */
     758    if (RT_LIKELY(   uCmd == SUP_IOCTL_FAST_DO_RAW_RUN
     759                  || uCmd == SUP_IOCTL_FAST_DO_HWACC_RUN
     760                  || uCmd == SUP_IOCTL_FAST_DO_NOP))
     761        return supdrvIOCtlFast(iCmd, &g_DevExt, (PSUPDRVSESSION)pFilp->private_data);
     762#endif
     763    return VBoxDrvLinuxIOCtlSlow(pInode, pFilp, uCmd, ulArg);
     764}
     765
     766
     767/**
     768 * Device I/O Control entry point.
     769 *
     770 * @param   pInode      Pointer to inode info structure.
     771 * @param   pFilp       Associated file pointer.
     772 * @param   uCmd        The function specified to ioctl().
     773 * @param   ulArg       The argument specified to ioctl().
     774 */
     775static int VBoxDrvLinuxIOCtlSlow(struct inode *pInode, struct file *pFilp, unsigned int uCmd, unsigned long ulArg)
    750776{
    751777    int                 rc;
    752     SUPDRVIOCTLDATA     Args;
    753     void               *pvBuf = NULL;
    754     int                 cbBuf = 0;
    755     unsigned            cbOut = 0;
    756 
    757     dprintf2(("VBoxSupDrvDeviceControl: pFilp=%p IOCmd=%x IOArg=%p\n", pFilp, IOCmd, (void *)IOArg));
    758 
    759     /*
    760      * Copy ioctl data structure from user space.
    761      */
    762     if (_IOC_SIZE(IOCmd) != sizeof(SUPDRVIOCTLDATA))
    763     {
    764         dprintf(("VBoxSupDrvDeviceControl: incorrect input length! cbArgs=%d\n", _IOC_SIZE(IOCmd)));
     778    SUPREQHDR           Hdr;
     779    PSUPREQHDR          pHdr;
     780    uint32_t            cbBuf;
     781
     782    dprintf2(("VBoxDrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p\n", pFilp, uCmd, (void *)ulArg));
     783
     784    /*
     785     * Read the header.
     786     */
     787    if (RT_UNLIKELY(copy_from_user(&Hdr, (void *)ulArg, sizeof(Hdr))))
     788    {
     789        dprintf(("VBoxDrvLinuxIOCtl: copy_from_user(,%#lx,) failed; uCmd=%#x.\n", ulArg, uCmd));
     790        return -EFAULT;
     791    }
     792    if (RT_UNLIKELY((Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC))
     793    {
     794        dprintf(("VBoxDrvLinuxIOCtl: bad header magic %#x; uCmd=%#x\n", Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK, uCmd));
    765795        return -EINVAL;
    766796    }
    767     if (copy_from_user(&Args, (void *)IOArg, _IOC_SIZE(IOCmd)))
    768     {
    769         dprintf(("VBoxSupDrvDeviceControl: copy_from_user(&Args) failed.\n"));
     797
     798    /*
     799     * Buffer the request.
     800     */
     801    cbBuf = RT_MAX(Hdr.cbIn, Hdr.cbOut);
     802    if (RT_UNLIKELY(cbBuf > _1M*16))
     803    {
     804        dprintf(("VBoxDrvLinuxIOCtl: too big cbBuf=%#x; uCmd=%#x\n", cbBuf, uCmd));
     805        return -E2BIG;
     806    }
     807    if (RT_UNLIKELY(cbBuf != _IOC_SIZE(uCmd) && _IOC_SIZE(uCmd)))
     808    {
     809        dprintf(("VBoxDrvLinuxIOCtl: bad ioctl cbBuf=%#x _IOC_SIZE=%#x; uCmd=%#x.\n", cbBuf, _IOC_SIZE(uCmd), uCmd));
     810        return -EINVAL;
     811    }
     812    pHdr = RTMemAlloc(cbBuf);
     813    if (RT_UNLIKELY(!pHdr))
     814    {
     815        OSDBGPRINT(("VBoxDrvLinuxIOCtl: failed to allocate buffer of %d bytes for uCmd=%#x.\n", cbBuf, uCmd));
     816        return -ENOMEM;
     817    }
     818    if (RT_UNLIKELY(copy_from_user(pHdr, (void *)ulArg, Hdr.cbIn)))
     819    {
     820        dprintf(("VBoxDrvLinuxIOCtl: copy_from_user(,%#lx, %#x) failed; uCmd=%#x.\n", ulArg, Hdr.cbIn, uCmd));
     821        RTMemFree(pHdr);
    770822        return -EFAULT;
    771823    }
    772824
    773825    /*
    774      * Allocate and copy user space input data buffer to kernel space.
    775      */
    776     if (Args.cbIn > 0 || Args.cbOut > 0)
    777     {
    778         cbBuf = max(Args.cbIn, Args.cbOut);
    779         pvBuf = vmalloc(cbBuf);
    780         if (pvBuf == NULL)
     826     * Process the IOCtl.
     827     */
     828    rc = supdrvIOCtl(uCmd, &g_DevExt, (PSUPDRVSESSION)pFilp->private_data, pHdr);
     829
     830    /*
     831     * Copy ioctl data and output buffer back to user space.
     832     */
     833    if (RT_LIKELY(!rc))
     834    {
     835        uint32_t cbOut = pHdr->cbOut;
     836        if (RT_UNLIKELY(cbOut > cbBuf))
    781837        {
    782             dprintf(("VBoxSupDrvDeviceControl: failed to allocate buffer of %d bytes.\n", cbBuf));
    783             return -ENOMEM;
     838            OSDBGPRINT(("VBoxDrvLinuxIOCtl: too much output! %#x > %#x; uCmd=%#x!\n", cbOut, cbBuf, uCmd));
     839            cbOut = cbBuf;
    784840        }
    785 
    786         if (copy_from_user(pvBuf, (void *)Args.pvIn, Args.cbIn))
     841        if (RT_UNLIKELY(copy_to_user((void *)ulArg, pHdr, cbOut)))
    787842        {
    788             dprintf(("VBoxSupDrvDeviceControl: copy_from_user(pvBuf) failed.\n"));
    789             vfree(pvBuf);
    790             return -EFAULT;
     843            /* this is really bad! */
     844            OSDBGPRINT(("VBoxDrvLinuxIOCtl: copy_to_user(%#lx,,%#x); uCmd=%#x!\n", ulArg, cbOut, uCmd));
     845            rc = -EFAULT;
    791846        }
    792847    }
    793 
    794     /*
    795      * Process the IOCtl.
    796      */
    797     rc = supdrvIOCtl(IOCmd, &g_DevExt, (PSUPDRVSESSION)pFilp->private_data,
    798                      pvBuf, Args.cbIn, pvBuf, Args.cbOut, &cbOut);
    799 
    800     /*
    801      * Copy ioctl data and output buffer back to user space.
    802      */
    803     if (rc)
    804     {
    805         dprintf(("VBoxSupDrvDeviceControl: pFilp=%p IOCmd=%x IOArg=%p failed, rc=%d (linux rc=%d)\n",
    806                  pFilp, IOCmd, (void *)IOArg, rc, VBoxSupDrvErr2LinuxErr(rc)));
    807         rc = VBoxSupDrvErr2LinuxErr(rc);
    808     }
    809     else if (cbOut > 0)
    810     {
    811         if (pvBuf != NULL && cbOut <= cbBuf)
    812         {
    813             if (copy_to_user((void *)Args.pvOut, pvBuf, cbOut))
    814             {
    815                 dprintf(("copy_to_user failed.\n"));
    816                 rc = -EFAULT;
    817             }
    818         }
    819         else
    820         {
    821             dprintf(("WHAT!?! supdrvIOCtl messed up! cbOut=%d cbBuf=%d pvBuf=%p\n", cbOut, cbBuf, pvBuf));
    822             rc = -EPERM;
    823         }
    824     }
    825 
    826     if (pvBuf)
    827         vfree(pvBuf);
    828 
    829     dprintf2(("VBoxSupDrvDeviceControl: returns %d\n", rc));
     848    else
     849    {
     850        dprintf(("VBoxDrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p failed, rc=%d\n", pFilp, uCmd, (void *)ulArg, rc));
     851        rc = -EINVAL;
     852    }
     853    RTMemFree(pHdr);
     854
     855    dprintf2(("VBoxDrvLinuxIOCtl: returns %d\n", rc));
    830856    return rc;
    831857}
    … …  
    871897 * @param   cPages      Number of pages.
    872898 */
    873 static int VBoxSupDrvOrder(unsigned long cPages)
     899static int VBoxDrvOrder(unsigned long cPages)
    874900{
    875901    int             iOrder;
    … …  
    10101036    unsigned    cbAligned = RT_ALIGN(pMem->cb, PAGE_SIZE);
    10111037    unsigned    cPages = cbAligned >> PAGE_SHIFT;
    1012     unsigned    cOrder = VBoxSupDrvOrder(cPages);
     1038    unsigned    cOrder = VBoxDrvOrder(cPages);
    10131039    unsigned long ulAddr;
    10141040    dma_addr_t  HCPhys;
    … …  
    11601186            MY_CHANGE_PAGE_ATTR(&pMem->u.cont.paPages[iPage], 1, PAGE_KERNEL);
    11611187    }
    1162     __free_pages(pMem->u.cont.paPages, VBoxSupDrvOrder(pMem->u.cont.cPages));
     1188    __free_pages(pMem->u.cont.paPages, VBoxDrvOrder(pMem->u.cont.cPages));
    11631189
    11641190    pMem->u.cont.cPages = 0;
    … …  
    11821208    const unsigned  cPages = cbAligned >> PAGE_SHIFT;
    11831209#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 22)
    1184     unsigned        cOrder = VBoxSupDrvOrder(cPages);
     1210    unsigned        cOrder = VBoxDrvOrder(cPages);
    11851211    struct page    *paPages;
    11861212#endif
    … …  
    12581284         */
    12591285        if (ppvR3)
    1260             *ppvR3 = pMem->pvR3 = VBoxSupDrvMapUser(papPages, cPages, PROT_READ | PROT_WRITE | PROT_EXEC, pgFlags);
     1286            *ppvR3 = pMem->pvR3 = VBoxDrvLinuxMapUser(papPages, cPages, PROT_READ | PROT_WRITE | PROT_EXEC, pgFlags);
    12611287        if (pMem->pvR3 || !ppvR3)
    12621288            return 0;
    … …  
    13471373#else
    13481374        if (cPages > 0)
    1349             __free_pages(papPages[0], VBoxSupDrvOrder(cPages));
     1375            __free_pages(papPages[0], VBoxDrvOrder(cPages));
    13501376#endif
    13511377        /* Free the page pointer array. */
    … …  
    13671393 * @param   pgFlags     The page level protection.
    13681394 */
    1369 static RTR3PTR VBoxSupDrvMapUser(struct page **papPages, unsigned cPages, unsigned fProt, pgprot_t pgFlags)
     1395static RTR3PTR VBoxDrvLinuxMapUser(struct page **papPages, unsigned cPages, unsigned fProt, pgprot_t pgFlags)
    13701396{
    13711397    int             rc = SUPDRV_ERR_NO_MEMORY;
    … …  
    14161442        /* no, cleanup! */
    14171443        if (rc)
    1418             dprintf(("VBoxSupDrvMapUser: remap_[page|pfn]_range failed! rc=%d\n", rc));
     1444            dprintf(("VBoxDrvLinuxMapUser: remap_[page|pfn]_range failed! rc=%d\n", rc));
    14191445        else
    1420             dprintf(("VBoxSupDrvMapUser: find_vma failed!\n"));
     1446            dprintf(("VBoxDrvLinuxMapUser: find_vma failed!\n"));
    14211447
    14221448        MY_DO_MUNMAP(current->mm, ulAddr, cPages << PAGE_SHIFT);
    … …  
    14411467 * @param   pDevExt     Instance data. GIP stuff may be updated.
    14421468 */
    1443 static int VBoxSupDrvInitGip(PSUPDRVDEVEXT pDevExt)
     1469static int VBoxDrvLinuxInitGip(PSUPDRVDEVEXT pDevExt)
    14441470{
    14451471    struct page *pPage;
    … …  
    14491475    unsigned i;
    14501476#endif
    1451     dprintf(("VBoxSupDrvInitGip:\n"));
     1477    dprintf(("VBoxDrvLinuxInitGip:\n"));
    14521478
    14531479    /*
    … …  
    14571483    if (!pPage)
    14581484    {
    1459         dprintf(("VBoxSupDrvInitGip: failed to allocate the GIP page\n"));
     1485        dprintf(("VBoxDrvLinuxInitGip: failed to allocate the GIP page\n"));
    14601486        return -ENOMEM;
    14611487    }
    … …  
    14751501#ifdef TICK_NSEC
    14761502    pDevExt->u64LastMonotime = (uint64_t)pDevExt->ulLastJiffies * TICK_NSEC;
    1477     dprintf(("VBoxSupDrvInitGIP: TICK_NSEC=%ld HZ=%d jiffies=%ld now=%lld\n",
     1503    dprintf(("VBoxDrvInitGIP: TICK_NSEC=%ld HZ=%d jiffies=%ld now=%lld\n",
    14781504             TICK_NSEC, HZ, pDevExt->ulLastJiffies, pDevExt->u64LastMonotime));
    14791505#else
    14801506    pDevExt->u64LastMonotime = (uint64_t)pDevExt->ulLastJiffies * (1000000 / HZ);
    1481     dprintf(("VBoxSupDrvInitGIP: TICK_NSEC=%d HZ=%d jiffies=%ld now=%lld\n",
     1507    dprintf(("VBoxDrvInitGIP: TICK_NSEC=%d HZ=%d jiffies=%ld now=%lld\n",
    14821508             (int)(1000000 / HZ), HZ, pDevExt->ulLastJiffies, pDevExt->u64LastMonotime));
    14831509#endif
    … …  
    14901516    init_timer(&g_GipTimer);
    14911517    g_GipTimer.data = (unsigned long)pDevExt;
    1492     g_GipTimer.function = VBoxSupGipTimer;
     1518    g_GipTimer.function = VBoxDrvLinuxGipTimer;
    14931519    g_GipTimer.expires = jiffies;
    14941520#ifdef CONFIG_SMP
    … …  
    15001526        init_timer(&pDevExt->aCPUs[i].Timer);
    15011527        pDevExt->aCPUs[i].Timer.data      = i;
    1502         pDevExt->aCPUs[i].Timer.function  = VBoxSupGipTimerPerCpu;
     1528        pDevExt->aCPUs[i].Timer.function  = VBoxDrvLinuxGipTimerPerCpu;
    15031529        pDevExt->aCPUs[i].Timer.expires   = jiffies;
    15041530    }
    … …  
    15151541 * @param   pDevExt     Instance data. GIP stuff may be updated.
    15161542 */
    1517 static int VBoxSupDrvTermGip(PSUPDRVDEVEXT pDevExt)
     1543static int VBoxDrvLinuxTermGip(PSUPDRVDEVEXT pDevExt)
    15181544{
    15191545    struct page *pPage;
    … …  
    15221548    unsigned i;
    15231549#endif
    1524     dprintf(("VBoxSupDrvTermGip:\n"));
     1550    dprintf(("VBoxDrvLinuxTermGip:\n"));
    15251551
    15261552    /*
    … …  
    15651591 * @param   ulUser  The device extension pointer.
    15661592 */
    1567 static void     VBoxSupGipTimer(unsigned long ulUser)
     1593static void     VBoxDrvLinuxGipTimer(unsigned long ulUser)
    15681594{
    15691595    PSUPDRVDEVEXT       pDevExt;
    … …  
    16201646 * @param   iTimerCPU     The APIC ID of this timer.
    16211647 */
    1622 static void VBoxSupGipTimerPerCpu(unsigned long iTimerCPU)
     1648static void VBoxDrvLinuxGipTimerPerCpu(unsigned long iTimerCPU)
    16231649{
    16241650    PSUPDRVDEVEXT       pDevExt;
    … …  
    17791805    {
    17801806        mod_timer(&g_GipTimer, jiffies);
    1781         smp_call_function(VBoxSupGipResumePerCpu, pDevExt, 0 /* retry */, 1 /* wait */);
     1807        smp_call_function(VBoxDrvLinuxGipResumePerCpu, pDevExt, 0 /* retry */, 1 /* wait */);
    17821808    }
    17831809#endif
    … …  
    17931819 * @param   pvUser  Pointer to the device instance.
    17941820 */
    1795 static void VBoxSupGipResumePerCpu(void *pvUser)
     1821static void VBoxDrvLinuxGipResumePerCpu(void *pvUser)
    17961822{
    17971823    PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pvUser;
    … …  
    18691895 * @param   rc  supdrv error code (SUPDRV_ERR_* defines).
    18701896 */
    1871 static int     VBoxSupDrvErr2LinuxErr(int rc)
     1897static int     VBoxDrvLinuxErr2LinuxErr(int rc)
    18721898{
    18731899    switch (rc)
    … …  
    19401966
    19411967
    1942 module_init(VBoxSupDrvInit);
    1943 module_exit(VBoxSupDrvUnload);
     1968module_init(VBoxDrvLinuxInit);
     1969module_exit(VBoxDrvLinuxUnload);
    19441970
    19451971MODULE_AUTHOR("innotek GmbH");

  • trunk/src/VBox/HostDrivers/Support/linux/SUPLib-linux.cpp

    r4071 r4800  
    201201 * @returns VBOX error code on failure.
    202202 * @param   uFunction   IO Control function.
    203  * @param   pvIn        Input data buffer.
    204  * @param   cbIn        Size of input data.
    205  * @param   pvOut       Output data buffer.
    206  * @param   cbOut       Size of output data.
    207  */
    208 int     suplibOsIOCtl(unsigned uFunction, void *pvIn, size_t cbIn, void *pvOut, size_t cbOut)
     203 * @param   pvReq       The request buffer.
     204 * @param   cbReq       The size of the request buffer.
     205 */
     206int suplibOsIOCtl(uintptr_t uFunction, void *pvReq, size_t cbReq)
    209207{
    210208    AssertMsg(g_hDevice != -1, ("SUPLIB not initiated successfully!\n"));
     209
    211210    /*
    212211     * Issue device iocontrol.
    213212     */
    214     SUPDRVIOCTLDATA Args;
    215     Args.pvIn = pvIn;
    216     Args.cbIn = cbIn;
    217     Args.pvOut = pvOut;
    218     Args.cbOut = cbOut;
    219 
    220     if (ioctl(g_hDevice, uFunction, &Args) >= 0)
     213    if (RT_LIKELY(ioctl(g_hDevice, uFunction, pvReq) >= 0))
    221214        return VINF_SUCCESS;
    222215

  • trunk/src/VBox/HostDrivers/Support/os2/SUPLib-os2.cpp

    r4071 r4800  
    131131
    132132
    133 int suplibOsIOCtl(unsigned uFunction, void *pvIn, size_t cbIn, void *pvOut, size_t cbOut)
     133int suplibOsIOCtl(uintptr_t uFunction, void *pvReq, size_t cbReq)
    134134{
    135135    AssertMsg(g_hDevice != (HFILE)-1, ("SUPLIB not initiated successfully!\n"));
    136136
    137     SUPDRVIOCTLDATA Args;
    138     Args.pvIn = pvIn;
    139     Args.cbIn = cbIn;
    140     Args.pvOut = pvOut;
    141     Args.cbOut = cbOut;
    142     Args.rc = VERR_INTERNAL_ERROR;
    143 
    144     ULONG cbReturned = sizeof(Args);
     137    ULONG cbReturned = sizeof(SUPREQHDR);
    145138    int rc = DosDevIOCtl(g_hDevice, SUP_CTL_CATEGORY, uFunction,
    146                          &Args, sizeof(Args), &cbReturned,
     139                         &cbIn, cbReturned, &cbReturned,
    147140                         NULL, 0, NULL);
    148141    if (RT_LIKELY(rc == NO_ERROR))
    149         rc = Args.rc;
    150     else
    151         rc = RTErrConvertFromOS2(rc);
    152     return rc;
     142        return VINF_SUCCESS;
     143    return RTErrConvertFromOS2(rc);
    153144}
    154145
    155146
    156147#ifdef VBOX_WITHOUT_IDT_PATCHING
    157 int suplibOSIOCtlFast(unsigned uFunction)
     148int suplibOSIOCtlFast(uintptr_t uFunction)
    158149{
    159150    int32_t rcRet = VERR_INTERNAL_ERROR;

  • trunk/src/VBox/HostDrivers/Support/solaris/SUPDrv-solaris.c

    r4717 r4800  
    235235            break;
    236236    }
    237    
     237
    238238    if (instance >= DEVICE_MAXINSTANCES)
    239239    {
    … …  
    241241        return ENXIO;
    242242    }
    243    
     243
    244244    *pDev = makedevice(getmajor(*pDev), instance);
    245        
     245
    246246    return VBoxSupDrvErr2SolarisErr(rc);
    247247}
    … …  
    290290    if (!pSession)
    291291    {
    292         OSDBGPRINT(("VBoxDrvSolarisClose: WHAT?!? pSession == NULL! This must be a mistake... pid=%d (close)\n", 
     292        OSDBGPRINT(("VBoxDrvSolarisClose: WHAT?!? pSession == NULL! This must be a mistake... pid=%d (close)\n",
    293293                    (int)Process));
    294294        return DDI_FAILURE;
    … …  
    328328    int instance = 0;
    329329    vbox_devstate_t *pState;
    330    
     330
    331331    switch (enmCmd)
    332332    {
    … …  
    340340                return DDI_FAILURE;
    341341            }
    342            
     342
    343343            pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, instance);
    344            
     344
    345345            /*
    346346             * Initialize IPRT R0 driver, which internally calls OS-specific r0 init.
    … …  
    425425            ddi_remove_minor_node(pDip, NULL);
    426426            ddi_soft_state_free(g_pVBoxDrvSolarisState, instance);
    427            
    428             rc = supdrvDeleteDevExt(&g_DevExt);
    429             AssertRC(rc);
     427
     428            supdrvDeleteDevExt(&g_DevExt);
    430429
    431430            rc = RTSpinlockDestroy(g_Spinlock);
    … …  
    478477    if (!pSession)
    479478    {
    480         OSDBGPRINT(("VBoxSupDrvIOCtl: WHAT?!? pSession == NULL! This must be a mistake... pid=%d iCmd=%#x\n", 
     479        OSDBGPRINT(("VBoxSupDrvIOCtl: WHAT?!? pSession == NULL! This must be a mistake... pid=%d iCmd=%#x\n",
    481480                    (int)Process, Cmd));
    482481        return EINVAL;
    … …  
    502501 * @returns Solaris errno.
    503502 *
    504  * @param pSession  The session.
    505  * @param Cmd       The IOCtl command.
    506  * @param Mode      Information bitfield (for specifying ownership of data)
    507  * @param pArgs     Pointer to the kernel copy of the SUPDRVIOCTLDATA buffer.
    508  */
    509 static int VBoxDrvSolarisIOCtlSlow(PSUPDRVSESSION pSession, int Cmd, int Mode, intptr_t pArgs)
    510 {
    511     int                 rc;
    512     void               *pvBuf = NULL;
    513     unsigned long       cbBuf = 0;
    514     unsigned            cbOut = 0;
    515     PSUPDRVIOCTLDATA    pArgData = (PSUPDRVIOCTLDATA)pArgs;
    516 
    517    /*
    518      * Allocate and copy user space input data buffer to kernel space.
    519      */
    520     if (pArgData->cbIn > 0 || pArgData->cbOut > 0)
    521     {
    522         cbBuf = max(pArgData->cbIn, pArgData->cbOut);
    523         pvBuf = RTMemTmpAlloc(cbBuf);
    524 
    525         if (pvBuf == NULL)
     503 * @param   pSession    The session.
     504 * @param   Cmd         The IOCtl command.
     505 * @param   Mode        Information bitfield (for specifying ownership of data)
     506 * @param   iArg        User space address of the request buffer.
     507 */
     508static int VBoxDrvSolarisIOCtlSlow(PSUPDRVSESSION pSession, int iCmd, int Mode, intptr_t iArg)
     509{
     510    int         rc;
     511    uint32_t    cbBuf = 0;
     512    SUPREQHDR   Hdr;
     513    PSUPREQHDR  pHdr;
     514
     515
     516    /*
     517     * Read the header.
     518     */
     519    rc = ddi_copyin(&Hdr, (void *)iArg, sizeof(Hdr), Mode);
     520    if (RT_UNLIKELY(rc))
     521    {
     522        dprintf(("VBoxDrvSolarisIOCtlSlow: ddi_copyin(,%#lx,) failed; iCmd=%#x. rc=%d\n", iArg, iCmd, rc));
     523        return EFAULT;
     524    }
     525    if (RT_UNLIKELY((Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC))
     526    {
     527        dprintf(("VBoxDrvSolarisIOCtlSlow: bad header magic %#x; iCmd=%#x\n", Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK, iCmd));
     528        return EINVAL;
     529    }
     530
     531    /*
     532     * Buffer the request.
     533     */
     534    cbBuf = RT_MAX(Hdr.cbIn, Hdr.cbOut);
     535    if (RT_UNLIKELY(cbBuf > _1M*16))
     536    {
     537        dprintf(("VBoxDrvSolarisIOCtlSlow: too big cbBuf=%#x; iCmd=%#x\n", cbBuf, iCmd));
     538        return E2BIG;
     539    }
     540    if (RT_UNLIKELY(cbBuf < sizeof(Hdr)))
     541    {
     542        dprintf(("VBoxDrvSolarisIOCtlSlow: bad ioctl cbBuf=%#x; iCmd=%#x.\n", cbBuf, iCmd));
     543        return EINVAL;
     544    }
     545    pHdr = RTMemAlloc(cbBuf);
     546    if (RT_UNLIKELY(!pHdr))
     547    {
     548        OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: failed to allocate buffer of %d bytes for iCmd=%#x.\n", cbBuf, iCmd));
     549        return ENOMEM;
     550    }
     551    rc = ddi_copyin(pHdr, (void *)iArg, cbBuf, Mode);
     552    if (RT_UNLIKELY(rc))
     553    {
     554        dprintf(("VBoxDrvSolarisIOCtlSlow: copy_from_user(,%#lx, %#x) failed; iCmd=%#x. rc=%d\n", iArg, Hdr.cbIn, iCmd, rc));
     555        RTMemFree(pHdr);
     556        return EFAULT;
     557    }
     558
     559    /*
     560     * Process the IOCtl.
     561     */
     562    rc = supdrvIOCtl(Cmd, &g_DevExt, pSession, pHdr);
     563
     564    /*
     565     * Copy ioctl data and output buffer back to user space.
     566     */
     567    if (RT_LIKELY(!rc))
     568    {
     569        uint32_t cbOut = pHdr->cbOut;
     570        if (RT_UNLIKELY(cbOut > cbBuf))
    526571        {
    527             OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: failed to allocate buffer of %d bytes.\n", cbBuf));
    528             return ENOMEM;
     572            OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: too much output! %#x > %#x; iCmd=%#x!\n", cbOut, cbBuf, iCmd));
     573            cbOut = cbBuf;
    529574        }
    530        
    531         rc = ddi_copyin(pArgData->pvIn, pvBuf, pArgData->cbIn, Mode);
    532        
    533         if (rc != 0)
     575        rc = ddi_copyout(pHdr, (void *)iArg, cbOut, Mode);
     576        if (RT_UNLIKELY(rc != 0))
    534577        {
    535             OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: ddi_copyin(%p,%d) failed.\n", pArgData->pvIn, pArgData->cbIn));
    536 
    537             RTMemTmpFree(pvBuf);
    538             return EFAULT;
     578            /* this is really bad */
     579            OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: ddi_copyout(,%p,%d) failed. rc=%d\n", (void *)iArg, cbBuf, rc));
     580            rc = EFAULT;
    539581        }
    540582    }
    541    
    542     /*
    543      * Process the IOCtl.
    544      */
    545     rc = supdrvIOCtl(Cmd, &g_DevExt, pSession, pvBuf, pArgData->cbIn, pvBuf, pArgData->cbOut, &cbOut);
    546    
    547     /*
    548      * Copy ioctl data and output buffer back to user space.
    549      */
    550     if (rc != 0)
    551         rc = VBoxSupDrvErr2SolarisErr(rc);
    552     else if (cbOut > 0)
    553     {
    554         if (pvBuf != NULL && cbOut <= cbBuf)
    555         {
    556             rc = ddi_copyout(pvBuf, pArgData->pvOut, cbOut, Mode);
    557             if (rc != 0)
    558             {
    559                 OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: ddi_copyout(,%p,%d) failed.\n", pArgData->pvOut, cbBuf));
    560                 rc = EFAULT;
    561             }
    562         }
    563         else
    564         {
    565             OSDBGPRINT(("WHAT!?! supdrvIOCtl messed up! cbOut=%d cbBuf=%d pvBuf=%p\n", cbOut, cbBuf, pvBuf));
    566             rc = EPERM;
    567         }
    568     }
    569 
    570     if (pvBuf)
    571         RTMemTmpFree(pvBuf);
    572    
     583    else
     584        rc = EINVAL;
     585
     586    RTMemTmpFree(pHdr);
    573587    return rc;
    574588}

  • trunk/src/VBox/HostDrivers/Support/solaris/SUPLib-solaris.cpp

    r4178 r4800  
    103103
    104104
    105 /**
    106  * Installs anything required by the support library.
    107  *
    108  * @returns 0 on success.
    109  * @returns error code on failure.
    110  */
    111105int suplibOsInstall(void)
    112106{
    113 //    int rc = mknod(DEVICE_NAME, S_IFCHR, );
    114 
    115107    return VERR_NOT_IMPLEMENTED;
    116108}
    117109
    118 /**
    119  * Installs anything required by the support library.
    120  *
    121  * @returns 0 on success.
    122  * @returns error code on failure.
    123  */
    124110int suplibOsUninstall(void)
    125111{
    126 //    int rc = unlink(DEVICE_NAME);
    127 
    128112    return VERR_NOT_IMPLEMENTED;
    129113}
    130114
    131 /**
    132  * Send a I/O Control request to the device.
    133  *
    134  * @returns 0 on success.
    135  * @returns VBOX error code on failure.
    136  * @param   uFunction   IO Control function.
    137  * @param   pvIn        Input data buffer.
    138  * @param   cbIn        Size of input data.
    139  * @param   pvOut       Output data buffer.
    140  * @param   cbOut       Size of output data.
    141  */
    142 int suplibOsIOCtl(unsigned uFunction, void *pvIn, size_t cbIn, void *pvOut, size_t cbOut)
     115
     116int suplibOsIOCtl(uintptr_t uFunction, void *pvReq, size_t cbReq)
    143117{
    144118    AssertMsg(g_hDevice != -1, ("SUPLIB not initiated successfully!\n"));
     119
    145120    /*
    146121     * Issue device iocontrol.
    147122     */
    148     SUPDRVIOCTLDATA Args;
    149     Args.pvIn = pvIn;
    150     Args.cbIn = cbIn;
    151     Args.pvOut = pvOut;
    152     Args.cbOut = cbOut;
     123    if (RT_LIKELY(ioctl(g_hDevice, uFunction, &pvReq) >= 0))
     124        return VINF_SUCCESS;
    153125
    154     if (ioctl(g_hDevice, uFunction, &Args) >= 0)
    155         return 0;
    156        
    157126    /* This is the reverse operation of the one found in SUPDrv-solaris.c */
    158127    switch (errno)
    … …  
    174143
    175144#ifdef VBOX_WITHOUT_IDT_PATCHING
    176 int suplibOSIOCtlFast(unsigned uFunction)
     145int suplibOSIOCtlFast(uintptr_t uFunction)
    177146{
    178147    int rc = ioctl(g_hDevice, uFunction, NULL);
    … …  
    184153
    185154
    186 /**
    187  * Allocate a number of zero-filled pages in user space.
    188  *
    189  * @returns VBox status code.
    190  * @param   cPages      Number of pages to allocate.
    191  * @param   ppvPages    Where to return the base pointer.
    192  */
    193155int suplibOsPageAlloc(size_t cPages, void **ppvPages)
    194156{
    … …  
    200162
    201163
    202 /**
    203  * Frees pages allocated by suplibOsPageAlloc().
    204  *
    205  * @returns VBox status code.
    206  * @param   pvPages     Pointer to pages.
    207  */
    208164int suplibOsPageFree(void *pvPages, size_t /* cPages */)
    209165{

  • trunk/src/VBox/HostDrivers/Support/win/SUPDrv-win.cpp

    r4755 r4800  
    5858*   Internal Functions                                                         *
    5959*******************************************************************************/
    60 static void     _stdcall   VBoxSupDrvUnload(PDRIVER_OBJECT pDrvObj);
    61 static NTSTATUS _stdcall   VBoxSupDrvCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    62 static NTSTATUS _stdcall   VBoxSupDrvClose(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    63 static NTSTATUS _stdcall   VBoxSupDrvDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    64 static int                 VBoxSupDrvDeviceControlSlow(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PIRP pIrp, PIO_STACK_LOCATION pStack);
    65 static NTSTATUS _stdcall   VBoxSupDrvNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    66 static NTSTATUS            VBoxSupDrvErr2NtStatus(int rc);
    67 static NTSTATUS            VBoxSupDrvGipInit(PSUPDRVDEVEXT pDevExt);
    68 static void                VBoxSupDrvGipTerm(PSUPDRVDEVEXT pDevExt);
    69 static void     _stdcall   VBoxSupDrvGipTimer(IN PKDPC pDpc, IN PVOID pvUser, IN PVOID SystemArgument1, IN PVOID SystemArgument2);
    70 static void     _stdcall   VBoxSupDrvGipPerCpuDpc(IN PKDPC pDpc, IN PVOID pvUser, IN PVOID SystemArgument1, IN PVOID SystemArgument2);
     60static void     _stdcall   VBoxDrvNtUnload(PDRIVER_OBJECT pDrvObj);
     61static NTSTATUS _stdcall   VBoxDrvNtCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     62static NTSTATUS _stdcall   VBoxDrvNtClose(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     63static NTSTATUS _stdcall   VBoxDrvNtDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     64static int                 VBoxDrvNtDeviceControlSlow(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PIRP pIrp, PIO_STACK_LOCATION pStack);
     65static NTSTATUS _stdcall   VBoxDrvNtNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     66static NTSTATUS            VBoxDrvNtErr2NtStatus(int rc);
     67static NTSTATUS            VBoxDrvNtGipInit(PSUPDRVDEVEXT pDevExt);
     68static void                VBoxDrvNtGipTerm(PSUPDRVDEVEXT pDevExt);
     69static void     _stdcall   VBoxDrvNtGipTimer(IN PKDPC pDpc, IN PVOID pvUser, IN PVOID SystemArgument1, IN PVOID SystemArgument2);
     70static void     _stdcall   VBoxDrvNtGipPerCpuDpc(IN PKDPC pDpc, IN PVOID pvUser, IN PVOID SystemArgument1, IN PVOID SystemArgument2);
    7171
    7272
    … …  
    118118                 * Inititalize the GIP.
    119119                 */
    120                 rc = VBoxSupDrvGipInit(pDevExt);
     120                rc = VBoxDrvNtGipInit(pDevExt);
    121121                if (NT_SUCCESS(rc))
    122122                {
    … …  
    124124                     * Setup the driver entry points in pDrvObj.
    125125                     */
    126                     pDrvObj->DriverUnload                           = VBoxSupDrvUnload;
    127                     pDrvObj->MajorFunction[IRP_MJ_CREATE]           = VBoxSupDrvCreate;
    128                     pDrvObj->MajorFunction[IRP_MJ_CLOSE]            = VBoxSupDrvClose;
    129                     pDrvObj->MajorFunction[IRP_MJ_DEVICE_CONTROL]   = VBoxSupDrvDeviceControl;
    130                     pDrvObj->MajorFunction[IRP_MJ_READ]             = VBoxSupDrvNotSupportedStub;
    131                     pDrvObj->MajorFunction[IRP_MJ_WRITE]            = VBoxSupDrvNotSupportedStub;
     126                    pDrvObj->DriverUnload                           = VBoxDrvNtUnload;
     127                    pDrvObj->MajorFunction[IRP_MJ_CREATE]           = VBoxDrvNtCreate;
     128                    pDrvObj->MajorFunction[IRP_MJ_CLOSE]            = VBoxDrvNtClose;
     129                    pDrvObj->MajorFunction[IRP_MJ_DEVICE_CONTROL]   = VBoxDrvNtDeviceControl;
     130                    pDrvObj->MajorFunction[IRP_MJ_READ]             = VBoxDrvNtNotSupportedStub;
     131                    pDrvObj->MajorFunction[IRP_MJ_WRITE]            = VBoxDrvNtNotSupportedStub;
    132132                    /* more? */
    133133                    dprintf(("VBoxDrv::DriverEntry   returning STATUS_SUCCESS\n"));
    134134                    return STATUS_SUCCESS;
    135135                }
    136                 dprintf(("VBoxSupDrvGipInit failed with rc=%#x!\n", rc));
     136                dprintf(("VBoxDrvNtGipInit failed with rc=%#x!\n", rc));
    137137
    138138                supdrvDeleteDevExt(pDevExt);
    … …  
    141141            {
    142142                dprintf(("supdrvInitDevExit failed with vrc=%d!\n", vrc));
    143                 rc = VBoxSupDrvErr2NtStatus(vrc);
     143                rc = VBoxDrvNtErr2NtStatus(vrc);
    144144            }
    145145
    … …  
    166166 * @param   pDrvObj     Driver object.
    167167 */
    168 void _stdcall VBoxSupDrvUnload(PDRIVER_OBJECT pDrvObj)
    169 {
    170     dprintf(("VBoxSupDrvUnload\n"));
     168void _stdcall VBoxDrvNtUnload(PDRIVER_OBJECT pDrvObj)
     169{
     170    dprintf(("VBoxDrvNtUnload\n"));
    171171    PSUPDRVDEVEXT       pDevExt = (PSUPDRVDEVEXT)pDrvObj->DeviceObject->DeviceExtension;
    172172
    … …  
    182182     * Terminate the GIP page and delete the device extension.
    183183     */
    184     VBoxSupDrvGipTerm(pDevExt);
     184    VBoxDrvNtGipTerm(pDevExt);
    185185    supdrvDeleteDevExt(pDevExt);
    186186    IoDeleteDevice(pDrvObj->DeviceObject);
    … …  
    194194 * @param   pIrp        Request packet.
    195195 */
    196 NTSTATUS _stdcall VBoxSupDrvCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    197 {
    198     dprintf(("VBoxSupDrvCreate\n"));
     196NTSTATUS _stdcall VBoxDrvNtCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     197{
     198    dprintf(("VBoxDrvNtCreate\n"));
    199199    PIO_STACK_LOCATION  pStack = IoGetCurrentIrpStackLocation(pIrp);
    200200    PFILE_OBJECT        pFileObj = pStack->FileObject;
    … …  
    228228    }
    229229
    230     NTSTATUS    rcNt = pIrp->IoStatus.Status = VBoxSupDrvErr2NtStatus(rc);
     230    NTSTATUS    rcNt = pIrp->IoStatus.Status = VBoxDrvNtErr2NtStatus(rc);
    231231    pIrp->IoStatus.Information  = 0;
    232232    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    … …  
    242242 * @param   pIrp        Request packet.
    243243 */
    244 NTSTATUS _stdcall VBoxSupDrvClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     244NTSTATUS _stdcall VBoxDrvNtClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    245245{
    246246    PSUPDRVDEVEXT       pDevExt = (PSUPDRVDEVEXT)pDevObj->DeviceExtension;
    247247    PIO_STACK_LOCATION  pStack = IoGetCurrentIrpStackLocation(pIrp);
    248248    PFILE_OBJECT        pFileObj = pStack->FileObject;
    249     dprintf(("VBoxSupDrvClose: pDevExt=%p pFileObj=%p pSession=%p\n",
     249    dprintf(("VBoxDrvNtClose: pDevExt=%p pFileObj=%p pSession=%p\n",
    250250             pDevExt, pFileObj, pFileObj->FsContext));
    251251    supdrvCloseSession(pDevExt, (PSUPDRVSESSION)pFileObj->FsContext);
    … …  
    265265 * @param   pIrp        Request packet.
    266266 */
    267 NTSTATUS _stdcall VBoxSupDrvDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     267NTSTATUS _stdcall VBoxDrvNtDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    268268{
    269269    PSUPDRVDEVEXT       pDevExt = (PSUPDRVDEVEXT)pDevObj->DeviceExtension;
    … …  
    300300#endif /* VBOX_WITHOUT_IDT_PATCHING */
    301301
    302     return VBoxSupDrvDeviceControlSlow(pDevExt, pSession, pIrp, pStack);
    303 }
    304 
    305 
    306 /**
    307  * Worker for VBoxSupDrvDeviceControl that takes the slow IOCtl functions.
     302    return VBoxDrvNtDeviceControlSlow(pDevExt, pSession, pIrp, pStack);
     303}
     304
     305
     306/**
     307 * Worker for VBoxDrvNtDeviceControl that takes the slow IOCtl functions.
    308308 *
    309309 * @returns NT status code.
    … …  
    314314 * @param   pStack      The stack location containing the DeviceControl parameters.
    315315 */
    316 static int VBoxSupDrvDeviceControlSlow(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PIRP pIrp, PIO_STACK_LOCATION pStack)
    317 {
    318     NTSTATUS    rcNt = STATUS_NOT_SUPPORTED;
     316static int VBoxDrvNtDeviceControlSlow(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PIRP pIrp, PIO_STACK_LOCATION pStack)
     317{
     318    NTSTATUS    rcNt;
    319319    unsigned    cbOut = 0;
    320320    int         rc = 0;
    321     dprintf2(("VBoxSupDrvDeviceControlSlow(%p,%p): ioctl=%#x pBuf=%p cbIn=%#x cbOut=%#x pSession=%p\n",
     321    dprintf2(("VBoxDrvNtDeviceControlSlow(%p,%p): ioctl=%#x pBuf=%p cbIn=%#x cbOut=%#x pSession=%p\n",
    322322             pDevExt, pIrp, pStack->Parameters.DeviceIoControl.IoControlCode,
    323323             pIrp->AssociatedIrp.SystemBuffer, pStack->Parameters.DeviceIoControl.InputBufferLength,
    … …  
    332332        if ((pStack->Parameters.DeviceIoControl.IoControlCode & 0x3) == METHOD_BUFFERED)
    333333        {
    334             char *pBuf = (char *)pIrp->AssociatedIrp.SystemBuffer;
    335 
    336             /*
    337              * Do the job.
    338              */
    339             rc = supdrvIOCtl(pStack->Parameters.DeviceIoControl.IoControlCode, pDevExt, pSession,
    340                              pBuf, pStack->Parameters.DeviceIoControl.InputBufferLength,
    341                              pBuf, pStack->Parameters.DeviceIoControl.OutputBufferLength,
    342                              &cbOut);
    343             rcNt = VBoxSupDrvErr2NtStatus(rc);
    344 
    345             /* sanity check. */
    346             AssertMsg(cbOut <= pStack->Parameters.DeviceIoControl.OutputBufferLength,
    347                       ("cbOut is too large! cbOut=%d max=%d! ioctl=%#x\n",
    348                        cbOut, pStack->Parameters.DeviceIoControl.OutputBufferLength,
    349                        pStack->Parameters.DeviceIoControl.IoControlCode));
    350             if (cbOut > pStack->Parameters.DeviceIoControl.OutputBufferLength)
    351                 cbOut = pStack->Parameters.DeviceIoControl.OutputBufferLength;
    352             dprintf2(("VBoxSupDrvDeviceControlSlow: returns %#x cbOut=%d rc=%#x\n", rcNt, cbOut, rc));
     334            /* Verify that the sizes in the request header are correct. */
     335            PSUPREQHDR pHdr = (PSUPREQHDR)pIrp->AssociatedIrp.SystemBuffer;
     336            if (    pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr)
     337                &&  pStack->Parameters.DeviceIoControl.InputBufferLength ==  pHdr->cbIn
     338                &&  pStack->Parameters.DeviceIoControl.OutputBufferLength ==  pHdr->cbOut)
     339            {
     340                /*
     341                 * Do the job.
     342                 */
     343                rc = supdrvIOCtl(pStack->Parameters.DeviceIoControl.IoControlCode, pDevExt, pSession, pHdr);
     344                if (!rc)
     345                {
     346                    rcNt = STATUS_SUCCESS;
     347                    cbOut = pHdr->cbOut;
     348                    if (cbOut > pStack->Parameters.DeviceIoControl.OutputBufferLength)
     349                    {
     350                        cbOut = pStack->Parameters.DeviceIoControl.OutputBufferLength;
     351                        OSDBGPRINT(("VBoxDrvLinuxIOCtl: too much output! %#x > %#x; uCmd=%#x!\n",
     352                                    pHdr->cbOut, cbOut, pStack->Parameters.DeviceIoControl.IoControlCode));
     353                    }
     354                }
     355                else
     356                    rcNt = STATUS_INVALID_PARAMETER;
     357                dprintf2(("VBoxDrvNtDeviceControlSlow: returns %#x cbOut=%d rc=%#x\n", rcNt, cbOut, rc));
     358            }
     359            else
     360            {
     361                dprintf(("VBoxDrvNtDeviceControlSlow: Mismatching sizes (%#x) - Hdr=%#lx/%#lx Irp=%#lx/%#lx!\n",
     362                         pStack->Parameters.DeviceIoControl.IoControlCode,
     363                         pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr) ? pHdr->cbIn : 0,
     364                         pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr) ? pHdr->cbOut : 0,
     365                         pStack->Parameters.DeviceIoControl.InputBufferLength,
     366                         pStack->Parameters.DeviceIoControl.OutputBufferLength));
     367                rcNt = STATUS_INVALID_PARAMETER;
     368            }
    353369        }
    354370        else
    355             dprintf(("VBoxSupDrvDeviceControlSlow: not buffered request (%#x) - not supported\n",
     371        {
     372            dprintf(("VBoxDrvNtDeviceControlSlow: not buffered request (%#x) - not supported\n",
    356373                     pStack->Parameters.DeviceIoControl.IoControlCode));
     374            rcNt = STATUS_NOT_SUPPORTED;
     375        }
    357376    }
    358377#ifdef RT_ARCH_AMD64
    359378    else
    360         dprintf(("VBoxSupDrvDeviceControlSlow: WOW64 req - not supported\n"));
     379    {
     380        dprintf(("VBoxDrvNtDeviceControlSlow: WOW64 req - not supported\n"));
     381        rcNt = STATUS_NOT_SUPPORTED;
     382    }
    361383#endif
    362384
    363385    /* complete the request. */
    364386    pIrp->IoStatus.Status = rcNt;
    365     pIrp->IoStatus.Information = NT_SUCCESS(rcNt) ? cbOut : rc; /* does this rc passing actually work?!? */
     387    pIrp->IoStatus.Information = cbOut;
    366388    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    367389    return rcNt;
    … …  
    376398 * @param   pIrp        IRP.
    377399 */
    378 NTSTATUS _stdcall VBoxSupDrvNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    379 {
    380     dprintf(("VBoxSupDrvNotSupportedStub\n"));
     400NTSTATUS _stdcall VBoxDrvNtNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     401{
     402    dprintf(("VBoxDrvNtNotSupportedStub\n"));
    381403    pDevObj = pDevObj;
    382404
    … …  
    808830 * @param   pDevExt     Instance data. GIP stuff may be updated.
    809831 */
    810 static NTSTATUS VBoxSupDrvGipInit(PSUPDRVDEVEXT pDevExt)
     832static NTSTATUS VBoxDrvNtGipInit(PSUPDRVDEVEXT pDevExt)
    811833{
    812834    dprintf2(("VBoxSupDrvTermGip:\n"));
    … …  
    850872                 */
    851873                KeInitializeTimerEx(&pDevExt->GipTimer, SynchronizationTimer);
    852                 KeInitializeDpc(&pDevExt->GipDpc, VBoxSupDrvGipTimer, pDevExt);
     874                KeInitializeDpc(&pDevExt->GipDpc, VBoxDrvNtGipTimer, pDevExt);
    853875
    854876                /*
    … …  
    862884                for (unsigned i = 0; i < RT_ELEMENTS(pDevExt->aGipCpuDpcs); i++)
    863885                {
    864                     KeInitializeDpc(&pDevExt->aGipCpuDpcs[i], VBoxSupDrvGipPerCpuDpc, pGip);
     886                    KeInitializeDpc(&pDevExt->aGipCpuDpcs[i], VBoxDrvNtGipPerCpuDpc, pGip);
    865887                    KeSetImportanceDpc(&pDevExt->aGipCpuDpcs[i], HighImportance);
    866888                    if (pfnKeSetTargetProcessorDpc)
    … …  
    868890                }
    869891
    870                 dprintf(("VBoxSupDrvGipInit: ulClockFreq=%ld ulClockInterval=%ld ulClockIntervalActual=%ld Phys=%x%08x\n",
     892                dprintf(("VBoxDrvNtGipInit: ulClockFreq=%ld ulClockInterval=%ld ulClockIntervalActual=%ld Phys=%x%08x\n",
    871893                         ulClockFreq, ulClockInterval, ulClockIntervalActual, Phys.HighPart, Phys.LowPart));
    872894                return STATUS_SUCCESS;
    … …  
    898920 * @param   pDevExt     Instance data. GIP stuff may be updated.
    899921 */
    900 static void VBoxSupDrvGipTerm(PSUPDRVDEVEXT pDevExt)
     922static void VBoxDrvNtGipTerm(PSUPDRVDEVEXT pDevExt)
    901923{
    902924    dprintf(("VBoxSupDrvTermGip:\n"));
    … …  
    941963 * The pvUser parameter is the pDevExt pointer.
    942964 */
    943 static void _stdcall VBoxSupDrvGipTimer(IN PKDPC pDpc, IN PVOID pvUser, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
     965static void _stdcall VBoxDrvNtGipTimer(IN PKDPC pDpc, IN PVOID pvUser, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
    944966{
    945967    PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pvUser;
    … …  
    9821004 * The pvUser parameter is the pGip pointer.
    9831005 */
    984 static void _stdcall VBoxSupDrvGipPerCpuDpc(IN PKDPC pDpc, IN PVOID pvUser, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
     1006static void _stdcall VBoxDrvNtGipPerCpuDpc(IN PKDPC pDpc, IN PVOID pvUser, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
    9851007{
    9861008    PSUPGLOBALINFOPAGE pGip = (PSUPGLOBALINFOPAGE)pvUser;
    … …  
    11731195 * @param   rc  supdrv error code (SUPDRV_ERR_* defines).
    11741196 */
    1175 static NTSTATUS     VBoxSupDrvErr2NtStatus(int rc)
     1197static NTSTATUS     VBoxDrvNtErr2NtStatus(int rc)
    11761198{
    11771199    switch (rc)

  • trunk/src/VBox/HostDrivers/Support/win/SUPLib-win.cpp

    r4071 r4800  
    2121*******************************************************************************/
    2222#define LOG_GROUP LOG_GROUP_SUP
    23 #include <windows.h>
     23#include <Windows.h>
    2424
    2525#include <VBox/sup.h>
    … …  
    3232#include <iprt/string.h>
    3333#include "SUPLibInternal.h"
     34#include "SUPDRVIOC.h"
    3435
    3536
    … …  
    603604 * @returns VBOX error code on failure.
    604605 * @param   uFunction   IO Control function.
    605  * @param   pvIn        Input data buffer.
    606  * @param   cbIn        Size of input data.
    607  * @param   pvOut       Output data buffer.
    608  * @param   cbOut       Size of output data.
    609  */
    610 int     suplibOsIOCtl(unsigned uFunction, void *pvIn, size_t cbIn, void *pvOut, size_t cbOut)
     606 * @param   pvIn        The request buffer.
     607 * @param   cbReq       The size of the request buffer.
     608 */
     609int suplibOsIOCtl(uintptr_t uFunction, void *pvReq, size_t cbReq)
    611610{
    612611    AssertMsg(g_hDevice != INVALID_HANDLE_VALUE, ("SUPLIB not initiated successfully!\n"));
    613     /*
    614      * Issue device I/O control.
    615      */
    616     DWORD cbReturned = (ULONG)cbOut;
    617     if (DeviceIoControl(g_hDevice, uFunction, pvIn, (ULONG)cbIn, pvOut, (ULONG)cbOut, &cbReturned, NULL))
     612
     613    /*
     614     * Issue the device I/O control.
     615     */
     616    PSUPREQHDR pHdr = (PSUPREQHDR)pvReq;
     617    Assert(cbReq == RT_MAX(pHdr->cbIn, pHdr->cbOut));
     618    DWORD cbReturned = (ULONG)pHdr->cbOut;
     619    if (DeviceIoControl(g_hDevice, uFunction, pvReq, pHdr->cbIn, pvReq, cbReturned, &cbReturned, NULL))
    618620        return 0;
     621
    619622    return suplibConvertWin32Err(GetLastError());
    620623}
Note: See TracChangeset for help on using the changeset viewer.

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