path: root/include/VBox/VBoxGuest.h

/** @file
 * VBoxGuest - VirtualBox Guest Additions Driver Interface. (ADD,DEV)
 *
 * @note    This file is used by 16-bit compilers too (OpenWatcom).
 */

/*
 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef VBOX_INCLUDED_VBoxGuest_h
#define VBOX_INCLUDED_VBoxGuest_h
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include <VBox/types.h>
#include <iprt/assertcompile.h>
#include <VBox/VMMDevCoreTypes.h>
#include <VBox/VBoxGuestCoreTypes.h>



/** @defgroup grp_vboxguest  VirtualBox Guest Additions Device Driver
 *
 * Also know as VBoxGuest.
 *
 * @{
 */

/** @defgroup grp_vboxguest_ioc  VirtualBox Guest Additions Driver Interface
 *
 * @note This is considered internal in ring-3, please use the VbglR3 functions.
 *
 * - I/O controls for user and/or kernel mode starts at 0.
 * - IDC specific requests descends from 63.
 * - Bits 7 and 6 are currently reserved for future hacks.
 *
 * @remarks When creating new IOCtl interfaces keep in mind that not all OSes supports
 *          reporting back the output size. (This got messed up a little bit in VBoxDrv.)
 *
 *          The request size is also a little bit tricky as it's passed as part of the
 *          request code on unix. The size field is 14 bits on Linux, 12 bits on *BSD,
 *          13 bits Darwin, and 8-bits on Solaris. All the BSDs and Darwin kernels
 *          will make use of the size field, while Linux and Solaris will not. We're of
 *          course using the size to validate and/or map/lock the request, so it has
 *          to be valid.
 *
 *          For Solaris we will have to do something special though, 255 isn't
 *          sufficient for all we need. A 4KB restriction (BSD) is probably not
 *          too problematic (yet) as a general one.
 *
 *          More info can be found in SUPDRVIOC.h and related sources.
 *
 * @remarks If adding interfaces that only has input or only has output, some new macros
 *          needs to be created so the most efficient IOCtl data buffering method can be
 *          used.
 *
 * @{
 */
#if !defined(IN_RC) && !defined(IN_RING0_AGNOSTIC)

/** Fictive start address of the hypervisor physical memory for MmMapIoSpace. */
#define VBOXGUEST_HYPERVISOR_PHYSICAL_START         UINT32_C(0xf8000000)

#ifdef RT_OS_DARWIN
/** Cookie used to fend off some unwanted clients to the IOService. */
# define VBOXGUEST_DARWIN_IOSERVICE_COOKIE          UINT32_C(0x56426f78) /* 'VBox' */
#endif


#if defined(RT_OS_WINDOWS)
# ifndef CTL_CODE
#  include <iprt/win/windows.h>
# endif
  /* Automatic buffering, size not encoded. */
# define VBGL_IOCTL_CODE_SIZE(Function, Size)       CTL_CODE(FILE_DEVICE_UNKNOWN, 2048 + (Function), METHOD_BUFFERED, FILE_WRITE_ACCESS)
# define VBGL_IOCTL_CODE_BIG(Function)              CTL_CODE(FILE_DEVICE_UNKNOWN, 2048 + (Function), METHOD_BUFFERED, FILE_WRITE_ACCESS)
# define VBGL_IOCTL_CODE_FAST(Function)             CTL_CODE(FILE_DEVICE_UNKNOWN, 2048 + (Function), METHOD_NEITHER,  FILE_WRITE_ACCESS)
# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl)         (a_uIOCtl)
# define VBOXGUEST_DEVICE_NAME                      "\\\\.\\VBoxGuest"
/** The support service name. */
# define VBOXGUEST_SERVICE_NAME                     "VBoxGuest"
/** Global name for Win2k+ */
# define VBOXGUEST_DEVICE_NAME_GLOBAL               "\\\\.\\Global\\VBoxGuest"
/** Win32 driver name */
# define VBOXGUEST_DEVICE_NAME_NT                   L"\\Device\\VBoxGuest"
/** Device name. */
# define VBOXGUEST_DEVICE_NAME_DOS                  L"\\DosDevices\\VBoxGuest"

#elif defined(RT_OS_OS2)
  /* No automatic buffering, size not encoded. */
# define VBGL_IOCTL_CATEGORY                        0xc2
# define VBGL_IOCTL_CODE_SIZE(Function, Size)       ((unsigned char)(Function))
# define VBGL_IOCTL_CODE_BIG(Function)              ((unsigned char)(Function))
# define VBGL_IOCTL_CATEGORY_FAST                   0xc3 /**< Also defined in VBoxGuestA-os2.asm. */
# define VBGL_IOCTL_CODE_FAST(Function)             ((unsigned char)(Function))
# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl)         (a_uIOCtl)
# define VBOXGUEST_DEVICE_NAME                      "\\Dev\\VBoxGst$"
/** Short device name for AttachDD.
 * @note Case sensitive. Must match what VBoxGuestA-os2.asm says! */
# define VBOXGUEST_DEVICE_NAME_SHORT                "vboxgst$"

#elif defined(RT_OS_SOLARIS)
  /* No automatic buffering, size limited to 255 bytes => use VBGLBIGREQ for everything. */
# include <sys/ioccom.h>
# define VBGL_IOCTL_CODE_SIZE(Function, Size)       ((uintptr_t)(_IOWRN('V', (Function), sizeof(VBGLREQHDR))))
# define VBGL_IOCTL_CODE_BIG(Function)              _IOWRN('V', (Function), sizeof(VBGLREQHDR))
# define VBGL_IOCTL_CODE_FAST(Function)             _IO(   'F', (Function))
# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl)         (a_uIOCtl)
# define VBGL_IOCTL_IS_FAST(a_uIOCtl)               ( ((a_uIOCtl) & 0x0000ff00) == ('F' << 8) )

#elif defined(RT_OS_LINUX)
  /* No automatic buffering, size limited to 16KB. */
# include <linux/ioctl.h>
# define VBGL_IOCTL_CODE_SIZE(Function, Size)       _IOC(_IOC_READ | _IOC_WRITE, 'V', (Function), (Size))
# define VBGL_IOCTL_CODE_BIG(Function)              _IO('V', (Function))
# define VBGL_IOCTL_CODE_FAST(Function)             _IO('F', (Function))
# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl)         _IOC_NR((a_uIOCtl))
# define VBOXGUEST_USER_DEVICE_NAME                 "/dev/vboxuser"

