VirtualBox

source: vbox/trunk/include/VBox/VBoxGuest.h@ 8155

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

The Big Sun Rebranding Header Change
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 49.3 KB
Line 
1/** @file
2 * VBoxGuest - VirtualBox Guest Additions interface
3 */
4
5/*
6 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 *
25 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
26 * Clara, CA 95054 USA or visit http://www.sun.com if you need
27 * additional information or have any questions.
28 */
29
30#ifndef ___VBox_VBoxGuest_h
31#define ___VBox_VBoxGuest_h
32
33#include <iprt/cdefs.h>
34#include <iprt/types.h>
35#include <VBox/err.h>
36#include <VBox/ostypes.h>
37
38/*******************************************************************************
39* Defined Constants And Macros *
40*******************************************************************************/
41
42/** @todo The following is a temporary fix for the problem of accessing
43 hypervisor pointers from within guest additions */
44
45/** Hypervisor linear pointer size type */
46typedef RTGCPTR vmmDevHypPtr;
47/** Hypervisor physical pointer size type */
48typedef RTGCPHYS32 vmmDevHypPhys;
49
50#if defined(RT_OS_LINUX)
51/** The support device name. */
52# define VBOXGUEST_DEVICE_NAME "/dev/vboxadd"
53
54#elif defined(RT_OS_OS2)
55/** The support device name. */
56# define VBOXGUEST_DEVICE_NAME "\\Dev\\VBoxGst$"
57
58#elif defined(RT_OS_SOLARIS)
59/** The support device name. */
60# define VBOXGUEST_DEVICE_NAME "/devices/pci@0,0/pci80ee,cafe@4:vboxguest"
61
62#elif defined(RT_OS_WINDOWS)
63/** The support service name. */
64# define VBOXGUEST_SERVICE_NAME "VBoxGuest"
65/** Win32 Device name. */
66# define VBOXGUEST_DEVICE_NAME "\\\\.\\VBoxGuest"
67/** Global name for Win2k+ */
68# define VBOXGUEST_DEVICE_NAME_GLOBAL "\\\\.\\Global\\VBoxGuest"
69/** Win32 driver name */
70# define VBOXGUEST_DEVICE_NAME_NT L"\\Device\\VBoxGuest"
71/** device name */
72# define VBOXGUEST_DEVICE_NAME_DOS L"\\DosDevices\\VBoxGuest"
73
74#elif defined(RT_OS_FREEBSD)
75/** The support device name. */
76# define VBOXGUEST_DEVICE_NAME "/dev/vboxguest"
77
78#else
79/* PORTME */
80#endif
81
82/** VirtualBox vendor ID */
83#define VBOX_PCI_VENDORID (0x80ee)
84
85/** VMMDev PCI card identifiers */
86#define VMMDEV_VENDORID VBOX_PCI_VENDORID
87#define VMMDEV_DEVICEID (0xcafe)
88
89/** VirtualBox graphics card identifiers */
90#define VBOX_VENDORID VBOX_PCI_VENDORID
91#define VBOX_VESA_VENDORID VBOX_PCI_VENDORID
92#define VBOX_DEVICEID (0xbeef)
93#define VBOX_VESA_DEVICEID (0xbeef)
94
95/**
96 * VBoxGuest port definitions
97 * @{
98 */
99
100/** guest can (== wants to) handle absolute coordinates */
101#define VBOXGUEST_MOUSE_GUEST_CAN_ABSOLUTE RT_BIT(0)
102/** host can (== wants to) send absolute coordinates */
103#define VBOXGUEST_MOUSE_HOST_CAN_ABSOLUTE RT_BIT(1)
104/** guest can *NOT* switch to software cursor and therefore depends on the host cursor */
105#define VBOXGUEST_MOUSE_GUEST_NEEDS_HOST_CURSOR RT_BIT(2)
106/** host does NOT provide support for drawing the cursor itself (e.g. L4 console) */
107#define VBOXGUEST_MOUSE_HOST_CANNOT_HWPOINTER RT_BIT(3)
108
109/** fictive start address of the hypervisor physical memory for MmMapIoSpace */
110#define HYPERVISOR_PHYSICAL_START 0xf8000000
111
112/*
113 * VMMDev Generic Request Interface
114 */
115
116/** port for generic request interface */
117#define PORT_VMMDEV_REQUEST_OFFSET 0
118
119/** Current version of the VMMDev interface.
120 *
121 * Additions are allowed to work only if
122 * additions_major == vmmdev_current && additions_minor <= vmmdev_current.
123 * Additions version is reported to host (VMMDev) by VMMDevReq_ReportGuestInfo.
124 *
125 * @remark These defines also live in the 16-bit and assembly versions of this header.
126 */
127#define VMMDEV_VERSION 0x00010004
128#define VMMDEV_VERSION_MAJOR (VMMDEV_VERSION >> 16)
129#define VMMDEV_VERSION_MINOR (VMMDEV_VERSION & 0xffff)
130
131/* Maximum request packet size */
132#define VMMDEV_MAX_VMMDEVREQ_SIZE _1M
133
134/**
135 * VMMDev request types.
136 * @note when updating this, adjust vmmdevGetRequestSize() as well
137 */
138typedef enum
139{
140 VMMDevReq_InvalidRequest = 0,
141 VMMDevReq_GetMouseStatus = 1,
142 VMMDevReq_SetMouseStatus = 2,
143 VMMDevReq_SetPointerShape = 3,
144 /** @todo implement on host side */
145 VMMDevReq_GetHostVersion = 4,
146 VMMDevReq_Idle = 5,
147 VMMDevReq_GetHostTime = 10,
148 VMMDevReq_GetHypervisorInfo = 20,
149 VMMDevReq_SetHypervisorInfo = 21,
150 VMMDevReq_SetPowerStatus = 30,
151 VMMDevReq_AcknowledgeEvents = 41,
152 VMMDevReq_CtlGuestFilterMask = 42,
153 VMMDevReq_ReportGuestInfo = 50,
154 VMMDevReq_GetDisplayChangeRequest = 51,
155 VMMDevReq_VideoModeSupported = 52,
156 VMMDevReq_GetHeightReduction = 53,
157 VMMDevReq_GetDisplayChangeRequest2 = 54,
158 VMMDevReq_ReportGuestCapabilities = 55,
159 VMMDevReq_SetGuestCapabilities = 56,
160#ifdef VBOX_HGCM
161 VMMDevReq_HGCMConnect = 60,
162 VMMDevReq_HGCMDisconnect = 61,
163 VMMDevReq_HGCMCall = 62,
164#endif
165 VMMDevReq_VideoAccelEnable = 70,
166 VMMDevReq_VideoAccelFlush = 71,
167 VMMDevReq_VideoSetVisibleRegion = 72,
168 VMMDevReq_GetSeamlessChangeRequest = 73,
169 VMMDevReq_QueryCredentials = 100,
170 VMMDevReq_ReportCredentialsJudgement = 101,
171 VMMDevReq_ReportGuestStats = 110,
172 VMMDevReq_GetMemBalloonChangeRequest = 111,
173 VMMDevReq_GetStatisticsChangeRequest = 112,
174 VMMDevReq_ChangeMemBalloon = 113,
175 VMMDevReq_GetVRDPChangeRequest = 150,
176 VMMDevReq_LogString = 200,
177 VMMDevReq_SizeHack = 0x7fffffff
178} VMMDevRequestType;
179
180/** Version of VMMDevRequestHeader structure. */
181#define VMMDEV_REQUEST_HEADER_VERSION (0x10001)
182
183#pragma pack(4)
184/** generic VMMDev request header */
185typedef struct
186{
187 /** size of the structure in bytes (including body). Filled by caller */
188 uint32_t size;
189 /** version of the structure. Filled by caller */
190 uint32_t version;
191 /** type of the request */
192 VMMDevRequestType requestType;
193 /** return code. Filled by VMMDev */
194 int32_t rc;
195 /** reserved fields */
196 uint32_t reserved1;
197 uint32_t reserved2;
198} VMMDevRequestHeader;
199
200/** mouse status request structure */
201typedef struct
202{
203 /** header */
204 VMMDevRequestHeader header;
205 /** mouse feature mask */
206 uint32_t mouseFeatures;
207 /** mouse x position */
208 uint32_t pointerXPos;
209 /** mouse y position */
210 uint32_t pointerYPos;
211} VMMDevReqMouseStatus;
212
213/** Note VBOX_MOUSE_POINTER_* flags are used in guest video driver,
214 * values must be <= 0x8000 and must not be changed.
215 */
216
217/** pointer is visible */
218#define VBOX_MOUSE_POINTER_VISIBLE (0x0001)
219/** pointer has alpha channel */
220#define VBOX_MOUSE_POINTER_ALPHA (0x0002)
221/** pointerData contains new pointer shape */
222#define VBOX_MOUSE_POINTER_SHAPE (0x0004)
223
224/** mouse pointer shape/visibility change request */
225typedef struct
226{
227 /** header */
228 VMMDevRequestHeader header;
229 /** VBOX_MOUSE_POINTER_* bit flags */
230 uint32_t fFlags;
231 /** x coordinate of hot spot */
232 uint32_t xHot;
233 /** y coordinate of hot spot */
234 uint32_t yHot;
235 /** width of the pointer in pixels */
236 uint32_t width;
237 /** height of the pointer in scanlines */
238 uint32_t height;
239 /** Pointer data.
240 *
241 ****
242 * The data consists of 1 bpp AND mask followed by 32 bpp XOR (color) mask.
243 *
244 * For pointers without alpha channel the XOR mask pixels are 32 bit values: (lsb)BGR0(msb).
245 * For pointers with alpha channel the XOR mask consists of (lsb)BGRA(msb) 32 bit values.
246 *
247 * Guest driver must create the AND mask for pointers with alpha channel, so if host does not
248 * support alpha, the pointer could be displayed as a normal color pointer. The AND mask can
249 * be constructed from alpha values. For example alpha value >= 0xf0 means bit 0 in the AND mask.
250 *
251 * The AND mask is 1 bpp bitmap with byte aligned scanlines. Size of AND mask,
252 * therefore, is cbAnd = (width + 7) / 8 * height. The padding bits at the
253 * end of any scanline are undefined.
254 *
255 * The XOR mask follows the AND mask on the next 4 bytes aligned offset:
256 * uint8_t *pXor = pAnd + (cbAnd + 3) & ~3
257 * Bytes in the gap between the AND and the XOR mask are undefined.
258 * XOR mask scanlines have no gap between them and size of XOR mask is:
259 * cXor = width * 4 * height.
260 ****
261 *
262 * Preallocate 4 bytes for accessing actual data as p->pointerData
263 */
264 char pointerData[4];
265} VMMDevReqMousePointer;
266
267/** string log request structure */
268typedef struct
269{
270 /** header */
271 VMMDevRequestHeader header;
272 /** variable length string data */
273 char szString[1];
274} VMMDevReqLogString;
275
276/** host version request structure */
277typedef struct
278{
279 /** header */
280 VMMDevRequestHeader header;
281 /** major version */
282 uint32_t major;
283 /** minor version */
284 uint32_t minor;
285 /** build number */
286 uint32_t build;
287} VMMDevReqHostVersion;
288
289/** guest capabilites structure */
290typedef struct
291{
292 /** header */
293 VMMDevRequestHeader header;
294 /** capabilities (VMMDEV_GUEST_*) */
295 uint32_t caps;
296} VMMDevReqGuestCapabilities;
297
298/** guest capabilites structure */
299typedef struct
300{
301 /** header */
302 VMMDevRequestHeader header;
303 /** mask of capabilities to be added */
304 uint32_t u32OrMask;
305 /** mask of capabilities to be removed */
306 uint32_t u32NotMask;
307} VMMDevReqGuestCapabilities2;
308
309/** idle request structure */
310typedef struct
311{
312 /** header */
313 VMMDevRequestHeader header;
314} VMMDevReqIdle;
315
316/** host time request structure */
317typedef struct
318{
319 /** header */
320 VMMDevRequestHeader header;
321 /** time in milliseconds since unix epoch. Filled by VMMDev. */
322 uint64_t time;
323} VMMDevReqHostTime;
324
325/** hypervisor info structure */
326typedef struct
327{
328 /** header */
329 VMMDevRequestHeader header;
330 /** guest virtual address of proposed hypervisor start */
331 vmmDevHypPtr hypervisorStart;
332 /** hypervisor size in bytes */
333 uint32_t hypervisorSize;
334} VMMDevReqHypervisorInfo;
335
336/** system power requests */
337typedef enum
338{
339 VMMDevPowerState_Invalid = 0,
340 VMMDevPowerState_Pause = 1,
341 VMMDevPowerState_PowerOff = 2,
342 VMMDevPowerState_SaveState = 3,
343 VMMDevPowerState_SizeHack = 0x7fffffff
344} VMMDevPowerState;
345
346/** system power status structure */
347typedef struct
348{
349 /** header */
350 VMMDevRequestHeader header;
351 /** power state request */
352 VMMDevPowerState powerState;
353} VMMDevPowerStateRequest;
354
355/** pending events structure */
356typedef struct
357{
358 /** header */
359 VMMDevRequestHeader header;
360 /** pending event bitmap */
361 uint32_t events;
362} VMMDevEvents;
363
364/** guest filter mask control */
365typedef struct
366{
367 /** header */
368 VMMDevRequestHeader header;
369 /** mask of events to be added to filter */
370 uint32_t u32OrMask;
371 /** mask of events to be removed from filter */
372 uint32_t u32NotMask;
373} VMMDevCtlGuestFilterMask;
374
375/** guest information structure */
376typedef struct VBoxGuestInfo
377{
378 /** The VMMDev interface version expected by additions. */
379 uint32_t additionsVersion;
380 /** guest OS type */
381 VBOXOSTYPE osType;
382 /** @todo */
383} VBoxGuestInfo;
384
385/** guest information structure */
386typedef struct
387{
388 /** header */
389 VMMDevRequestHeader header;
390 /** Guest information. */
391 VBoxGuestInfo guestInfo;
392} VMMDevReportGuestInfo;
393
394/** guest statistics values */
395#define VBOX_GUEST_STAT_CPU_LOAD_IDLE RT_BIT(0)
396#define VBOX_GUEST_STAT_CPU_LOAD_KERNEL RT_BIT(1)
397#define VBOX_GUEST_STAT_CPU_LOAD_USER RT_BIT(2)
398#define VBOX_GUEST_STAT_THREADS RT_BIT(3)
399#define VBOX_GUEST_STAT_PROCESSES RT_BIT(4)
400#define VBOX_GUEST_STAT_HANDLES RT_BIT(5)
401#define VBOX_GUEST_STAT_MEMORY_LOAD RT_BIT(6)
402#define VBOX_GUEST_STAT_PHYS_MEM_TOTAL RT_BIT(7)
403#define VBOX_GUEST_STAT_PHYS_MEM_AVAIL RT_BIT(8)
404#define VBOX_GUEST_STAT_PHYS_MEM_BALLOON RT_BIT(9)
405#define VBOX_GUEST_STAT_MEM_COMMIT_TOTAL RT_BIT(10)
406#define VBOX_GUEST_STAT_MEM_KERNEL_TOTAL RT_BIT(11)
407#define VBOX_GUEST_STAT_MEM_KERNEL_PAGED RT_BIT(12)
408#define VBOX_GUEST_STAT_MEM_KERNEL_NONPAGED RT_BIT(13)
409#define VBOX_GUEST_STAT_MEM_SYSTEM_CACHE RT_BIT(14)
410#define VBOX_GUEST_STAT_PAGE_FILE_SIZE RT_BIT(15)
411
412
413/** guest statistics structure */
414typedef struct VBoxGuestStatistics
415{
416 /** Virtual CPU id */
417 uint32_t u32CpuId;
418 /** Reported statistics */
419 uint32_t u32StatCaps;
420 /** Idle CPU load (0-100) for last interval */
421 uint32_t u32CpuLoad_Idle;
422 /** Kernel CPU load (0-100) for last interval */
423 uint32_t u32CpuLoad_Kernel;
424 /** User CPU load (0-100) for last interval */
425 uint32_t u32CpuLoad_User;
426 /** Nr of threads */
427 uint32_t u32Threads;
428 /** Nr of processes */
429 uint32_t u32Processes;
430 /** Nr of handles */
431 uint32_t u32Handles;
432 /** Memory load (0-100) */
433 uint32_t u32MemoryLoad;
434 /** Page size of guest system */
435 uint32_t u32PageSize;
436 /** Total physical memory (in 4kb pages) */
437 uint32_t u32PhysMemTotal;
438 /** Available physical memory (in 4kb pages) */
439 uint32_t u32PhysMemAvail;
440 /** Ballooned physical memory (in 4kb pages) */
441 uint32_t u32PhysMemBalloon;
442 /** Total number of committed memory (which is not necessarily in-use) (in 4kb pages) */
443 uint32_t u32MemCommitTotal;
444 /** Total amount of memory used by the kernel (in 4kb pages) */
445 uint32_t u32MemKernelTotal;
446 /** Total amount of paged memory used by the kernel (in 4kb pages) */
447 uint32_t u32MemKernelPaged;
448 /** Total amount of nonpaged memory used by the kernel (in 4kb pages) */
449 uint32_t u32MemKernelNonPaged;
450 /** Total amount of memory used for the system cache (in 4kb pages) */
451 uint32_t u32MemSystemCache;
452 /** Pagefile size (in 4kb pages) */
453 uint32_t u32PageFileSize;
454} VBoxGuestStatistics;
455
456/** guest statistics command structure */
457typedef struct
458{
459 /** header */
460 VMMDevRequestHeader header;
461 /** Guest information. */
462 VBoxGuestStatistics guestStats;
463} VMMDevReportGuestStats;
464
465/** memory balloon change request structure */
466#define VMMDEV_MAX_MEMORY_BALLOON(PhysMemTotal) ((90*PhysMemTotal)/100)
467
468typedef struct
469{
470 /** header */
471 VMMDevRequestHeader header;
472 uint32_t u32BalloonSize; /* balloon size in megabytes */
473 uint32_t u32PhysMemSize; /* guest ram size in megabytes */
474 uint32_t eventAck;
475} VMMDevGetMemBalloonChangeRequest;
476
477/** inflate/deflate memory balloon structure */
478#define VMMDEV_MEMORY_BALLOON_CHUNK_PAGES (_1M/4096)
479#define VMMDEV_MEMORY_BALLOON_CHUNK_SIZE (VMMDEV_MEMORY_BALLOON_CHUNK_PAGES*4096)
480
481typedef struct
482{
483 /** header */
484 VMMDevRequestHeader header;
485 uint32_t cPages;
486 uint32_t fInflate; /* true = inflate, false = defalte */
487 /** Physical address (RTGCPHYS) of each page, variable size. */
488 RTGCPHYS aPhysPage[1];
489} VMMDevChangeMemBalloon;
490
491/** guest statistics interval change request structure */
492typedef struct
493{
494 /** header */
495 VMMDevRequestHeader header;
496 uint32_t u32StatInterval; /* interval in seconds */
497 uint32_t eventAck;
498} VMMDevGetStatisticsChangeRequest;
499
500/** display change request structure */
501typedef struct
502{
503 /** header */
504 VMMDevRequestHeader header;
505 /** horizontal pixel resolution (0 = do not change) */
506 uint32_t xres;
507 /** vertical pixel resolution (0 = do not change) */
508 uint32_t yres;
509 /** bits per pixel (0 = do not change) */
510 uint32_t bpp;
511 /** Flag that the request is an acknowlegement for the VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST.
512 * Values: 0 - just querying, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST - event acknowledged.
513 */
514 uint32_t eventAck;
515} VMMDevDisplayChangeRequest;
516
517typedef struct
518{
519 /** header */
520 VMMDevRequestHeader header;
521 /** horizontal pixel resolution (0 = do not change) */
522 uint32_t xres;
523 /** vertical pixel resolution (0 = do not change) */
524 uint32_t yres;
525 /** bits per pixel (0 = do not change) */
526 uint32_t bpp;
527 /** Flag that the request is an acknowlegement for the VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST.
528 * Values: 0 - just querying, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST - event acknowledged.
529 */
530 uint32_t eventAck;
531 /** 0 for primary display, 1 for the first secondary, etc. */
532 uint32_t display;
533} VMMDevDisplayChangeRequest2;
534
535/** video mode supported request structure */
536typedef struct
537{
538 /** header */
539 VMMDevRequestHeader header;
540 /** horizontal pixel resolution (input) */
541 uint32_t width;
542 /** vertical pixel resolution (input) */
543 uint32_t height;
544 /** bits per pixel (input) */
545 uint32_t bpp;
546 /** supported flag (output) */
547 bool fSupported;
548} VMMDevVideoModeSupportedRequest;
549
550/** video modes height reduction request structure */
551typedef struct
552{
553 /** header */
554 VMMDevRequestHeader header;
555 /** height reduction in pixels (output) */
556 uint32_t heightReduction;
557} VMMDevGetHeightReductionRequest;
558
559#define VRDP_EXPERIENCE_LEVEL_ZERO 0 /* Theming disabled. */
560#define VRDP_EXPERIENCE_LEVEL_LOW 1 /* Full window dragging and desktop wallpaper disabled. */
561#define VRDP_EXPERIENCE_LEVEL_MEDIUM 2 /* Font smoothing, gradients. */
562#define VRDP_EXPERIENCE_LEVEL_HIGH 3 /* Animation effects disabled. */
563#define VRDP_EXPERIENCE_LEVEL_FULL 4 /* Everything enabled. */
564
565typedef struct
566{
567 /** header */
568 VMMDevRequestHeader header;
569 /** Whether VRDP is active or not */
570 uint8_t u8VRDPActive;
571 /** The configured experience level for active VRDP. */
572 uint32_t u32VRDPExperienceLevel;
573} VMMDevVRDPChangeRequest;
574
575
576
577#pragma pack()
578
579#ifdef VBOX_HGCM
580
581/** HGCM flags.
582 * @{
583 */
584#define VBOX_HGCM_REQ_DONE (0x1)
585#define VBOX_HGCM_REQ_CANCELLED (0x2)
586/** @} */
587
588#pragma pack(4)
589typedef struct _VMMDevHGCMRequestHeader
590{
591 /** Request header. */
592 VMMDevRequestHeader header;
593
594 /** HGCM flags. */
595 uint32_t fu32Flags;
596
597 /** Result code. */
598 int32_t result;
599} VMMDevHGCMRequestHeader;
600
601/** HGCM service location types. */
602typedef enum
603{
604 VMMDevHGCMLoc_Invalid = 0,
605 VMMDevHGCMLoc_LocalHost = 1,
606 VMMDevHGCMLoc_LocalHost_Existing = 2,
607 VMMDevHGCMLoc_SizeHack = 0x7fffffff
608} HGCMServiceLocationType;
609
610typedef struct
611{
612 char achName[128];
613} HGCMServiceLocationHost;
614
615typedef struct HGCMSERVICELOCATION
616{
617 /** Type of the location. */
618 HGCMServiceLocationType type;
619
620 union
621 {
622 HGCMServiceLocationHost host;
623 } u;
624} HGCMServiceLocation;
625
626typedef struct
627{
628 /* request header */
629 VMMDevHGCMRequestHeader header;
630
631 /** IN: Description of service to connect to. */
632 HGCMServiceLocation loc;
633
634 /** OUT: Client identifier assigned by local instance of HGCM. */
635 uint32_t u32ClientID;
636} VMMDevHGCMConnect;
637
638typedef struct
639{
640 /* request header */
641 VMMDevHGCMRequestHeader header;
642
643 /** IN: Client identifier. */
644 uint32_t u32ClientID;
645} VMMDevHGCMDisconnect;
646
647typedef enum
648{
649 VMMDevHGCMParmType_Invalid = 0,
650 VMMDevHGCMParmType_32bit = 1,
651 VMMDevHGCMParmType_64bit = 2,
652 VMMDevHGCMParmType_PhysAddr = 3,
653 VMMDevHGCMParmType_LinAddr = 4, /**< In and Out */
654 VMMDevHGCMParmType_LinAddr_In = 5, /**< In (read; host<-guest) */
655 VMMDevHGCMParmType_LinAddr_Out = 6, /**< Out (write; host->guest) */
656 VMMDevHGCMParmType_LinAddr_Locked = 7, /**< Locked In and Out */
657 VMMDevHGCMParmType_LinAddr_Locked_In = 8, /**< Locked In (read; host<-guest) */
658 VMMDevHGCMParmType_LinAddr_Locked_Out = 9, /**< Locked Out (write; host->guest) */
659 VMMDevHGCMParmType_SizeHack = 0x7fffffff
660} HGCMFunctionParameterType;
661
662typedef struct _HGCMFUNCTIONPARAMETER
663{
664 HGCMFunctionParameterType type;
665 union
666 {
667 uint32_t value32;
668 uint64_t value64;
669 struct
670 {
671 uint32_t size;
672
673 union
674 {
675 vmmDevHypPhys physAddr;
676 vmmDevHypPtr linearAddr;
677 } u;
678 } Pointer;
679 } u;
680} HGCMFunctionParameter;
681
682typedef struct
683{
684 /* request header */
685 VMMDevHGCMRequestHeader header;
686
687 /** IN: Client identifier. */
688 uint32_t u32ClientID;
689 /** IN: Service function number. */
690 uint32_t u32Function;
691 /** IN: Number of parameters. */
692 uint32_t cParms;
693 /** Parameters follow in form: HGCMFunctionParameter aParms[X]; */
694} VMMDevHGCMCall;
695#pragma pack()
696
697#define VMMDEV_HGCM_CALL_PARMS(a) ((HGCMFunctionParameter *)((char *)a + sizeof (VMMDevHGCMCall)))
698
699#define VBOX_HGCM_MAX_PARMS 32
700
701#endif /* VBOX_HGCM */
702
703
704#define VBVA_F_STATUS_ACCEPTED (0x01)
705#define VBVA_F_STATUS_ENABLED (0x02)
706
707#pragma pack(4)
708
709typedef struct _VMMDevVideoAccelEnable
710{
711 /* request header */
712 VMMDevRequestHeader header;
713
714 /** 0 - disable, !0 - enable. */
715 uint32_t u32Enable;
716
717 /** The size of VBVAMEMORY::au8RingBuffer expected by driver.
718 * The host will refuse to enable VBVA if the size is not equal to
719 * VBVA_RING_BUFFER_SIZE.
720 */
721 uint32_t cbRingBuffer;
722
723 /** Guest initializes the status to 0. Host sets appropriate VBVA_F_STATUS_ flags. */
724 uint32_t fu32Status;
725
726} VMMDevVideoAccelEnable;
727
728typedef struct _VMMDevVideoAccelFlush
729{
730 /* request header */
731 VMMDevRequestHeader header;
732
733} VMMDevVideoAccelFlush;
734
735
736typedef struct _VMMDevVideoSetVisibleRegion
737{
738 /* request header */
739 VMMDevRequestHeader header;
740
741 /** Number of rectangles */
742 uint32_t cRect;
743
744 /** Rectangle array */
745 RTRECT Rect;
746} VMMDevVideoSetVisibleRegion;
747
748
749/** Seamless mode */
750typedef enum
751{
752 VMMDev_Seamless_Disabled = 0, /* normal mode; entire guest desktop displayed */
753 VMMDev_Seamless_Visible_Region = 1, /* visible region mode; only top-level guest windows displayed */
754 VMMDev_Seamless_Host_Window = 2 /* windowed mode; each top-level guest window is represented in a host window */
755} VMMDevSeamlessMode;
756
757typedef struct
758{
759 /** header */
760 VMMDevRequestHeader header;
761
762 /** New seamless mode */
763 VMMDevSeamlessMode mode;
764 /** Flag that the request is an acknowlegement for the VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST.
765 * Values: 0 - just querying, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST - event acknowledged.
766 */
767 uint32_t eventAck;
768} VMMDevSeamlessChangeRequest;
769
770#pragma pack()
771
772#pragma pack(1)
773/** VBVA command header. */
774typedef struct _VBVACMDHDR
775{
776 /** Coordinates of affected rectangle. */
777 int16_t x;
778 int16_t y;
779 uint16_t w;
780 uint16_t h;
781} VBVACMDHDR;
782#pragma pack()
783
784/* The VBVA ring buffer is suitable for transferring large (< 2gb) amount of data.
785 * For example big bitmaps which do not fit to the buffer.
786 *
787 * Guest starts writing to the buffer by initializing a record entry in the
788 * aRecords queue. VBVA_F_RECORD_PARTIAL indicates that the record is being
789 * written. As data is written to the ring buffer, the guest increases off32End
790 * for the record.
791 *
792 * The host reads the aRecords on flushes and processes all completed records.
793 * When host encounters situation when only a partial record presents and
794 * cbRecord & ~VBVA_F_RECORD_PARTIAL >= VBVA_RING_BUFFER_SIZE - VBVA_RING_BUFFER_THRESHOLD,
795 * the host fetched all record data and updates off32Head. After that on each flush
796 * the host continues fetching the data until the record is completed.
797 *
798 */
799
800#define VBVA_RING_BUFFER_SIZE (_4M - _1K)
801#define VBVA_RING_BUFFER_THRESHOLD (4 * _1K)
802
803#define VBVA_MAX_RECORDS (64)
804
805#define VBVA_F_MODE_ENABLED (0x00000001)
806#define VBVA_F_MODE_VRDP (0x00000002)
807#define VBVA_F_MODE_VRDP_RESET (0x00000004)
808#define VBVA_F_MODE_VRDP_ORDER_MASK (0x00000008)
809
810#define VBVA_F_RECORD_PARTIAL (0x80000000)
811
812#pragma pack(1)
813typedef struct _VBVARECORD
814{
815 /** The length of the record. Changed by guest. */
816 uint32_t cbRecord;
817} VBVARECORD;
818
819typedef struct _VBVAMEMORY
820{
821 /** VBVA_F_MODE_* */
822 uint32_t fu32ModeFlags;
823
824 /** The offset where the data start in the buffer. */
825 uint32_t off32Data;
826 /** The offset where next data must be placed in the buffer. */
827 uint32_t off32Free;
828
829 /** The ring buffer for data. */
830 uint8_t au8RingBuffer[VBVA_RING_BUFFER_SIZE];
831
832 /** The queue of record descriptions. */
833 VBVARECORD aRecords[VBVA_MAX_RECORDS];
834 uint32_t indexRecordFirst;
835 uint32_t indexRecordFree;
836
837 /* RDP orders supported by the client. The guest reports only them
838 * and falls back to DIRTY rects for not supported ones.
839 *
840 * (1 << VBVA_VRDP_*)
841 */
842 uint32_t fu32SupportedOrders;
843
844} VBVAMEMORY;
845#pragma pack()
846
847/** @} */
848
849
850/**
851 * VMMDev RAM
852 * @{
853 */
854
855#pragma pack(1)
856/** Layout of VMMDEV RAM region that contains information for guest */
857typedef struct
858{
859 /** size */
860 uint32_t u32Size;
861 /** version */
862 uint32_t u32Version;
863
864 union {
865 /** Flag telling that VMMDev set the IRQ and acknowlegment is required */
866 struct {
867 bool fHaveEvents;
868 } V1_04;
869
870 struct {
871 /** Pending events flags, set by host. */
872 uint32_t u32HostEvents;
873 /** Mask of events the guest wants to see, set by guest. */
874 uint32_t u32GuestEventMask;
875 } V1_03;
876 } V;
877
878 VBVAMEMORY vbvaMemory;
879
880} VMMDevMemory;
881#pragma pack()
882
883/** Version of VMMDevMemory structure. */
884#define VMMDEV_MEMORY_VERSION (1)
885
886/** @} */
887
888
889/**
890 * VMMDev events.
891 * @{
892 */
893
894/** Host mouse capabilities has been changed. */
895#define VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED RT_BIT(0)
896/** HGCM event. */
897#define VMMDEV_EVENT_HGCM RT_BIT(1)
898/** A display change request has been issued. */
899#define VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST RT_BIT(2)
900/** Credentials are available for judgement. */
901#define VMMDEV_EVENT_JUDGE_CREDENTIALS RT_BIT(3)
902/** The guest has been restored. */
903#define VMMDEV_EVENT_RESTORED RT_BIT(4)
904/** Seamless mode state changed */
905#define VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST RT_BIT(5)
906/** Memory balloon size changed */
907#define VMMDEV_EVENT_BALLOON_CHANGE_REQUEST RT_BIT(6)
908/** Statistics interval changed */
909#define VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST RT_BIT(7)
910/** VRDP status changed. */
911#define VMMDEV_EVENT_VRDP RT_BIT(8)
912
913/** @} */
914
915
916/**
917 * VBoxGuest IOCTL codes and structures.
918 *
919 * The range 0..15 is for basic driver communication.
920 * The range 16..31 is for HGCM communcation.
921 * The range 32..47 is reserved for future use.
922 * The range 48..63 is for OS specific communcation.
923 * The 7th bit is reserved for future hacks.
924 * The 8th bit is reserved for distinguishing between 32-bit and 64-bit
925 * processes in future 64-bit guest additions.
926 *
927 * While windows IOCTL function number has to start at 2048 and stop at 4096 there
928 * never was any need to do this for everyone. A simple ((Function) | 0x800) would
929 * have sufficed. On Linux we're now intruding upon the type field. Fortunately
930 * this hasn't caused any trouble because the FILE_DEVICE_UNKNOWN value was set
931 * to 0x22 (if it were 0x2C it would not have worked soo smoothly). The situation
932 * would've been the same for *BSD and Darwin since they seems to share common
933 * _IOC() heritage.
934 *
935 * However, on good old OS/2 we only have 8-bit handy for the function number. The
936 * result from using the old IOCTL function numbers her would've been overlapping
937 * between the two ranges.
938 *
939 * To fix this problem and get rid of all the unnecessary windowsy crap that I
940 * bet was copied from my SUPDRVIOC.h once upon a time (although the concept of
941 * prefixing macros with the purpose of avoid clashes with system stuff and
942 * to indicate exactly how owns them seems to have been lost somewhere along
943 * the way), I've introduced a VBOXGUEST_IOCTL_CODE for defining generic IN/OUT
944 * IOCtls on new ports of the additions.
945 *
946 * @remarks When creating new IOCtl interfaces keep in mind that not all OSes supports
947 * reporting back the output size. (This got messed up a little bit in VBoxDrv.)
948 *
949 * The request size is also a little bit tricky as it's passed as part of the
950 * request code on unix. The size field is 14 bits on Linux, 12 bits on *BSD,
951 * 13 bits Darwin, and 8-bits on Solaris. All the BSDs and Darwin kernels
952 * will make use of the size field, while Linux and Solaris will not. We're of
953 * course using the size to validate and/or map/lock the request, so it has
954 * to be valid.
955 *
956 * For Solaris we will have to do something special though, 255 isn't
957 * sufficent for all we need. A 4KB restriction (BSD) is probably not
958 * too problematic (yet) as a general one.
959 *
960 * More info can be found in SUPDRVIOC.h and related sources.
961 *
962 * @remarks If adding interfaces that only has input or only has output, some new macros
963 * needs to be created so the most efficient IOCtl data buffering method can be
964 * used.
965 * @{
966 */
967#ifdef RT_ARCH_AMD64
968# define VBOXGUEST_IOCTL_FLAG 128
969#elif defined(RT_ARCH_X86)
970# define VBOXGUEST_IOCTL_FLAG 0
971#else
972# error "dunno which arch this is!"
973#endif
974
975/** Ring-3 request wrapper for big requests.
976 *
977 * This is necessary because the ioctl number scheme on many Unixy OSes (esp. Solaris)
978 * only allows a relatively small size to be encoded into the request. So, for big
979 * request this generic form is used instead. */
980typedef struct VBGLBIGREQ
981{
982 /** Magic value (VBGLBIGREQ_MAGIC). */
983 uint32_t u32Magic;
984 /** The size of the data buffer. */
985 uint32_t cbData;
986 /** The user address of the data buffer. */
987 RTR3PTR pvDataR3;
988} VBGLBIGREQ;
989/** Pointer to a request wrapper for solaris guests. */
990typedef VBGLBIGREQ *PVBGLBIGREQ;
991/** Pointer to a const request wrapper for solaris guests. */
992typedef const VBGLBIGREQ *PCVBGLBIGREQ;
993
994/** The VBGLBIGREQ::u32Magic value (Ryuu Murakami). */
995#define VBGLBIGREQ_MAGIC 0x19520219
996
997
998#if defined(RT_OS_WINDOWS)
999 /* legacy encoding. */
1000# define IOCTL_CODE(DeviceType, Function, Method, Access, DataSize_ignored) \
1001 ( ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
1002
1003#elif defined(RT_OS_OS2)
1004 /* No automatic buffering, size not encoded. */
1005# define VBOXGUEST_IOCTL_CATEGORY 0xc2
1006# define VBOXGUEST_IOCTL_CODE(Function, Size) ((unsigned char)(Function))
1007# define VBOXGUEST_IOCTL_CATEGORY_FAST 0xc3 /**< Also defined in VBoxGuestA-os2.asm. */
1008# define VBOXGUEST_IOCTL_CODE_FAST(Function) ((unsigned char)(Function))
1009# define VBOXGUEST_IOCTL_STRIP_SIZE(Code) (Code)
1010
1011#elif defined(RT_OS_SOLARIS)
1012 /* No automatic buffering, size limited to 255 bytes => use VBGLBIGREQ for everything. */
1013# include <sys/ioccom.h>
1014# define VBOXGUEST_IOCTL_CODE(Function, Size) _IOWRN('V', (Function) | VBOXGUEST_IOCTL_FLAG, sizeof(VBGLBIGREQ))
1015# define VBOXGUEST_IOCTL_CODE_FAST(Function) _IO( 'V', (Function) | VBOXGUEST_IOCTL_FLAG)
1016# define VBOXGUEST_IOCTL_STRIP_SIZE(Code) (Code)
1017
1018#elif defined(RT_OS_LINUX)
1019 /* No automatic buffering, size limited to 16KB. */
1020# include <linux/ioctl.h>
1021# define VBOXGUEST_IOCTL_CODE(Function, Size) _IOC(_IOC_READ|_IOC_WRITE, 'V', (Function) | VBOXGUEST_IOCTL_FLAG, (Size))
1022# define VBOXGUEST_IOCTL_CODE_FAST(Function) _IO( 'V', (Function) | VBOXGUEST_IOCTL_FLAG)
1023# define VBOXGUEST_IOCTL_STRIP_SIZE(Code) VBOXGUEST_IOCTL_CODE(_IOC_NR((Code)), 0)
1024
1025#elif defined(RT_OS_FREEBSD) /** @todo r=bird: Please do it like SUPDRVIOC to keep it as similar as possible. */
1026# include <sys/ioccom.h>
1027
1028# define VBOXGUEST_IOCTL_CODE(Function, Size) _IOWR('V', (Function) | VBOXGUEST_IOCTL_FLAG, VBGLBIGREQ)
1029# define VBOXGUEST_IOCTL_CODE_FAST(Function) _IO( 'V', (Function) | VBOXGUEST_IOCTL_FLAG)
1030# define VBOXGUEST_IOCTL_STRIP_SIZE(Code) IOCBASECMD(Code)
1031
1032#else
1033/* PORTME */
1034#endif
1035
1036/** IOCTL to VBoxGuest to query the VMMDev IO port region start. */
1037#ifdef VBOXGUEST_IOCTL_CODE
1038# define VBOXGUEST_IOCTL_GETVMMDEVPORT VBOXGUEST_IOCTL_CODE(1, sizeof(VBoxGuestPortInfo))
1039# define IOCTL_VBOXGUEST_GETVMMDEVPORT VBOXGUEST_IOCTL_GETVMMDEVPORT
1040#else
1041# define IOCTL_VBOXGUEST_GETVMMDEVPORT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2048, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestPortInfo))
1042#endif
1043
1044#pragma pack(4)
1045typedef struct _VBoxGuestPortInfo
1046{
1047 uint32_t portAddress;
1048 VMMDevMemory *pVMMDevMemory;
1049} VBoxGuestPortInfo;
1050
1051/** IOCTL to VBoxGuest to wait for a VMMDev host notification */
1052#ifdef VBOXGUEST_IOCTL_CODE
1053# define VBOXGUEST_IOCTL_WAITEVENT VBOXGUEST_IOCTL_CODE(2, sizeof(VBoxGuestWaitEventInfo))
1054# define IOCTL_VBOXGUEST_WAITEVENT VBOXGUEST_IOCTL_WAITEVENT
1055#else
1056# define IOCTL_VBOXGUEST_WAITEVENT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2049, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestWaitEventInfo))
1057#endif
1058
1059/** IOCTL to VBoxGuest to interrupt (cancel) any pending WAITEVENTs and return.
1060 * Handled inside the guest additions and not seen by the host at all.
1061 * @see VBOXGUEST_IOCTL_WAITEVENT */
1062#ifdef VBOXGUEST_IOCTL_CODE
1063# define VBOXGUEST_IOCTL_CANCEL_ALL_WAITEVENTS VBOXGUEST_IOCTL_CODE(5, 0)
1064#else
1065# define VBOXGUEST_IOCTL_CANCEL_ALL_WAITEVENTS IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2054, METHOD_BUFFERED, FILE_WRITE_ACCESS, 0)
1066#endif
1067
1068/**
1069 * Result codes for VBoxGuestWaitEventInfo::u32Result
1070 * @{
1071 */
1072/** Successful completion, an event occured. */
1073#define VBOXGUEST_WAITEVENT_OK (0)
1074/** Successful completion, timed out. */
1075#define VBOXGUEST_WAITEVENT_TIMEOUT (1)
1076/** Wait was interrupted. */
1077#define VBOXGUEST_WAITEVENT_INTERRUPTED (2)
1078/** An error occured while processing the request. */
1079#define VBOXGUEST_WAITEVENT_ERROR (3)
1080/** @} */
1081
1082/** Input and output buffers layout of the IOCTL_VBOXGUEST_WAITEVENT */
1083typedef struct _VBoxGuestWaitEventInfo
1084{
1085 /** timeout in milliseconds */
1086 uint32_t u32TimeoutIn;
1087 /** events to wait for */
1088 uint32_t u32EventMaskIn;
1089 /** result code */
1090 uint32_t u32Result;
1091 /** events occured */
1092 uint32_t u32EventFlagsOut;
1093} VBoxGuestWaitEventInfo;
1094
1095/** IOCTL to VBoxGuest to perform a VMM request
1096 * @remark The data buffer for this IOCtl has an variable size, keep this in mind
1097 * on systems where this matters. */
1098#ifdef VBOXGUEST_IOCTL_CODE
1099# define VBOXGUEST_IOCTL_VMMREQUEST(Size) VBOXGUEST_IOCTL_CODE(3, (Size))
1100# define IOCTL_VBOXGUEST_VMMREQUEST VBOXGUEST_IOCTL_VMMREQUEST(sizeof(VMMDevRequestHeader))
1101#else
1102# define IOCTL_VBOXGUEST_VMMREQUEST IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2050, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VMMDevRequestHeader))
1103#endif
1104
1105/** Input and output buffer layout of the IOCTL_VBOXGUEST_CTL_FILTER_MASK. */
1106typedef struct _VBoxGuestFilterMaskInfo
1107{
1108 uint32_t u32OrMask;
1109 uint32_t u32NotMask;
1110} VBoxGuestFilterMaskInfo;
1111#pragma pack()
1112
1113/** IOCTL to VBoxGuest to control event filter mask. */
1114#ifdef VBOXGUEST_IOCTL_CODE
1115# define VBOXGUEST_IOCTL_CTL_FILTER_MASK VBOXGUEST_IOCTL_CODE(4, sizeof(VBoxGuestFilterMaskInfo))
1116# define IOCTL_VBOXGUEST_CTL_FILTER_MASK VBOXGUEST_IOCTL_CTL_FILTER_MASK
1117#else
1118# define IOCTL_VBOXGUEST_CTL_FILTER_MASK IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2051, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof (VBoxGuestFilterMaskInfo))
1119#endif
1120
1121/** IOCTL to VBoxGuest to check memory ballooning. */
1122#ifdef VBOXGUEST_IOCTL_CODE
1123# define VBOXGUEST_IOCTL_CTL_CHECK_BALLOON_MASK VBOXGUEST_IOCTL_CODE(4, 100)
1124# define IOCTL_VBOXGUEST_CTL_CHECK_BALLOON VBOXGUEST_IOCTL_CTL_CHECK_BALLOON_MASK
1125#else
1126# define IOCTL_VBOXGUEST_CTL_CHECK_BALLOON IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2052, METHOD_BUFFERED, FILE_WRITE_ACCESS, 0)
1127#endif
1128
1129/** IOCTL to VBoxGuest to perform backdoor logging. */
1130#ifdef VBOXGUEST_IOCTL_CODE
1131# define VBOXGUEST_IOCTL_LOG(Size) VBOXGUEST_IOCTL_CODE(6, (Size))
1132#else
1133# define VBOXGUEST_IOCTL_LOG(Size) IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2055, METHOD_BUFFERED, FILE_WRITE_ACCESS, (Size))
1134#endif
1135
1136
1137#ifdef VBOX_HGCM
1138/* These structures are shared between the driver and other binaries,
1139 * therefore packing must be defined explicitely.
1140 */
1141#pragma pack(1)
1142typedef struct _VBoxGuestHGCMConnectInfo
1143{
1144 uint32_t result; /**< OUT */
1145 HGCMServiceLocation Loc; /**< IN */
1146 uint32_t u32ClientID; /**< OUT */
1147} VBoxGuestHGCMConnectInfo;
1148
1149typedef struct _VBoxGuestHGCMDisconnectInfo
1150{
1151 uint32_t result; /**< OUT */
1152 uint32_t u32ClientID; /**< IN */
1153} VBoxGuestHGCMDisconnectInfo;
1154
1155typedef struct _VBoxGuestHGCMCallInfo
1156{
1157 uint32_t result; /**< OUT Host HGCM return code.*/
1158 uint32_t u32ClientID; /**< IN The id of the caller. */
1159 uint32_t u32Function; /**< IN Function number. */
1160 uint32_t cParms; /**< IN How many parms. */
1161 /* Parameters follow in form HGCMFunctionParameter aParms[cParms] */
1162} VBoxGuestHGCMCallInfo;
1163#pragma pack()
1164
1165#ifdef VBOXGUEST_IOCTL_CODE
1166# define VBOXGUEST_IOCTL_HGCM_CONNECT VBOXGUEST_IOCTL_CODE(16, sizeof(VBoxGuestHGCMConnectInfo))
1167# define IOCTL_VBOXGUEST_HGCM_CONNECT VBOXGUEST_IOCTL_HGCM_CONNECT
1168# define VBOXGUEST_IOCTL_HGCM_DISCONNECT VBOXGUEST_IOCTL_CODE(17, sizeof(VBoxGuestHGCMDisconnectInfo))
1169# define IOCTL_VBOXGUEST_HGCM_DISCONNECT VBOXGUEST_IOCTL_HGCM_DISCONNECT
1170# define VBOXGUEST_IOCTL_HGCM_CALL(Size) VBOXGUEST_IOCTL_CODE(18, (Size))
1171# define IOCTL_VBOXGUEST_HGCM_CALL VBOXGUEST_IOCTL_HGCM_CALL(sizeof(VBoxGuestHGCMCallInfo))
1172# define VBOXGUEST_IOCTL_CLIPBOARD_CONNECT VBOXGUEST_IOCTL_CODE(19, sizeof(uint32_t))
1173# define IOCTL_VBOXGUEST_CLIPBOARD_CONNECT VBOXGUEST_IOCTL_CLIPBOARD_CONNECT
1174#else
1175# define IOCTL_VBOXGUEST_HGCM_CONNECT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3072, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMConnectInfo))
1176# define IOCTL_VBOXGUEST_HGCM_DISCONNECT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3073, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMDisconnectInfo))
1177# define IOCTL_VBOXGUEST_HGCM_CALL IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3074, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMCallInfo))
1178# define IOCTL_VBOXGUEST_CLIPBOARD_CONNECT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3075, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(uint32_t))
1179#endif
1180
1181#define VBOXGUEST_HGCM_CALL_PARMS(a) ((HGCMFunctionParameter *)((uint8_t *)(a) + sizeof (VBoxGuestHGCMCallInfo)))
1182
1183#endif /* VBOX_HGCM */
1184
1185/*
1186 * Credentials request flags and structure
1187 */
1188
1189#define VMMDEV_CREDENTIALS_STRLEN 128
1190
1191/** query from host whether credentials are present */
1192#define VMMDEV_CREDENTIALS_QUERYPRESENCE RT_BIT(1)
1193/** read credentials from host (can be combined with clear) */
1194#define VMMDEV_CREDENTIALS_READ RT_BIT(2)
1195/** clear credentials on host (can be combined with read) */
1196#define VMMDEV_CREDENTIALS_CLEAR RT_BIT(3)
1197/** read credentials for judgement in the guest */
1198#define VMMDEV_CREDENTIALS_READJUDGE RT_BIT(8)
1199/** clear credentials for judegement on the host */
1200#define VMMDEV_CREDENTIALS_CLEARJUDGE RT_BIT(9)
1201/** report credentials acceptance by guest */
1202#define VMMDEV_CREDENTIALS_JUDGE_OK RT_BIT(10)
1203/** report credentials denial by guest */
1204#define VMMDEV_CREDENTIALS_JUDGE_DENY RT_BIT(11)
1205/** report that no judgement could be made by guest */
1206#define VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT RT_BIT(12)
1207
1208/** flag telling the guest that credentials are present */
1209#define VMMDEV_CREDENTIALS_PRESENT RT_BIT(16)
1210/** flag telling guest that local logons should be prohibited */
1211#define VMMDEV_CREDENTIALS_NOLOCALLOGON RT_BIT(17)
1212
1213/** credentials request structure */
1214#pragma pack(4)
1215typedef struct _VMMDevCredentials
1216{
1217 /* request header */
1218 VMMDevRequestHeader header;
1219 /* request flags (in/out) */
1220 uint32_t u32Flags;
1221 /* user name (UTF-8) (out) */
1222 char szUserName[VMMDEV_CREDENTIALS_STRLEN];
1223 /* password (UTF-8) (out) */
1224 char szPassword[VMMDEV_CREDENTIALS_STRLEN];
1225 /* domain name (UTF-8) (out) */
1226 char szDomain[VMMDEV_CREDENTIALS_STRLEN];
1227} VMMDevCredentials;
1228#pragma pack()
1229
1230/** inline helper to determine the request size for the given operation */
1231DECLINLINE(size_t) vmmdevGetRequestSize(VMMDevRequestType requestType)
1232{
1233 switch (requestType)
1234 {
1235 case VMMDevReq_GetMouseStatus:
1236 case VMMDevReq_SetMouseStatus:
1237 return sizeof(VMMDevReqMouseStatus);
1238 case VMMDevReq_SetPointerShape:
1239 return sizeof(VMMDevReqMousePointer);
1240 case VMMDevReq_GetHostVersion:
1241 return sizeof(VMMDevReqHostVersion);
1242 case VMMDevReq_Idle:
1243 return sizeof(VMMDevReqIdle);
1244 case VMMDevReq_GetHostTime:
1245 return sizeof(VMMDevReqHostTime);
1246 case VMMDevReq_GetHypervisorInfo:
1247 case VMMDevReq_SetHypervisorInfo:
1248 return sizeof(VMMDevReqHypervisorInfo);
1249 case VMMDevReq_SetPowerStatus:
1250 return sizeof(VMMDevPowerStateRequest);
1251 case VMMDevReq_AcknowledgeEvents:
1252 return sizeof(VMMDevEvents);
1253 case VMMDevReq_ReportGuestInfo:
1254 return sizeof(VMMDevReportGuestInfo);
1255 case VMMDevReq_GetDisplayChangeRequest:
1256 return sizeof(VMMDevDisplayChangeRequest);
1257 case VMMDevReq_GetDisplayChangeRequest2:
1258 return sizeof(VMMDevDisplayChangeRequest2);
1259 case VMMDevReq_VideoModeSupported:
1260 return sizeof(VMMDevVideoModeSupportedRequest);
1261 case VMMDevReq_GetHeightReduction:
1262 return sizeof(VMMDevGetHeightReductionRequest);
1263 case VMMDevReq_ReportGuestCapabilities:
1264 return sizeof(VMMDevReqGuestCapabilities);
1265 case VMMDevReq_SetGuestCapabilities:
1266 return sizeof(VMMDevReqGuestCapabilities2);
1267#ifdef VBOX_HGCM
1268 case VMMDevReq_HGCMConnect:
1269 return sizeof(VMMDevHGCMConnect);
1270 case VMMDevReq_HGCMDisconnect:
1271 return sizeof(VMMDevHGCMDisconnect);
1272 case VMMDevReq_HGCMCall:
1273 return sizeof(VMMDevHGCMCall);
1274#endif
1275 case VMMDevReq_VideoAccelEnable:
1276 return sizeof(VMMDevVideoAccelEnable);
1277 case VMMDevReq_VideoAccelFlush:
1278 return sizeof(VMMDevVideoAccelFlush);
1279 case VMMDevReq_VideoSetVisibleRegion:
1280 return sizeof(VMMDevVideoSetVisibleRegion);
1281 case VMMDevReq_GetSeamlessChangeRequest:
1282 return sizeof(VMMDevSeamlessChangeRequest);
1283 case VMMDevReq_QueryCredentials:
1284 return sizeof(VMMDevCredentials);
1285 case VMMDevReq_ReportGuestStats:
1286 return sizeof(VMMDevReportGuestStats);
1287 case VMMDevReq_GetMemBalloonChangeRequest:
1288 return sizeof(VMMDevGetMemBalloonChangeRequest);
1289 case VMMDevReq_GetStatisticsChangeRequest:
1290 return sizeof(VMMDevGetStatisticsChangeRequest);
1291 case VMMDevReq_ChangeMemBalloon:
1292 return sizeof(VMMDevChangeMemBalloon);
1293 case VMMDevReq_GetVRDPChangeRequest:
1294 return sizeof(VMMDevVRDPChangeRequest);
1295 case VMMDevReq_LogString:
1296 return sizeof(VMMDevReqLogString);
1297 default:
1298 return 0;
1299 }
1300}
1301
1302/**
1303 * Initializes a request structure.
1304 *
1305 */
1306DECLINLINE(int) vmmdevInitRequest(VMMDevRequestHeader *req, VMMDevRequestType type)
1307{
1308 uint32_t requestSize;
1309 if (!req)
1310 return VERR_INVALID_PARAMETER;
1311 requestSize = (uint32_t)vmmdevGetRequestSize(type);
1312 if (!requestSize)
1313 return VERR_INVALID_PARAMETER;
1314 req->size = requestSize;
1315 req->version = VMMDEV_REQUEST_HEADER_VERSION;
1316 req->requestType = type;
1317 req->rc = VERR_GENERAL_FAILURE;
1318 req->reserved1 = 0;
1319 req->reserved2 = 0;
1320 return VINF_SUCCESS;
1321}
1322
1323
1324#ifdef RT_OS_OS2
1325
1326/**
1327 * The data buffer layout for the IDC entry point (AttachDD).
1328 *
1329 * @remark This is defined in multiple 16-bit headers / sources.
1330 * Some places it's called VBGOS2IDC to short things a bit.
1331 */
1332typedef struct VBOXGUESTOS2IDCCONNECT
1333{
1334 /** VMMDEV_VERSION. */
1335 uint32_t u32Version;
1336 /** Opaque session handle. */
1337 uint32_t u32Session;
1338
1339 /**
1340 * The 32-bit service entry point.
1341 *
1342 * @returns VBox status code.
1343 * @param u32Session The above session handle.
1344 * @param iFunction The requested function.
1345 * @param pvData The input/output data buffer. The caller ensures that this
1346 * cannot be swapped out, or that it's acceptable to take a
1347 * page in fault in the current context. If the request doesn't
1348 * take input or produces output, apssing NULL is okay.
1349 * @param cbData The size of the data buffer.
1350 * @param pcbDataReturned Where to store the amount of data that's returned.
1351 * This can be NULL if pvData is NULL.
1352 */
1353 DECLCALLBACKMEMBER(int, pfnServiceEP)(uint32_t u32Session, unsigned iFunction, void *pvData, size_t cbData, size_t *pcbDataReturned);
1354
1355 /** The 16-bit service entry point for C code (cdecl).
1356 *
1357 * It's the same as the 32-bit entry point, but the types has
1358 * changed to 16-bit equivalents.
1359 *
1360 * @code
1361 * int far cdecl
1362 * VBoxGuestOs2IDCService16(uint32_t u32Session, uint16_t iFunction,
1363 * void far *fpvData, uint16_t cbData, uint16_t far *pcbDataReturned);
1364 * @endcode
1365 */
1366 RTFAR16 fpfnServiceEP;
1367
1368 /** The 16-bit service entry point for Assembly code (register).
1369 *
1370 * This is just a wrapper around fpfnServiceEP to simplify calls
1371 * from 16-bit assembly code.
1372 *
1373 * @returns (e)ax: VBox status code; cx: The amount of data returned.
1374 *
1375 * @param u32Session eax - The above session handle.
1376 * @param iFunction dl - The requested function.
1377 * @param pvData es:bx - The input/output data buffer.
1378 * @param cbData cx - The size of the data buffer.
1379 */
1380 RTFAR16 fpfnServiceAsmEP;
1381} VBOXGUESTOS2IDCCONNECT;
1382/** Pointer to VBOXGUESTOS2IDCCONNECT buffer. */
1383typedef VBOXGUESTOS2IDCCONNECT *PVBOXGUESTOS2IDCCONNECT;
1384
1385/** OS/2 specific: IDC client disconnect request.
1386 *
1387 * This takes no input and it doesn't return anything. Obviously this
1388 * is only recognized if it arrives thru the IDC service EP.
1389 */
1390#define VBOXGUEST_IOCTL_OS2_IDC_DISCONNECT VBOXGUEST_IOCTL_CODE(48, sizeof(uint32_t))
1391
1392#endif /* RT_OS_OS2 */
1393
1394/** @} */
1395
1396
1397#ifdef IN_RING3
1398
1399/** @def VBGLR3DECL
1400 * Ring 3 VBGL declaration.
1401 * @param type The return type of the function declaration.
1402 */
1403#define VBGLR3DECL(type) type VBOXCALL
1404
1405/* General-purpose functions */
1406
1407__BEGIN_DECLS
1408VBGLR3DECL(int) VbglR3Init(void);
1409VBGLR3DECL(void) VbglR3Term(void);
1410# ifdef ___iprt_time_h
1411VBGLR3DECL(int) VbglR3GetHostTime(PRTTIMESPEC pTime);
1412# endif
1413VBGLR3DECL(int) VbglR3InterruptEventWaits(void);
1414VBGLR3DECL(int) VbglR3WriteLog(const char *pch, size_t cb);
1415VBGLR3DECL(int) VbglR3CtlFilterMask(uint32_t fOr, uint32_t fNot);
1416VBGLR3DECL(int) VbglR3Daemonize(bool fNoChDir, bool fNoClose);
1417VBGLR3DECL(int) VbglR3SetGuestCaps(uint32_t fOr, uint32_t fNot);
1418
1419/** @name Shared clipboard
1420 * @{ */
1421VBGLR3DECL(int) VbglR3ClipboardConnect(uint32_t *pu32ClientId);
1422VBGLR3DECL(int) VbglR3ClipboardDisconnect(uint32_t u32ClientId);
1423VBGLR3DECL(int) VbglR3ClipboardGetHostMsg(uint32_t u32ClientId, uint32_t *pMsg, uint32_t *pfFormats);
1424VBGLR3DECL(int) VbglR3ClipboardReadData(uint32_t u32ClientId, uint32_t fFormat, void *pv, uint32_t cb, uint32_t *pcb);
1425VBGLR3DECL(int) VbglR3ClipboardReportFormats(uint32_t u32ClientId, uint32_t fFormats);
1426VBGLR3DECL(int) VbglR3ClipboardWriteData(uint32_t u32ClientId, uint32_t fFormat, void *pv, uint32_t cb);
1427/** @} */
1428
1429/** @name Seamless mode
1430 * @{ */
1431VBGLR3DECL(int) VbglR3SeamlessSetCap(bool fState);
1432VBGLR3DECL(int) VbglR3SeamlessWaitEvent(VMMDevSeamlessMode *pMode);
1433VBGLR3DECL(int) VbglR3SeamlessSendRects(uint32_t cRects, PRTRECT pRects);
1434/** @} */
1435
1436/** @name Mouse
1437 * @{ */
1438VBGLR3DECL(int) VbglR3GetMouseStatus(uint32_t *pfFeatures, uint32_t *px, uint32_t *py);
1439VBGLR3DECL(int) VbglR3SetMouseStatus(uint32_t fFeatures);
1440/** @} */
1441
1442/** @name Video
1443 * @{ */
1444VBGLR3DECL(int) VbglR3VideoAccelEnable(bool fEnable);
1445VBGLR3DECL(int) VbglR3VideoAccelFlush(void);
1446VBGLR3DECL(int) VbglR3SetPointerShape(uint32_t fFlags, uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy, const void *pvImg, size_t cbImg);
1447VBGLR3DECL(int) VbglR3SetPointerShapeReq(VMMDevReqMousePointer *pReq);
1448/** @} */
1449
1450/** @name Display
1451 * @{ */
1452VBGLR3DECL(int) VbglR3GetLastDisplayChangeRequest(uint32_t *pcx, uint32_t *pcy,
1453 uint32_t *pcBits,uint32_t *piDisplay);
1454VBGLR3DECL(int) VbglR3DisplayChangeWaitEvent(uint32_t *pcx, uint32_t *pcy, uint32_t *pcBits,
1455 uint32_t *piDisplay);
1456VBGLR3DECL(bool) VbglR3HostLikesVideoMode(uint32_t cx, uint32_t cy,
1457 uint32_t cBits);
1458/** @} */
1459
1460
1461__END_DECLS
1462
1463#endif /* IN_RING3 */
1464
1465#endif
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use