VirtualBox

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

Last change on this file since 4492 was 4492, checked in by vboxsync, 18 years ago

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

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