1012 lines
39 KiB
C
1012 lines
39 KiB
C
/** @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 */
|
|
|