#elif defined(RT_OS_HAIKU)
  /* No automatic buffering, size not encoded. */
  /** @todo do something better */
# define VBGL_IOCTL_CODE_SIZE(Function, Size)       (0x56420000 | (Function))
# define VBGL_IOCTL_CODE_BIG(Function)              (0x56420000 | (Function))
# define VBGL_IOCTL_CODE_FAST(Function)             (0x56420000 | (Function))
# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl)         (a_uIOCtl)
# define VBOXGUEST_DEVICE_NAME                      "/dev/misc/vboxguest"

#else /* BSD Like */
  /* Automatic buffering, size limited to 4KB on *BSD and 8KB on Darwin - commands the limit, 4KB. */
# include <sys/ioccom.h>
# define VBGL_IOCTL_CODE_SIZE(Function, Size)       _IOC(IOC_INOUT, 'V', (Function), (Size))
# define VBGL_IOCTL_CODE_BIG(Function)              _IO('V', (Function))
# define VBGL_IOCTL_CODE_FAST(Function)             _IO('F', (Function))
# define VBGL_IOCTL_CODE_STRIPPED(a_uIOCtl)         ((a_uIOCtl) & ~(_IOC(0,0,0,IOCPARM_MASK)))
# define VBGL_IOCTL_IS_FAST(a_uIOCtl)               ( IOCGROUP(a_uIOCtl) == 'F' )
# if defined(RT_OS_DARWIN)
#  define VBOXGUEST_DEVICE_NAME                     "/dev/vboxguest"
#  define VBOXGUEST_USER_DEVICE_NAME                "/dev/vboxguestu"
# endif

#endif

/** @todo It would be nice if we could have two defines without paths. */

/** @def VBOXGUEST_DEVICE_NAME
 * The support device name. */
#ifndef VBOXGUEST_DEVICE_NAME /* PORTME */
# define VBOXGUEST_DEVICE_NAME          "/dev/vboxguest"
#endif

/** @def VBOXGUEST_USER_DEVICE_NAME
 * The support device name of the user accessible device node. */
#ifndef VBOXGUEST_USER_DEVICE_NAME
# define VBOXGUEST_USER_DEVICE_NAME     VBOXGUEST_DEVICE_NAME
#endif


/**
 * The VBoxGuest I/O control version.
 *
 * As usual, the high word contains the major version and changes to it
 * signifies incompatible changes.
 *
 * The lower word is the minor version number, it is increased when new
 * functions are added or existing changed in a backwards compatible manner.
 */
#define VBGL_IOC_VERSION                          UINT32_C(0x00010000)



/** @name VBGL_IOCTL_DRIVER_INFO
 * Adjust and get driver information.
 *
 * @note May switch the session to a backwards compatible interface version if
 *       uClientVersion indicates older client code.
 *
 * @{
 */
#define VBGL_IOCTL_DRIVER_VERSION_INFO              VBGL_IOCTL_CODE_SIZE(0, VBGL_IOCTL_DRIVER_VERSION_INFO_SIZE)
#define VBGL_IOCTL_DRIVER_VERSION_INFO_SIZE         sizeof(VBGLIOCDRIVERVERSIONINFO)
#define VBGL_IOCTL_DRIVER_VERSION_INFO_SIZE_IN      RT_UOFFSET_AFTER(VBGLIOCDRIVERVERSIONINFO, u.In)
#define VBGL_IOCTL_DRIVER_VERSION_INFO_SIZE_OUT     sizeof(VBGLIOCDRIVERVERSIONINFO)
typedef struct VBGLIOCDRIVERVERSIONINFO
{
    /** The header. */
    VBGLREQHDR          Hdr;
    union
    {
        struct
        {
            /** The requested interface version number (VBGL_IOC_VERSION). */
            uint32_t        uReqVersion;
            /** The minimum interface version number
             * (typically the major version part of VBGL_IOC_VERSION). */
            uint32_t        uMinVersion;
            /** Reserved, MBZ. */
            uint32_t        uReserved1;
            /** Reserved, MBZ. */
            uint32_t        uReserved2;
        } In;
        struct
        {
            /** Interface version for this session (typically VBGL_IOC_VERSION). */
            uint32_t        uSessionVersion;
            /** The version of the IDC interface (VBGL_IOC_VERSION). */
            uint32_t        uDriverVersion;
            /** The SVN revision of the driver.
             * This will be set to 0 if not compiled into the driver. */
            uint32_t        uDriverRevision;
            /** Reserved \#1 (will be returned as zero until defined). */
            uint32_t        uReserved1;
            /** Reserved \#2 (will be returned as zero until defined). */
            uint32_t        uReserved2;
        } Out;
    } u;
} VBGLIOCDRIVERVERSIONINFO, RT_FAR *PVBGLIOCDRIVERVERSIONINFO;
AssertCompileSize(VBGLIOCDRIVERVERSIONINFO, 24 + 20);
#if  !defined(__GNUC__) /* Some GCC versions can't handle the complicated RT_UOFFSET_AFTER macro, it seems. */ \
  && (!defined(RT_OS_OS2) || (!defined(__IBMC__) && !defined(__IBMCPP__) && (!defined(__WATCOMC__) || !defined(__cplusplus))))
AssertCompile(VBGL_IOCTL_DRIVER_VERSION_INFO_SIZE_IN == 24 + 16);
#endif
/** @} */


/** @name VBGL_IOCTL_GET_PORT_INFO
 * Query VMMDev I/O port region and MMIO mapping address.
 * @remarks Ring-0 only.
 * @{
 */
