VirtualBox

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

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

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