#define VBGL_IOCTL_GET_VMMDEV_IO_INFO               VBGL_IOCTL_CODE_SIZE(1, VBGL_IOCTL_GET_VMMDEV_IO_INFO_SIZE)
#define VBGL_IOCTL_GET_VMMDEV_IO_INFO_SIZE          sizeof(VBGLIOCGETVMMDEVIOINFO)
#define VBGL_IOCTL_GET_VMMDEV_IO_INFO_SIZE_IN       sizeof(VBGLREQHDR)
#define VBGL_IOCTL_GET_VMMDEV_IO_INFO_SIZE_OUT      sizeof(VBGLIOCGETVMMDEVIOINFO)
typedef struct VBGLIOCGETVMMDEVIOINFO
{
    /** The header. */
    VBGLREQHDR  Hdr;
    union
    {
        struct
        {
            /** The MMIO mapping.  NULL if no MMIO region. */
            struct VMMDevMemory volatile RT_FAR *pvVmmDevMapping;
            /** The I/O port address. */
            RTIOPORT                        IoPort;
            /** Padding, ignore. */
            RTIOPORT                        auPadding[HC_ARCH_BITS == 64 ? 3 : 1];
        } Out;
    } u;
} VBGLIOCGETVMMDEVIOINFO, RT_FAR *PVBGLIOCGETVMMDEVIOINFO;
AssertCompileSize(VBGLIOCGETVMMDEVIOINFO, 24 + (HC_ARCH_BITS == 64 ? 16 : 8));
/** @} */


/** @name VBGL_IOCTL_VMMDEV_REQUEST
 * IOCTL to VBoxGuest to perform a VMM Device request less than 1KB in size.
 * @{
 */
#define VBGL_IOCTL_VMMDEV_REQUEST(a_cb)             VBGL_IOCTL_CODE_SIZE(2, (a_cb))
/** @} */


/** @name VBGL_IOCTL_VMMDEV_REQUEST_BIG
 * IOCTL to VBoxGuest to perform a VMM Device request that can 1KB or larger.
 * @{
 */
#define VBGL_IOCTL_VMMDEV_REQUEST_BIG               VBGL_IOCTL_CODE_BIG(3)
/** @} */

#ifdef VBOX_WITH_HGCM

/** @name VBGL_IOCTL_HGCM_CONNECT
 * Connect to a HGCM service.
 * @{ */
# define VBGL_IOCTL_HGCM_CONNECT                    VBGL_IOCTL_CODE_SIZE(4, VBGL_IOCTL_HGCM_CONNECT_SIZE)
# define VBGL_IOCTL_HGCM_CONNECT_SIZE               sizeof(VBGLIOCHGCMCONNECT)
# define VBGL_IOCTL_HGCM_CONNECT_SIZE_IN            sizeof(VBGLIOCHGCMCONNECT)
# define VBGL_IOCTL_HGCM_CONNECT_SIZE_OUT           RT_UOFFSET_AFTER(VBGLIOCHGCMCONNECT, u.Out)
typedef struct VBGLIOCHGCMCONNECT
{
    /** The header. */
    VBGLREQHDR                  Hdr;
    union
    {
        struct
        {
            HGCMServiceLocation Loc;
        } In;
        struct
        {
            uint32_t            idClient;
        } Out;
    } u;
} VBGLIOCHGCMCONNECT, RT_FAR *PVBGLIOCHGCMCONNECT;
AssertCompileSize(VBGLIOCHGCMCONNECT, 24 + 132);
#if !defined(__GNUC__)  /* Some GCC versions can't handle the complicated RT_UOFFSET_AFTER macro, it seems. */ \
  && (!defined(RT_OS_OS2) || (!defined(__IBMC__) && !defined(__IBMCPP__) && (!defined(__WATCOMC__) || !defined(__cplusplus))))
AssertCompile(VBGL_IOCTL_HGCM_CONNECT_SIZE_OUT == 24 + 4);
#endif
/** @} */


/** @name VBGL_IOCTL_HGCM_DISCONNECT
 * Disconnect from a HGCM service.
 * @{ */
# define VBGL_IOCTL_HGCM_DISCONNECT                 VBGL_IOCTL_CODE_SIZE(5, VBGL_IOCTL_HGCM_DISCONNECT_SIZE)
# define VBGL_IOCTL_HGCM_DISCONNECT_SIZE            sizeof(VBGLIOCHGCMDISCONNECT)
# define VBGL_IOCTL_HGCM_DISCONNECT_SIZE_IN         sizeof(VBGLIOCHGCMDISCONNECT)
# define VBGL_IOCTL_HGCM_DISCONNECT_SIZE_OUT        sizeof(VBGLREQHDR)
/** @note This is also used by a VbglR0 API.  */
typedef struct VBGLIOCHGCMDISCONNECT
{
    /** The header. */
    VBGLREQHDR          Hdr;
    union
    {
        struct
        {
            uint32_t    idClient;
        } In;
    } u;
} VBGLIOCHGCMDISCONNECT, RT_FAR *PVBGLIOCHGCMDISCONNECT;
AssertCompileSize(VBGLIOCHGCMDISCONNECT, 24 + 4);
/** @} */


/** @name VBGL_IOCTL_HGCM_CALL, VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA
 *
 * Make a call to a HGCM service.  There are several variations here.
 *
 * The VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA variation is for other drivers (like
 * the graphics ones) passing on requests from user land that contains user
 * data.  These calls are always interruptible.
 *
 * @{ */
# define VBGL_IOCTL_HGCM_CALL_32(a_cb)              VBGL_IOCTL_CODE_SIZE(6, (a_cb))
# define VBGL_IOCTL_HGCM_CALL_64(a_cb)              VBGL_IOCTL_CODE_SIZE(7, (a_cb))
# if ARCH_BITS == 64
#  define VBGL_IOCTL_HGCM_CALL(a_cb)                VBGL_IOCTL_HGCM_CALL_64(a_cb)
# else
#  define VBGL_IOCTL_HGCM_CALL(a_cb)                VBGL_IOCTL_HGCM_CALL_32(a_cb)
# endif
# define VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA(a_cb)  VBGL_IOCTL_CODE_SIZE(8, (a_cb))
/** @} */


/** @name VBGL_IOCTL_IDC_HGCM_FAST_CALL
 *
 * Variant of VBGL_IOCTL_HGCM_CALL for drivers that submits the request as-is to
 * the host and handles the waiting, the caller does all the rest.
 *
 * @note ring-0 only.
 * @note Size is not encoded in the I/O control code.
 * @{
 */
#define VBGL_IOCTL_IDC_HGCM_FAST_CALL               VBGL_IOCTL_CODE_SIZE(61, sizeof(VBGLIOCIDCHGCMFASTCALL))
#define VBGL_IOCTL_IDC_HGCM_FAST_CALL_SIZE(a_cb)    (a_cb)
#define VBGL_IOCTL_IDC_HGCM_FAST_CALL_SIZE_IN(a_cb) (a_cb)
#define VBGL_IOCTL_IDC_HGCM_FAST_CALL_SIZE_OUT(a_cb) (a_cb)
#pragma pack(4) /* Want it to fit nicely with the 44 byte VMMDevHGCMCall and optimally align 64-bit parameters structures.  */
typedef struct VBGLIOCIDCHGCMFASTCALL
{
    /** The header. */
    VBGLREQHDR      Hdr;
    /** The physical address of the following VMMDevHGCMCall structure. */
    RTGCPHYS32      GCPhysReq;
    /** Set if interruptible. */
    bool            fInterruptible;
    /** Reserved. */
    uint8_t         abReserved0[3];
    uint64_t        uTimestamp[2];
    uint8_t         abReserved1[4];
    /* After this structure follows a VMMDevHGCMCall strcuture (44 bytes), then
       zero or more HGCMFunctionParameter structures (12 or 16 bytes), and finally
       page lists and embedded buffers. */
} VBGLIOCIDCHGCMFASTCALL, RT_FAR *PVBGLIOCIDCHGCMFASTCALL;
#pragma pack()
AssertCompileSize(VBGLIOCIDCHGCMFASTCALL, /* 24 + 4 + 1 + 3 + 2*8 + 4 = 0x34 (52) = */ 0x34);

/**
 * Macro for initializing VBGLIOCIDCHGCMFASTCALL and the following
 * VMMDevHGCMCall structures.
 *
 * @param   a_pHdr      The request header to initialize.
 * @param   a_HdrPhys   The 32-bit physical address corresponding to @a a_pHdr.
 * @param   a_pCall     Pointer to the VMMDevHGCMCall structure.
 * @param   a_idClient  The HGCM client ID.
 * @param   a_uFunction The HGCM function number.
 * @param   a_cParms    The number of parameters following @a a_pCall.
 * @param   a_cbReq     The size of the whole request.
 */
#define VBGLIOCIDCHGCMFASTCALL_INIT(a_pHdr, a_HdrPhys, a_pCall, a_idClient, a_uFunction, a_cParms, a_cbReq) \
    do { \
        Assert((uintptr_t)(a_pHdr) + sizeof(VBGLIOCIDCHGCMFASTCALL) == (uintptr_t)(a_pCall)); \
        VBGLREQHDR_INIT_EX(&(a_pHdr)->Hdr, a_cbReq, a_cbReq); \
        pReq->Hdr.GCPhysReq      = (a_HdrPhys) + sizeof(VBGLIOCIDCHGCMFASTCALL); \
        pReq->Hdr.fInterruptible = false; \
        \
        (a_pCall)->header.header.size       = (a_cbReq) - sizeof(VBGLIOCIDCHGCMFASTCALL); \
        (a_pCall)->header.header.version    = VBGLREQHDR_VERSION; \
        (a_pCall)->header.header.requestType= (ARCH_BITS == 64 ? VMMDevReq_HGCMCall64 : VMMDevReq_HGCMCall32); \
        (a_pCall)->header.header.rc         = VERR_INTERNAL_ERROR; \
        (a_pCall)->header.header.reserved1  = 0; \
        (a_pCall)->header.header.fRequestor = VMMDEV_REQUESTOR_KERNEL        | VMMDEV_REQUESTOR_USR_DRV_OTHER \
                                            | VMMDEV_REQUESTOR_CON_DONT_KNOW | VMMDEV_REQUESTOR_TRUST_NOT_GIVEN; \
        (a_pCall)->header.fu32Flags         = 0; \
        (a_pCall)->header.result            = VERR_INTERNAL_ERROR; \
        (a_pCall)->u32ClientID              = (a_idClient); \
        (a_pCall)->u32Function              = (a_uFunction); \
        (a_pCall)->cParms                   = (a_cParms); \
    } while (0)


/** @} */

#endif /* VBOX_WITH_HGCM */


/** @name VBGL_IOCTL_LOG
 * IOCTL to VBoxGuest to perform backdoor logging.
 * @{ */
#define VBOXGUEST_IOCTL_LOG(Size)
#define VBGL_IOCTL_LOG(a_cchMsg)                    VBGL_IOCTL_CODE_BIG(9)
#define VBGL_IOCTL_LOG_SIZE(a_cchMsg)               (sizeof(VBGLREQHDR) + (a_cchMsg) + 1)
#define VBGL_IOCTL_LOG_SIZE_IN(a_cchMsg)            (sizeof(VBGLREQHDR) + (a_cchMsg) + 1)
#define VBGL_IOCTL_LOG_SIZE_OUT                     sizeof(VBGLREQHDR)
typedef struct VBGLIOCLOG
{
    /** The header. */
    VBGLREQHDR                      Hdr;
    union
    {
        struct
        {
            /** The log message.
             * The length is determined from the input size and zero termination. */
            char                    szMsg[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
        } In;
    } u;
} VBGLIOCLOG, RT_FAR *PVBGLIOCLOG;
/** @} */


/** @name VBGL_IOCTL_WAIT_FOR_EVENTS
 * Wait for a VMMDev host event notification.
 * @{
 */
#define VBGL_IOCTL_WAIT_FOR_EVENTS                  VBGL_IOCTL_CODE_SIZE(10, VBGL_IOCTL_WAIT_FOR_EVENTS_SIZE)
#define VBGL_IOCTL_WAIT_FOR_EVENTS_SIZE             sizeof(VBGLIOCWAITFOREVENTS)
#define VBGL_IOCTL_WAIT_FOR_EVENTS_SIZE_IN          sizeof(VBGLIOCWAITFOREVENTS)
#define VBGL_IOCTL_WAIT_FOR_EVENTS_SIZE_OUT         RT_UOFFSET_AFTER(VBGLIOCWAITFOREVENTS, u.Out)
typedef struct VBGLIOCWAITFOREVENTS
{
    /** The header. */
    VBGLREQHDR                      Hdr;
    union
    {
        struct
        {
            /** Timeout in milliseconds. */
            uint32_t                cMsTimeOut;
            /** Events to wait for. */
            uint32_t                fEvents;
        } In;
        struct
        {
            /** Events that occurred. */
            uint32_t                fEvents;
        } Out;
    } u;
} VBGLIOCWAITFOREVENTS, RT_FAR *PVBGLIOCWAITFOREVENTS;
AssertCompileSize(VBGLIOCWAITFOREVENTS, 24 + 8);
/** @} */


/** @name VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS
 * IOCTL to VBoxGuest to interrupt (cancel) any pending
 * VBGL_IOCTL_WAIT_FOR_EVENTS and return.
 *
 * Handled inside the guest additions and not seen by the host at all.
 * After calling this, VBGL_IOCTL_WAIT_FOR_EVENTS should no longer be called in
 * the same session.  At the time of writing this is not enforced; at the time
 * of reading it may be.
 * @see VBGL_IOCTL_WAIT_FOR_EVENTS
 *
 * @{
 */
#define VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS    VBGL_IOCTL_CODE_SIZE(11, VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS_SIZE)
#define VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS_SIZE       sizeof(VBGLREQHDR)
#define VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS_SIZE_IN    sizeof(VBGLREQHDR)
#define VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS_SIZE_OUT   sizeof(VBGLREQHDR)
/** @} */


/** @name VBGL_IOCTL_CHANGE_FILTER_MASK
 * IOCTL to VBoxGuest to control the event filter mask.
 * @{ */
#define VBGL_IOCTL_CHANGE_FILTER_MASK               VBGL_IOCTL_CODE_SIZE(12, VBGL_IOCTL_CHANGE_FILTER_MASK_SIZE)
#define VBGL_IOCTL_CHANGE_FILTER_MASK_SIZE          sizeof(VBGLIOCCHANGEFILTERMASK)
#define VBGL_IOCTL_CHANGE_FILTER_MASK_SIZE_IN       sizeof(VBGLIOCCHANGEFILTERMASK)
#define VBGL_IOCTL_CHANGE_FILTER_MASK_SIZE_OUT      sizeof(VBGLREQHDR)
typedef struct VBGLIOCCHANGEFILTERMASK
{
    /** The header. */
    VBGLREQHDR                      Hdr;
    union
    {
        struct
        {
            /** Flags to set. */
            uint32_t fOrMask;
            /** Flags to remove. */
            uint32_t fNotMask;
        } In;
    } u;
} VBGLIOCCHANGEFILTERMASK, RT_FAR *PVBGLIOCCHANGEFILTERMASK;
AssertCompileSize(VBGLIOCCHANGEFILTERMASK, 24 + 8);
/** @} */


/** @name VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES
 * IOCTL to for acquiring and releasing guest capabilities.
 *
 * This is used for multiple purposes:
 * 1. By doing @a acquire r3 client application (e.g. VBoxTray) claims it will
 *    use the given session for performing operations like @a seamless or
 *    @a auto-resize, thus, if the application terminates, the driver will
 *    automatically cleanup the caps reported to host, so that host knows guest
 *    does not support them anymore
 * 2. In a multy-user environment this will not allow r3 applications (like
 *    VBoxTray) running in different user sessions simultaneously to interfere
 *    with each other.  An r3 client application (like VBoxTray) is responsible
 *    for Acquiring/Releasing caps properly as needed.
 *
 *
 * VERR_RESOURCE_BUSY is returned if any capabilities in the fOrMask are
 * currently acquired by some other VBoxGuest session.
 *
 * @todo Rename to VBGL_IOCTL_ACQUIRE_GUEST_CAPS
 * @{
 */
#define VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES           VBGL_IOCTL_CODE_SIZE(13, VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES_SIZE)
#define VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES_SIZE      sizeof(VBGLIOCACQUIREGUESTCAPS)
#define VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES_SIZE_IN   sizeof(VBGLIOCACQUIREGUESTCAPS)
#define VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES_SIZE_OUT  sizeof(VBGLREQHDR)

/** Default operation (full acquire/release). */
#define VBGL_IOC_AGC_FLAGS_DEFAULT                      UINT32_C(0x00000000)
/** Configures VBoxGuest to use the specified caps in Acquire mode, w/o making
 * any caps acquisition/release.  This is only possible to set acquire mode for
 * caps, but not clear it, so fNotMask is ignored when this flag is set. */
#define VBGL_IOC_AGC_FLAGS_CONFIG_ACQUIRE_MODE          UINT32_C(0x00000001)
/** Valid flag mask. */
#define VBGL_IOC_AGC_FLAGS_VALID_MASK                   UINT32_C(0x00000001)

typedef struct VBGLIOCACQUIREGUESTCAPS
{
    /** The header. */
    VBGLREQHDR              Hdr;
    union
    {
        struct
        {
            /** Acquire flags (VBGL_IOC_AGC_FLAGS_XXX). */
            uint32_t        fFlags;
            /** Guest capabilities to acquire (VMMDEV_GUEST_SUPPORTS_XXX). */
            uint32_t        fOrMask;
            /** Guest capabilities to release (VMMDEV_GUEST_SUPPORTS_XXX). */
            uint32_t        fNotMask;
        } In;
    } u;
} VBGLIOCACQUIREGUESTCAPS, RT_FAR *PVBGLIOCACQUIREGUESTCAPS;
AssertCompileSize(VBGLIOCACQUIREGUESTCAPS, 24 + 12);
/** @} */


/** @name VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES
 * IOCTL to VBoxGuest to set guest capabilities.
 * @{ */
#define VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES            VBGL_IOCTL_CODE_SIZE(14, VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES_SIZE)
#define VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES_SIZE       sizeof(VBGLIOCSETGUESTCAPS)
#define VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES_SIZE_IN    sizeof(VBGLIOCSETGUESTCAPS)
#define VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES_SIZE_OUT   sizeof(VBGLIOCSETGUESTCAPS)
typedef struct VBGLIOCSETGUESTCAPS
{
    /** The header. */
    VBGLREQHDR              Hdr;
    union
    {
        struct
        {
            /** The capabilities to set (VMMDEV_GUEST_SUPPORTS_XXX). */
            uint32_t        fOrMask;
            /** The capabilities to drop (VMMDEV_GUEST_SUPPORTS_XXX). */
            uint32_t        fNotMask;
        } In;
        struct
        {
            /** The capabilities held by the session after the call (VMMDEV_GUEST_SUPPORTS_XXX). */
            uint32_t        fSessionCaps;
            /** The capabilities for all the sessions after the call (VMMDEV_GUEST_SUPPORTS_XXX). */
            uint32_t        fGlobalCaps;
        } Out;
    } u;
} VBGLIOCSETGUESTCAPS, RT_FAR *PVBGLIOCSETGUESTCAPS;
AssertCompileSize(VBGLIOCSETGUESTCAPS, 24 + 8);
typedef VBGLIOCSETGUESTCAPS VBoxGuestSetCapabilitiesInfo;
/** @} */


/** @name VBGL_IOCTL_SET_MOUSE_STATUS
 * IOCTL to VBoxGuest to update the mouse status features.
 * @{ */
#define VBGL_IOCTL_SET_MOUSE_STATUS                 VBGL_IOCTL_CODE_SIZE(15, VBGL_IOCTL_SET_MOUSE_STATUS_SIZE)
#define VBGL_IOCTL_SET_MOUSE_STATUS_SIZE            sizeof(VBGLIOCSETMOUSESTATUS)
#define VBGL_IOCTL_SET_MOUSE_STATUS_SIZE_IN         sizeof(VBGLIOCSETMOUSESTATUS)
#define VBGL_IOCTL_SET_MOUSE_STATUS_SIZE_OUT        sizeof(VBGLREQHDR)
typedef struct VBGLIOCSETMOUSESTATUS
{
    /** The header. */
    VBGLREQHDR          Hdr;
    union
    {
        struct
        {
            /** Mouse status flags (VMMDEV_MOUSE_XXX). */
            uint32_t    fStatus;
        } In;
    } u;
} VBGLIOCSETMOUSESTATUS, RT_FAR *PVBGLIOCSETMOUSESTATUS;
/** @} */


/** @name VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK
 *
 * IOCTL to for setting the mouse driver callback.
 * @note The callback will be called in interrupt context with the VBoxGuest
 *       device event spinlock held.
 * @note ring-0 only.
 *
 * @{ */
#define VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK            VBGL_IOCTL_CODE_SIZE(16, VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK_SIZE)
#define VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK_SIZE       sizeof(VBGLIOCSETMOUSENOTIFYCALLBACK)
#define VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK_SIZE_IN    sizeof(VBGLIOCSETMOUSENOTIFYCALLBACK)
#define VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK_SIZE_OUT   sizeof(VBGLREQHDR)
typedef struct VBGLIOCSETMOUSENOTIFYCALLBACK
{
    /** The header. */
    VBGLREQHDR              Hdr;
    union
    {
        struct
        {
            /** Mouse notification callback function. */
            PFNVBOXGUESTMOUSENOTIFY     pfnNotify;
            /** The callback argument. */
            void                RT_FAR *pvUser;
        } In;
    } u;
} VBGLIOCSETMOUSENOTIFYCALLBACK, RT_FAR *PVBGLIOCSETMOUSENOTIFYCALLBACK;
/** @} */


/** @name VBGL_IOCTL_CHECK_BALLOON
 * IOCTL to VBoxGuest to check memory ballooning.
 *
 * The guest kernel module / device driver will ask the host for the current size of
 * the balloon and adjust the size. Or it will set fHandledInR0 = false and R3 is
 * responsible for allocating memory and calling R0 (VBGL_IOCTL_CHANGE_BALLOON).
 * @{ */
#define VBGL_IOCTL_CHECK_BALLOON                    VBGL_IOCTL_CODE_SIZE(17, VBGL_IOCTL_CHECK_BALLOON_SIZE)
#define VBGL_IOCTL_CHECK_BALLOON_SIZE               sizeof(VBGLIOCCHECKBALLOON)
#define VBGL_IOCTL_CHECK_BALLOON_SIZE_IN            sizeof(VBGLREQHDR)
#define VBGL_IOCTL_CHECK_BALLOON_SIZE_OUT           sizeof(VBGLIOCCHECKBALLOON)
typedef struct VBGLIOCCHECKBALLOON
{
    /** The header. */
    VBGLREQHDR                      Hdr;
    union
    {
        struct
        {
            /** The size of the balloon in chunks of 1MB. */
            uint32_t                cBalloonChunks;
            /** false = handled in R0, no further action required.
             *   true = allocate balloon memory in R3. */
            bool                    fHandleInR3;
            /** Explicit padding, please ignore. */
            bool                    afPadding[3];
        } Out;
    } u;
} VBGLIOCCHECKBALLOON, RT_FAR *PVBGLIOCCHECKBALLOON;
AssertCompileSize(VBGLIOCCHECKBALLOON, 24 + 8);
typedef VBGLIOCCHECKBALLOON VBoxGuestCheckBalloonInfo;
/** @} */


/** @name VBGL_IOCTL_CHANGE_BALLOON
 * IOCTL to VBoxGuest to supply or revoke one chunk for ballooning.
 *
 * The guest kernel module / device driver will lock down supplied memory or
 * unlock reclaimed memory and then forward the physical addresses of the
 * changed balloon chunk to the host.
 *
 * @{ */
#define VBGL_IOCTL_CHANGE_BALLOON                   VBGL_IOCTL_CODE_SIZE(18, VBGL_IOCTL_CHANGE_BALLOON_SIZE)
#define VBGL_IOCTL_CHANGE_BALLOON_SIZE              sizeof(VBGLIOCCHANGEBALLOON)
#define VBGL_IOCTL_CHANGE_BALLOON_SIZE_IN           sizeof(VBGLIOCCHANGEBALLOON)
#define VBGL_IOCTL_CHANGE_BALLOON_SIZE_OUT          sizeof(VBGLREQHDR)
typedef struct VBGLIOCCHANGEBALLOON
{
    /** The header. */
    VBGLREQHDR          Hdr;
    union
    {
        struct
        {
            /** Address of the chunk (user space address). */
            RTR3PTR     pvChunk;
            /** Explicit alignment padding, MBZ. */
            uint8_t     abPadding[ARCH_BITS == 64 ? 0 + 7 : 4 + 7];
            /** true = inflate, false = deflate. */
            bool        fInflate;
        } In;
    } u;
} VBGLIOCCHANGEBALLOON, RT_FAR *PVBGLIOCCHANGEBALLOON;
AssertCompileSize(VBGLIOCCHANGEBALLOON, 24+16);
/** @} */


/** @name VBGL_IOCTL_WRITE_CORE_DUMP
 * IOCTL to VBoxGuest to write guest core.
 * @{ */
#define VBGL_IOCTL_WRITE_CORE_DUMP                  VBGL_IOCTL_CODE_SIZE(19, VBGL_IOCTL_WRITE_CORE_DUMP_SIZE)
#define VBGL_IOCTL_WRITE_CORE_DUMP_SIZE             sizeof(VBGLIOCWRITECOREDUMP)
#define VBGL_IOCTL_WRITE_CORE_DUMP_SIZE_IN          sizeof(VBGLIOCWRITECOREDUMP)
#define VBGL_IOCTL_WRITE_CORE_DUMP_SIZE_OUT         sizeof(VBGLREQHDR)
typedef struct VBGLIOCWRITECOREDUMP
{
    /** The header. */
    VBGLREQHDR          Hdr;
    union
    {
        struct
        {
            /** Flags (reserved, MBZ). */
            uint32_t    fFlags;
        } In;
    } u;
} VBGLIOCWRITECOREDUMP, RT_FAR *PVBGLIOCWRITECOREDUMP;
AssertCompileSize(VBGLIOCWRITECOREDUMP, 24 + 4);
typedef VBGLIOCWRITECOREDUMP VBoxGuestWriteCoreDump;
/** @} */


#ifdef VBOX_WITH_DPC_LATENCY_CHECKER
/** @name VBGL_IOCTL_DPC_LATENCY_CHECKER
 * IOCTL to VBoxGuest to perform DPC latency tests, printing the result in
 * the release log on the host.  Takes no data, returns no data.
 * @{ */
# define VBGL_IOCTL_DPC_LATENCY_CHECKER             VBGL_IOCTL_CODE_SIZE(20, VBGL_IOCTL_DPC_LATENCY_CHECKER_SIZE)
# define VBGL_IOCTL_DPC_LATENCY_CHECKER_SIZE        sizeof(VBGLREQHDR)
# define VBGL_IOCTL_DPC_LATENCY_CHECKER_SIZE_IN     sizeof(VBGLREQHDR)
# define VBGL_IOCTL_DPC_LATENCY_CHECKER_SIZE_OUT    sizeof(VBGLREQHDR)
/** @} */
#endif


#ifdef RT_OS_OS2
/**
 * The data buffer layout for the IDC entry point (AttachDD).
 *
 * @remark  This is defined in multiple 16-bit headers / sources.
 *          Some places it's called VBGOS2IDC to short things a bit.
 */
typedef struct VBGLOS2ATTACHDD
{
    /** VBGL_IOC_VERSION. */
    uint32_t u32Version;
    /** Opaque session handle. */
    uint32_t u32Session;

    /**
     * The 32-bit service entry point.
     *
     * @returns VBox status code.
     * @param   u32Session          The session handle (PVBOXGUESTSESSION).
     * @param   iFunction           The requested function.
     * @param   pReqHdr             The input/output data buffer.  The caller
     *                              ensures that this cannot be swapped out, or that
     *                              it's acceptable to take a page in fault in the
     *                              current context.  If the request doesn't take
     *                              input or produces output, apssing NULL is okay.
     * @param   cbReq               The size of the data buffer.
     */
# if ARCH_BITS == 32 || defined(DOXYGEN_RUNNING)
    DECLCALLBACKMEMBER(int, pfnServiceEP,(uint32_t u32Session, unsigned iFunction, PVBGLREQHDR pReqHdr, size_t cbReq));
# else
    uint32_t pfnServiceEP;
#endif

    /** The 16-bit service entry point for C code (cdecl).
     *
     * It's the same as the 32-bit entry point, but the types has
     * changed to 16-bit equivalents.
     *
     * @code
     * int far cdecl
     * VBoxGuestOs2IDCService16(uint32_t u32Session, uint16_t iFunction,
     *                          PVBGLREQHDR fpvData, uint16_t cbData);
     * @endcode
     */
# if ARCH_BITS == 16 || defined(DOXYGEN_RUNNING)
    DECLCALLBACKMEMBER(int, fpfnServiceEP,(uint32_t u32Session, uint16_t iFunction, PVBGLREQHDR fpvData, uint16_t cbData));
# else
    RTFAR16 fpfnServiceEP;
# endif

    /** The 16-bit service entry point for Assembly code (register).
     *
     * This is just a wrapper around fpfnServiceEP to simplify calls
     * from 16-bit assembly code.
     *
     * @returns (e)ax: VBox status code; cx: The amount of data returned.
     *
     * @param   u32Session          eax   - The above session handle.
     * @param   iFunction           dl    - The requested function.
     * @param   pvData              es:bx - The input/output data buffer.
     * @param   cbData              cx    - The size of the data buffer.
     */
    RTFAR16 fpfnServiceAsmEP;
} VBGLOS2ATTACHDD;
/** Pointer to VBOXGUESTOS2IDCCONNECT buffer. */
typedef VBGLOS2ATTACHDD RT_FAR *PVBGLOS2ATTACHDD;

/**
 * Prototype for the 16-bit callback returned by AttachDD on OS/2.
 * @param   pAttachInfo     Pointer to structure to fill in.
 */
# if defined(__IBMC__) || defined(__IBMCPP__)
typedef void (* __cdecl RT_FAR_CODE PFNVBGLOS2ATTACHDD)(PVBGLOS2ATTACHDD pAttachInfo);
# else
typedef void (__cdecl RT_FAR_CODE *PFNVBGLOS2ATTACHDD)(PVBGLOS2ATTACHDD pAttachInfo);
# endif
#endif /* RT_OS_OS2 */


/** @name VBGL_IOCL_IDC_CONNECT
 * IDC client connect request.
 *
 * On platforms other than Windows and OS/2, this will also create a kernel
 * session for the caller.
 *
 * @note ring-0 only.
 * @{
 */
#define VBGL_IOCTL_IDC_CONNECT                      VBGL_IOCTL_CODE_SIZE(63, VBGL_IOCTL_IDC_CONNECT_SIZE)
#define VBGL_IOCTL_IDC_CONNECT_SIZE                 sizeof(VBGLIOCIDCCONNECT)
#define VBGL_IOCTL_IDC_CONNECT_SIZE_IN              RT_UOFFSET_AFTER(VBGLIOCIDCCONNECT, u.In)
#define VBGL_IOCTL_IDC_CONNECT_SIZE_OUT             sizeof(VBGLIOCIDCCONNECT)
typedef struct VBGLIOCIDCCONNECT
{
    /** The header. */
    VBGLREQHDR          Hdr;
    /** The payload union. */
    union
    {
        struct
        {
            /** VBGL_IOCTL_IDC_CONNECT_MAGIC_COOKIE. */
            uint32_t        u32MagicCookie;
            /** The desired version of the I/O control interface (VBGL_IOC_VERSION). */
            uint32_t        uReqVersion;
            /** The minimum version of the I/O control interface (VBGL_IOC_VERSION). */
            uint32_t        uMinVersion;
            /** Reserved, MBZ. */
            uint32_t        uReserved;
        } In;
        struct
        {
            /** The session handle (opaque). */
#if ARCH_BITS >= 32
            void    RT_FAR *pvSession;
#else
            uint32_t        pvSession;
#endif
            /** The version of the I/O control interface for this session
             * (typically VBGL_IOC_VERSION). */
            uint32_t        uSessionVersion;
            /** The I/O control interface version for of the driver (VBGL_IOC_VERSION). */
            uint32_t        uDriverVersion;
            /** The SVN revision of the driver.
             * This will be set to 0 if not compiled into the driver. */
            uint32_t        uDriverRevision;
            /** Reserved \#1 (will be returned as zero until defined). */
            uint32_t        uReserved1;
            /** Reserved \#2 (will be returned as NULL until defined). */
            void    RT_FAR *pvReserved2;
        } Out;
    } u;
} VBGLIOCIDCCONNECT, RT_FAR *PVBGLIOCIDCCONNECT;
AssertCompileSize(VBGLIOCIDCCONNECT, 24 + 16 + (ARCH_BITS == 64 ? 8 : 4) * 2);
#if  !defined(__GNUC__) /* Some GCC versions can't handle the complicated RT_UOFFSET_AFTER macro, it seems. */ \
  && (!defined(RT_OS_OS2) || (!defined(__IBMC__) && !defined(__IBMCPP__) && (!defined(__WATCOMC__) || !defined(__cplusplus))))
AssertCompile(VBGL_IOCTL_IDC_CONNECT_SIZE_IN == 24 + 16);
#endif
#define VBGL_IOCTL_IDC_CONNECT_MAGIC_COOKIE         UINT32_C(0x55aa4d5a) /**< Magic value for doing an IDC connect. */
/** @} */


/** @name VBGL_IOCL_IDC_DISCONNECT
 * IDC client disconnect request.
 *
 * This will destroy the kernel session associated with the IDC connection.
 *
 * @note ring-0 only.
 * @{
 */
#define VBGL_IOCTL_IDC_DISCONNECT                   VBGL_IOCTL_CODE_SIZE(62, VBGL_IOCTL_IDC_DISCONNECT_SIZE)
#define VBGL_IOCTL_IDC_DISCONNECT_SIZE              sizeof(VBGLIOCIDCDISCONNECT)
#define VBGL_IOCTL_IDC_DISCONNECT_SIZE_IN           sizeof(VBGLIOCIDCDISCONNECT)
#define VBGL_IOCTL_IDC_DISCONNECT_SIZE_OUT          sizeof(VBGLREQHDR)
typedef struct VBGLIOCIDCDISCONNECT
{
    /** The header. */
    VBGLREQHDR          Hdr;
    union
    {
        struct
        {
            /** The session handle for platforms where this is needed. */
#if ARCH_BITS >= 32
            void RT_FAR *pvSession;
#else
            uint32_t     pvSession;
#endif
        } In;
    } u;
} VBGLIOCIDCDISCONNECT, RT_FAR *PVBGLIOCIDCDISCONNECT;
AssertCompileSize(VBGLIOCIDCDISCONNECT, 24 + (ARCH_BITS == 64 ? 8 : 4));
/** @} */


#if !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2)
RT_C_DECLS_BEGIN
/**
 * The VBoxGuest IDC entry point.
 *
 * @returns VBox status code.
 * @param   pvSession   The session.
 * @param   uReq        The request code.
 * @param   pReqHdr     The request.
 * @param   cbReq       The request size.
 */
int VBOXCALL VBoxGuestIDC(void RT_FAR *pvSession, uintptr_t uReq, PVBGLREQHDR pReqHdr, size_t cbReq);
RT_C_DECLS_END
#endif


#if defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

/* Private IOCtls between user space and the kernel video driver.  DRM private
 * IOCtls always have the type 'd' and a number between 0x40 and 0x99 (0x9F?) */

# define VBOX_DRM_IOCTL(a) (0x40 + DRM_VBOX_ ## a)

/** Stop using HGSMI in the kernel driver until it is re-enabled, so that a
 *  user-space driver can use it.  It must be re-enabled before the kernel
 *  driver can be used again in a sensible way. */
/** @note These IOCtls was removed from the code, but are left here as
 * templates as we may need similar ones in future. */
# define DRM_VBOX_DISABLE_HGSMI    0
# define DRM_IOCTL_VBOX_DISABLE_HGSMI    VBOX_DRM_IOCTL(DISABLE_HGSMI)
# define VBOXVIDEO_IOCTL_DISABLE_HGSMI   _IO('d', DRM_IOCTL_VBOX_DISABLE_HGSMI)
/** Enable HGSMI in the kernel driver after it was previously disabled. */
# define DRM_VBOX_ENABLE_HGSMI     1
# define DRM_IOCTL_VBOX_ENABLE_HGSMI     VBOX_DRM_IOCTL(ENABLE_HGSMI)
# define VBOXVIDEO_IOCTL_ENABLE_HGSMI    _IO('d', DRM_IOCTL_VBOX_ENABLE_HGSMI)

#endif /* RT_OS_LINUX || RT_OS_SOLARIS || RT_OS_FREEBSD */

#endif /* !defined(IN_RC) && !defined(IN_RING0_AGNOSTIC) && !defined(IPRT_NO_CRT) */

/** @} */

/** @} */
#endif /* !VBOX_INCLUDED_VBoxGuest_h */