VirtualBox

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

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

don't include VBoxGuest.h if we don't need to because it drags in ostypes.h and that conflicts with a core darwin type.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 29.3 KB
Line 
1/** @file
2 * VBoxGuest - VirtualBox Guest Additions interface
3 */
4
5/*
6 * Copyright (C) 2006 InnoTek Systemberatung 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 * If you received this file as part of a commercial VirtualBox
17 * distribution, then only the terms of your commercial VirtualBox
18 * license agreement apply instead of the previous paragraph.
19 */
20
21#ifndef __VBox_VBoxGuest_h__
22#define __VBox_VBoxGuest_h__
23
24#include <iprt/cdefs.h>
25#include <iprt/types.h>
26#include <VBox/err.h>
27#include <VBox/ostypes.h>
28
29/*******************************************************************************
30* Defined Constants And Macros *
31*******************************************************************************/
32
33#ifdef __WIN__
34/** The support service name. */
35#define VBOXGUEST_SERVICE_NAME "VBoxGuest"
36/** Win32 Device name. */
37#define VBOXGUEST_DEVICE_NAME "\\\\.\\VBoxGuest"
38/** Global name for Win2k+ */
39#define VBOXGUEST_DEVICE_NAME_GLOBAL "\\\\.\\Global\\VBoxGuest"
40/** Win32 driver name */
41#define VBOXGUEST_DEVICE_NAME_NT L"\\Device\\VBoxGuest"
42/** device name */
43#define VBOXGUEST_DEVICE_NAME_DOS L"\\DosDevices\\VBoxGuest"
44#else /* !__WIN__ */
45#define VBOXGUEST_DEVICE_NAME "/dev/vboxadd"
46#endif
47
48/** VirtualBox vendor ID */
49#define VBOX_PCI_VENDORID (0x80ee)
50
51/** VMMDev PCI card identifiers */
52#define VMMDEV_VENDORID VBOX_PCI_VENDORID
53#define VMMDEV_DEVICEID (0xcafe)
54
55/** VirtualBox graphics card identifiers */
56#define VBOX_VENDORID VBOX_PCI_VENDORID
57#define VBOX_VESA_VENDORID VBOX_PCI_VENDORID
58#define VBOX_DEVICEID (0xbeef)
59#define VBOX_VESA_DEVICEID (0xbeef)
60
61/**
62 * VBoxGuest port definitions
63 * @{
64 */
65
66/** guest can (== wants to) handle absolute coordinates */
67#define VBOXGUEST_MOUSE_GUEST_CAN_ABSOLUTE BIT(0)
68/** host can (== wants to) send absolute coordinates */
69#define VBOXGUEST_MOUSE_HOST_CAN_ABSOLUTE BIT(1)
70/** guest can *NOT* switch to software cursor and therefore depends on the host cursor */
71#define VBOXGUEST_MOUSE_GUEST_NEEDS_HOST_CURSOR BIT(2)
72/** host does NOT provide support for drawing the cursor itself (e.g. L4 console) */
73#define VBOXGUEST_MOUSE_HOST_CANNOT_HWPOINTER BIT(3)
74
75/** fictive start address of the hypervisor physical memory for MmMapIoSpace */
76#define HYPERVISOR_PHYSICAL_START 0xf8000000
77
78/*
79 * VMMDev Generic Request Interface
80 */
81
82/** port for generic request interface */
83#define PORT_VMMDEV_REQUEST_OFFSET 0
84
85/** Current version of the VMMDev interface.
86 *
87 * Additions are allowed to work only if
88 * additions_major == vmmdev_current && additions_minor <= vmmdev_current.
89 * Additions version is reported to host (VMMDev) by VMMDevReq_ReportGuestInfo.
90 */
91#define VMMDEV_VERSION_MAJOR (0x1)
92#define VMMDEV_VERSION_MINOR (0x4)
93#define VMMDEV_VERSION ((VMMDEV_VERSION_MAJOR << 16) | VMMDEV_VERSION_MINOR)
94
95/**
96 * VMMDev request types.
97 * @note when updating this, adjust vmmdevGetRequestSize() as well
98 */
99typedef enum
100{
101 VMMDevReq_InvalidRequest = 0,
102 VMMDevReq_GetMouseStatus = 1,
103 VMMDevReq_SetMouseStatus = 2,
104 VMMDevReq_SetPointerShape = 3,
105 /** @todo implement on host side */
106 VMMDevReq_GetHostVersion = 4,
107 VMMDevReq_Idle = 5,
108 VMMDevReq_GetHostTime = 10,
109 VMMDevReq_GetHypervisorInfo = 20,
110 VMMDevReq_SetHypervisorInfo = 21,
111 VMMDevReq_SetPowerStatus = 30,
112 VMMDevReq_AcknowledgeEvents = 41,
113 VMMDevReq_CtlGuestFilterMask = 42,
114 VMMDevReq_ReportGuestInfo = 50,
115 VMMDevReq_GetDisplayChangeRequest = 51,
116 VMMDevReq_VideoModeSupported = 52,
117 VMMDevReq_GetHeightReduction = 53,
118#ifdef VBOX_HGCM
119 VMMDevReq_HGCMConnect = 60,
120 VMMDevReq_HGCMDisconnect = 61,
121 VMMDevReq_HGCMCall = 62,
122#endif
123 VMMDevReq_VideoAccelEnable = 70,
124 VMMDevReq_VideoAccelFlush = 71,
125 VMMDevReq_QueryCredentials = 100,
126 VMMDevReq_ReportCredentialsJudgement = 101,
127 VMMDevReq_SizeHack = 0x7fffffff
128} VMMDevRequestType;
129
130/** Version of VMMDevRequestHeader structure. */
131#define VMMDEV_REQUEST_HEADER_VERSION (0x10001)
132
133#pragma pack(4)
134/** generic VMMDev request header */
135typedef struct
136{
137 /** size of the structure in bytes (including body). Filled by caller */
138 uint32_t size;
139 /** version of the structure. Filled by caller */
140 uint32_t version;
141 /** type of the request */
142 VMMDevRequestType requestType;
143 /** return code. Filled by VMMDev */
144 int32_t rc;
145 /** reserved fields */
146 uint32_t reserved1;
147 uint32_t reserved2;
148} VMMDevRequestHeader;
149
150/** mouse status request structure */
151typedef struct
152{
153 /** header */
154 VMMDevRequestHeader header;
155 /** mouse feature mask */
156 uint32_t mouseFeatures;
157 /** mouse x position */
158 uint32_t pointerXPos;
159 /** mouse y position */
160 uint32_t pointerYPos;
161} VMMDevReqMouseStatus;
162
163/** Note VBOX_MOUSE_POINTER_* flags are used in guest video driver,
164 * values must be <= 0x8000 and must not be changed.
165 */
166
167/** pointer is visible */
168#define VBOX_MOUSE_POINTER_VISIBLE (0x0001)
169/** pointer has alpha channel */
170#define VBOX_MOUSE_POINTER_ALPHA (0x0002)
171/** pointerData contains new pointer shape */
172#define VBOX_MOUSE_POINTER_SHAPE (0x0004)
173
174/** mouse pointer shape/visibility change request */
175typedef struct
176{
177 /** header */
178 VMMDevRequestHeader header;
179 /** VBOX_MOUSE_POINTER_* bit flags */
180 uint32_t fFlags;
181 /** x coordinate of hot spot */
182 uint32_t xHot;
183 /** y coordinate of hot spot */
184 uint32_t yHot;
185 /** width of the pointer in pixels */
186 uint32_t width;
187 /** height of the pointer in scanlines */
188 uint32_t height;
189 /** Pointer data.
190 *
191 ****
192 * The data consists of 1 bpp AND mask followed by 32 bpp XOR (color) mask.
193 *
194 * For pointers without alpha channel the XOR mask pixels are 32 bit values: (lsb)BGR0(msb).
195 * For pointers with alpha channel the XOR mask consists of (lsb)BGRA(msb) 32 bit values.
196 *
197 * Guest driver must create the AND mask for pointers with alpha channel, so if host does not
198 * support alpha, the pointer could be displayed as a normal color pointer. The AND mask can
199 * be constructed from alpha values. For example alpha value >= 0xf0 means bit 0 in the AND mask.
200 *
201 * The AND mask is 1 bpp bitmap with byte aligned scanlines. Size of AND mask,
202 * therefore, is cbAnd = (width + 7) / 8 * height. The padding bits at the
203 * end of any scanline are undefined.
204 *
205 * The XOR mask follows the AND mask on the next 4 bytes aligned offset:
206 * uint8_t *pXor = pAnd + (cbAnd + 3) & ~3
207 * Bytes in the gap between the AND and the XOR mask are undefined.
208 * XOR mask scanlines have no gap between them and size of XOR mask is:
209 * cXor = width * 4 * height.
210 ****
211 *
212 * Preallocate 4 bytes for accessing actual data as p->pointerData
213 */
214 char pointerData[4];
215} VMMDevReqMousePointer;
216
217/** host version request structure */
218typedef struct
219{
220 /** header */
221 VMMDevRequestHeader header;
222 /** major version */
223 uint32_t major;
224 /** minor version */
225 uint32_t minor;
226 /** build number */
227 uint32_t build;
228} VMMDevReqHostVersion;
229
230/** idle request structure */
231typedef struct
232{
233 /** header */
234 VMMDevRequestHeader header;
235} VMMDevReqIdle;
236
237/** host time request structure */
238typedef struct
239{
240 /** header */
241 VMMDevRequestHeader header;
242 /** time in milliseconds since unix epoch. Filled by VMMDev. */
243 uint64_t time;
244} VMMDevReqHostTime;
245
246/** hypervisor info structure */
247typedef struct
248{
249 /** header */
250 VMMDevRequestHeader header;
251 /** guest virtual address of proposed hypervisor start */
252 RTGCPTR hypervisorStart;
253 /** hypervisor size in bytes */
254 uint32_t hypervisorSize;
255} VMMDevReqHypervisorInfo;
256
257/** system power requests */
258typedef enum
259{
260 VMMDevPowerState_Invalid = 0,
261 VMMDevPowerState_Pause = 1,
262 VMMDevPowerState_PowerOff = 2,
263 VMMDevPowerState_SaveState = 3,
264 VMMDevPowerState_SizeHack = 0x7fffffff
265} VMMDevPowerState;
266
267/** system power status structure */
268typedef struct
269{
270 /** header */
271 VMMDevRequestHeader header;
272 /** power state request */
273 VMMDevPowerState powerState;
274} VMMDevPowerStateRequest;
275
276/** pending events structure */
277typedef struct
278{
279 /** header */
280 VMMDevRequestHeader header;
281 /** pending event bitmap */
282 uint32_t events;
283} VMMDevEvents;
284
285/** guest filter mask control */
286typedef struct
287{
288 /** header */
289 VMMDevRequestHeader header;
290 /** mask of events to be added to filter */
291 uint32_t u32OrMask;
292 /** mask of events to be removed from filter */
293 uint32_t u32NotMask;
294} VMMDevCtlGuestFilterMask;
295
296/** guest information structure */
297typedef struct VBoxGuestInfo
298{
299 /** The VMMDev interface version expected by additions. */
300 uint32_t additionsVersion;
301 /** guest OS type */
302 OSType osType;
303 /** @todo */
304} VBoxGuestInfo;
305
306/** guest information structure */
307typedef struct
308{
309 /** header */
310 VMMDevRequestHeader header;
311 /** Guest information. */
312 VBoxGuestInfo guestInfo;
313} VMMDevReportGuestInfo;
314
315/** display change request structure */
316typedef struct
317{
318 /** header */
319 VMMDevRequestHeader header;
320 /** horizontal pixel resolution (0 = do not change) */
321 uint32_t xres;
322 /** vertical pixel resolution (0 = do not change) */
323 uint32_t yres;
324 /** bits per pixel (0 = do not change) */
325 uint32_t bpp;
326 /** Flag that the request is an acknowlegement for the VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST.
327 * Values: 0 - just querying, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST - event acknowledged.
328 */
329 uint32_t eventAck;
330} VMMDevDisplayChangeRequest;
331
332/** video mode supported request structure */
333typedef struct
334{
335 /** header */
336 VMMDevRequestHeader header;
337 /** horizontal pixel resolution (input) */
338 uint32_t width;
339 /** vertical pixel resolution (input) */
340 uint32_t height;
341 /** bits per pixel (input) */
342 uint32_t bpp;
343 /** supported flag (output) */
344 bool fSupported;
345} VMMDevVideoModeSupportedRequest;
346
347/** video modes height reduction request structure */
348typedef struct
349{
350 /** header */
351 VMMDevRequestHeader header;
352 /** height reduction in pixels (output) */
353 uint32_t heightReduction;
354} VMMDevGetHeightReductionRequest;
355
356#pragma pack()
357
358#ifdef VBOX_HGCM
359
360/** HGCM flags.
361 * @{
362 */
363#define VBOX_HGCM_REQ_DONE (0x1)
364#define VBOX_HGCM_REQ_CANCELLED (0x2)
365/** @} */
366
367#pragma pack(4)
368typedef struct _VMMDevHGCMRequestHeader
369{
370 /** Request header. */
371 VMMDevRequestHeader header;
372
373 /** HGCM flags. */
374 uint32_t fu32Flags;
375
376 /** Result code. */
377 int32_t result;
378} VMMDevHGCMRequestHeader;
379
380/** HGCM service location types. */
381typedef enum
382{
383 VMMDevHGCMLoc_Invalid = 0,
384 VMMDevHGCMLoc_LocalHost = 1,
385 VMMDevHGCMLoc_LocalHost_Existing = 2,
386 VMMDevHGCMLoc_SizeHack = 0x7fffffff
387} HGCMServiceLocationType;
388
389typedef struct
390{
391 char achName[128];
392} HGCMServiceLocationHost;
393
394typedef struct HGCMSERVICELOCATION
395{
396 /** Type of the location. */
397 HGCMServiceLocationType type;
398
399 union
400 {
401 HGCMServiceLocationHost host;
402 } u;
403} HGCMServiceLocation;
404
405typedef struct
406{
407 /* request header */
408 VMMDevHGCMRequestHeader header;
409
410 /** IN: Description of service to connect to. */
411 HGCMServiceLocation loc;
412
413 /** OUT: Client identifier assigned by local instance of HGCM. */
414 uint32_t u32ClientID;
415} VMMDevHGCMConnect;
416
417typedef struct
418{
419 /* request header */
420 VMMDevHGCMRequestHeader header;
421
422 /** IN: Client identifier. */
423 uint32_t u32ClientID;
424} VMMDevHGCMDisconnect;
425
426typedef enum
427{
428 VMMDevHGCMParmType_Invalid = 0,
429 VMMDevHGCMParmType_32bit = 1,
430 VMMDevHGCMParmType_64bit = 2,
431 VMMDevHGCMParmType_PhysAddr = 3,
432 VMMDevHGCMParmType_LinAddr = 4, /**< In and Out */
433 VMMDevHGCMParmType_LinAddr_In = 5, /**< In (read) */
434 VMMDevHGCMParmType_LinAddr_Out= 6, /**< Out (write) */
435 VMMDevHGCMParmType_SizeHack = 0x7fffffff
436} HGCMFunctionParameterType;
437
438typedef struct _HGCMFUNCTIONPARAMETER
439{
440 HGCMFunctionParameterType type;
441 union
442 {
443 uint32_t value32;
444 uint64_t value64;
445 struct
446 {
447 uint32_t size;
448
449 union
450 {
451 RTGCPHYS physAddr;
452 RTGCPTR linearAddr;
453 } u;
454 } Pointer;
455 } u;
456} HGCMFunctionParameter;
457
458typedef struct
459{
460 /* request header */
461 VMMDevHGCMRequestHeader header;
462
463 /** IN: Client identifier. */
464 uint32_t u32ClientID;
465 /** IN: Service function number. */
466 uint32_t u32Function;
467 /** IN: Number of parameters. */
468 uint32_t cParms;
469 /** Parameters follow in form: HGCMFunctionParameter aParms[X]; */
470} VMMDevHGCMCall;
471#pragma pack()
472
473#define VMMDEV_HGCM_CALL_PARMS(a) ((HGCMFunctionParameter *)((char *)a + sizeof (VMMDevHGCMCall)))
474
475#endif /* VBOX_HGCM */
476
477
478#define VBVA_F_STATUS_ACCEPTED (0x01)
479#define VBVA_F_STATUS_ENABLED (0x02)
480
481#pragma pack(4)
482
483typedef struct _VMMDevVideoAccelEnable
484{
485 /* request header */
486 VMMDevRequestHeader header;
487
488 /** 0 - disable, !0 - enable. */
489 uint32_t u32Enable;
490
491 /** The size of VBVAMEMORY::au8RingBuffer expected by driver.
492 * The host will refuse to enable VBVA if the size is not equal to
493 * VBVA_RING_BUFFER_SIZE.
494 */
495 uint32_t cbRingBuffer;
496
497 /** Guest initializes the status to 0. Host sets appropriate VBVA_F_STATUS_ flags. */
498 uint32_t fu32Status;
499
500} VMMDevVideoAccelEnable;
501
502typedef struct _VMMDevVideoAccelFlush
503{
504 /* request header */
505 VMMDevRequestHeader header;
506
507} VMMDevVideoAccelFlush;
508
509#pragma pack()
510
511#pragma pack(1)
512
513/** VBVA command header. */
514typedef struct _VBVACMDHDR
515{
516 /** Coordinates of affected rectangle. */
517 int16_t x;
518 int16_t y;
519 uint16_t w;
520 uint16_t h;
521} VBVACMDHDR;
522
523/* VBVA order codes. Must be >= 0, because the VRDP server internally
524 * uses negative values to mark some operations.
525 * Values are important since they are used as an index in the
526 * "supported orders" bit mask.
527 */
528#define VBVA_VRDP_DIRTY_RECT (0)
529#define VBVA_VRDP_SOLIDRECT (1)
530#define VBVA_VRDP_SOLIDBLT (2)
531#define VBVA_VRDP_DSTBLT (3)
532#define VBVA_VRDP_SCREENBLT (4)
533#define VBVA_VRDP_PATBLT_BRUSH (5)
534#define VBVA_VRDP_MEMBLT (6)
535#define VBVA_VRDP_CACHED_BITMAP (7)
536#define VBVA_VRDP_DELETED_BITMAP (8)
537#define VBVA_VRDP_LINE (9)
538#define VBVA_VRDP_BOUNDS (10)
539#define VBVA_VRDP_REPEAT (11)
540#define VBVA_VRDP_POLYLINE (12)
541#define VBVA_VRDP_ELLIPSE (13)
542#define VBVA_VRDP_SAVESCREEN (14)
543
544#define VBVA_VRDP_INDEX_TO_BIT(__index) (1 << (__index))
545
546/* 128 bit bitmap hash. */
547typedef uint8_t VRDPBITMAPHASH[16];
548
549typedef struct _VRDPORDERPOINT
550{
551 int16_t x;
552 int16_t y;
553} VRDPORDERPOINT;
554
555typedef struct _VRDPORDERPOLYPOINTS
556{
557 uint8_t c;
558 VRDPORDERPOINT a[16];
559} VRDPORDERPOLYPOINTS;
560
561typedef struct _VRDPORDERAREA
562{
563 int16_t x;
564 int16_t y;
565 uint16_t w;
566 uint16_t h;
567} VRDPORDERAREA;
568
569typedef struct _VRDPORDERBOUNDS
570{
571 VRDPORDERPOINT pt1;
572 VRDPORDERPOINT pt2;
573} VRDPORDERBOUNDS;
574
575typedef struct _VRDPORDERREPEAT
576{
577 VRDPORDERBOUNDS bounds;
578} VRDPORDERREPEAT;
579
580
581/* Header for bitmap bits in VBVA VRDP operations. */
582typedef struct _VRDPDATABITS
583{
584 /* Size of bitmap data without the header. */
585 uint32_t cb;
586 int16_t x;
587 int16_t y;
588 uint16_t cWidth;
589 uint16_t cHeight;
590 uint8_t cbPixel;
591} VRDPDATABITS;
592
593typedef struct _VRDPORDERSOLIDRECT
594{
595 int16_t x;
596 int16_t y;
597 uint16_t w;
598 uint16_t h;
599 uint32_t rgb;
600} VRDPORDERSOLIDRECT;
601
602typedef struct _VRDPORDERSOLIDBLT
603{
604 int16_t x;
605 int16_t y;
606 uint16_t w;
607 uint16_t h;
608 uint32_t rgb;
609 uint8_t rop;
610} VRDPORDERSOLIDBLT;
611
612typedef struct _VRDPORDERDSTBLT
613{
614 int16_t x;
615 int16_t y;
616 uint16_t w;
617 uint16_t h;
618 uint8_t rop;
619} VRDPORDERDSTBLT;
620
621typedef struct _VRDPORDERSCREENBLT
622{
623 int16_t x;
624 int16_t y;
625 uint16_t w;
626 uint16_t h;
627 int16_t xSrc;
628 int16_t ySrc;
629 uint8_t rop;
630} VRDPORDERSCREENBLT;
631
632typedef struct _VRDPORDERPATBLTBRUSH
633{
634 int16_t x;
635 int16_t y;
636 uint16_t w;
637 uint16_t h;
638 int8_t xSrc;
639 int8_t ySrc;
640 uint32_t rgbFG;
641 uint32_t rgbBG;
642 uint8_t rop;
643 uint8_t pattern[8];
644} VRDPORDERPATBLTBRUSH;
645
646typedef struct _VRDPORDERMEMBLT
647{
648 int16_t x;
649 int16_t y;
650 uint16_t w;
651 uint16_t h;
652 int16_t xSrc;
653 int16_t ySrc;
654 uint8_t rop;
655 VRDPBITMAPHASH hash;
656} VRDPORDERMEMBLT;
657
658typedef struct _VRDPORDERCACHEDBITMAP
659{
660 VRDPBITMAPHASH hash;
661 /* VRDPDATABITS and the bitmap data follows. */
662} VRDPORDERCACHEDBITMAP;
663
664typedef struct _VRDPORDERDELETEDBITMAP
665{
666 VRDPBITMAPHASH hash;
667} VRDPORDERDELETEDBITMAP;
668
669typedef struct _VRDPORDERLINE
670{
671 int16_t x1;
672 int16_t y1;
673 int16_t x2;
674 int16_t y2;
675 int16_t xBounds1;
676 int16_t yBounds1;
677 int16_t xBounds2;
678 int16_t yBounds2;
679 uint8_t mix;
680 uint32_t rgb;
681} VRDPORDERLINE;
682
683typedef struct _VRDPORDERPOLYLINE
684{
685 VRDPORDERPOINT ptStart;
686 uint8_t mix;
687 uint32_t rgb;
688 VRDPORDERPOLYPOINTS points;
689} VRDPORDERPOLYLINE;
690
691typedef struct _VRDPORDERELLIPSE
692{
693 VRDPORDERPOINT pt1;
694 VRDPORDERPOINT pt2;
695 uint8_t mix;
696 uint8_t fillMode;
697 uint32_t rgb;
698} VRDPORDERELLIPSE;
699
700typedef struct _VRDPORDERSAVESCREEN
701{
702 VRDPORDERPOINT pt1;
703 VRDPORDERPOINT pt2;
704 uint8_t ident;
705 uint8_t restore;
706} VRDPORDERSAVESCREEN;
707#pragma pack()
708
709/* The VBVA ring buffer is suitable for transferring large (< 2gb) amount of data.
710 * For example big bitmaps which do not fit to the buffer.
711 *
712 * Guest starts writing to the buffer by initializing a record entry in the
713 * aRecords queue. VBVA_F_RECORD_PARTIAL indicates that the record is being
714 * written. As data is written to the ring buffer, the guest increases off32End
715 * for the record.
716 *
717 * The host reads the aRecords on flushes and processes all completed records.
718 * When host encounters situation when only a partial record presents and
719 * cbRecord & ~VBVA_F_RECORD_PARTIAL >= VBVA_RING_BUFFER_SIZE - VBVA_RING_BUFFER_THRESHOLD,
720 * the host fetched all record data and updates off32Head. After that on each flush
721 * the host continues fetching the data until the record is completed.
722 *
723 */
724
725#define VBVA_RING_BUFFER_SIZE (_4M - _1K)
726#define VBVA_RING_BUFFER_THRESHOLD (4 * _1K)
727
728#define VBVA_MAX_RECORDS (64)
729
730#define VBVA_F_MODE_ENABLED (0x00000001)
731#define VBVA_F_MODE_VRDP (0x00000002)
732#define VBVA_F_MODE_VRDP_RESET (0x00000004)
733#define VBVA_F_MODE_VRDP_ORDER_MASK (0x00000008)
734
735#define VBVA_F_RECORD_PARTIAL (0x80000000)
736
737#pragma pack(1)
738typedef struct _VBVARECORD
739{
740 /** The length of the record. Changed by guest. */
741 uint32_t cbRecord;
742} VBVARECORD;
743
744typedef struct _VBVAMEMORY
745{
746 /** VBVA_F_MODE_* */
747 uint32_t fu32ModeFlags;
748
749 /** The offset where the data start in the buffer. */
750 uint32_t off32Data;
751 /** The offset where next data must be placed in the buffer. */
752 uint32_t off32Free;
753
754 /** The ring buffer for data. */
755 uint8_t au8RingBuffer[VBVA_RING_BUFFER_SIZE];
756
757 /** The queue of record descriptions. */
758 VBVARECORD aRecords[VBVA_MAX_RECORDS];
759 uint32_t indexRecordFirst;
760 uint32_t indexRecordFree;
761
762 /* RDP orders supported by the client. The guest reports only them
763 * and falls back to DIRTY rects for not supported ones.
764 *
765 * (1 << VBVA_VRDP_*)
766 */
767 uint32_t fu32SupportedOrders;
768
769} VBVAMEMORY;
770#pragma pack()
771
772/** @} */
773
774
775/**
776 * VMMDev RAM
777 * @{
778 */
779
780#pragma pack(1)
781/** Layout of VMMDEV RAM region that contains information for guest */
782typedef struct
783{
784 /** size */
785 uint32_t u32Size;
786 /** version */
787 uint32_t u32Version;
788
789 union {
790 /** Flag telling that VMMDev set the IRQ and acknowlegment is required */
791 struct {
792 bool fHaveEvents;
793 } V1_04;
794
795 struct {
796 /** Pending events flags, set by host. */
797 uint32_t u32HostEvents;
798 /** Mask of events the guest wants to see, set by guest. */
799 uint32_t u32GuestEventMask;
800 } V1_03;
801 } V;
802
803 VBVAMEMORY vbvaMemory;
804
805} VMMDevMemory;
806#pragma pack()
807
808/** Version of VMMDevMemory structure. */
809#define VMMDEV_MEMORY_VERSION (1)
810
811/** @} */
812
813
814/**
815 * VMMDev events.
816 * @{
817 */
818
819/** Host mouse capabilities has been changed. */
820#define VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED BIT(0)
821/** HGCM event. */
822#define VMMDEV_EVENT_HGCM BIT(1)
823/** A display change request has been issued. */
824#define VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST BIT(2)
825/** Credentials are available for judgement. */
826#define VMMDEV_EVENT_JUDGE_CREDENTIALS BIT(3)
827/** The guest has been restored. */
828#define VMMDEV_EVENT_RESTORED BIT(4)
829
830/** @} */
831
832
833/**
834 * VBoxGuest IOCTL codes and structures.
835 * @{
836 * IOCTL function numbers start from 2048, because MSDN says the
837 * second parameter of CTL_CODE macro (function) must be <= 2048 and <= 4095 for IHVs.
838 * The IOCTL number algorithm corresponds to CTL_CODE on Windows but for Linux IOCTLs,
839 * we also encode the data size, so we need an additional parameter.
840 */
841#if defined(__WIN__)
842#define IOCTL_CODE(DeviceType, Function, Method, Access, DataSize_ignored) \
843 ( ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
844#else /* unix: */
845#define IOCTL_CODE(DeviceType, Function, Method_ignored, Access_ignored, DataSize) \
846 ( (3 << 30) | ((DeviceType) << 8) | (Function) | ((DataSize) << 16) )
847#define METHOD_BUFFERED 0
848#define FILE_WRITE_ACCESS 0x0002
849#define FILE_DEVICE_UNKNOWN 0x00000022
850#endif
851
852/** IOCTL to VBoxGuest to query the VMMDev IO port region start. */
853#define IOCTL_VBOXGUEST_GETVMMDEVPORT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2048, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestPortInfo))
854
855#pragma pack(4)
856typedef struct _VBoxGuestPortInfo
857{
858 uint32_t portAddress;
859 VMMDevMemory *pVMMDevMemory;
860} VBoxGuestPortInfo;
861
862/** IOCTL to VBoxGuest to wait for a VMMDev host notification */
863#define IOCTL_VBOXGUEST_WAITEVENT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2049, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestWaitEventInfo))
864
865/**
866 * Result codes for VBoxGuestWaitEventInfo::u32Result
867 * @{
868 */
869/** Successful completion, an event occured. */
870#define VBOXGUEST_WAITEVENT_OK (0)
871/** Successful completion, timed out. */
872#define VBOXGUEST_WAITEVENT_TIMEOUT (1)
873/** Wait was interrupted. */
874#define VBOXGUEST_WAITEVENT_INTERRUPTED (2)
875/** An error occured while processing the request. */
876#define VBOXGUEST_WAITEVENT_ERROR (3)
877/** @} */
878
879/** Input and output buffers layout of the IOCTL_VBOXGUEST_WAITEVENT */
880typedef struct _VBoxGuestWaitEventInfo
881{
882 /** timeout in milliseconds */
883 uint32_t u32TimeoutIn;
884 /** events to wait for */
885 uint32_t u32EventMaskIn;
886 /** result code */
887 uint32_t u32Result;
888 /** events occured */
889 uint32_t u32EventFlagsOut;
890} VBoxGuestWaitEventInfo;
891
892/** IOCTL to VBoxGuest to perform a VMM request */
893#define IOCTL_VBOXGUEST_VMMREQUEST IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2050, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VMMDevRequestHeader))
894
895/** IOCTL to VBoxGuest to control event filter mask */
896
897typedef struct _VBoxGuestFilterMaskInfo
898{
899 uint32_t u32OrMask;
900 uint32_t u32NotMask;
901} VBoxGuestFilterMaskInfo;
902#pragma pack()
903
904#define IOCTL_VBOXGUEST_CTL_FILTER_MASK IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2051, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof (VBoxGuestFilterMaskInfo))
905
906#ifdef VBOX_HGCM
907/* These structures are shared between the driver and other binaries,
908 * therefore packing must be defined explicitely.
909 */
910#pragma pack(1)
911typedef struct _VBoxGuestHGCMConnectInfo
912{
913 uint32_t result; /**< OUT */
914 HGCMServiceLocation Loc; /**< IN */
915 uint32_t u32ClientID; /**< OUT */
916} VBoxGuestHGCMConnectInfo;
917
918typedef struct _VBoxGuestHGCMDisconnectInfo
919{
920 uint32_t result; /**< OUT */
921 uint32_t u32ClientID; /**< IN */
922} VBoxGuestHGCMDisconnectInfo;
923
924typedef struct _VBoxGuestHGCMCallInfo
925{
926 uint32_t result; /**< OUT Host HGCM return code.*/
927 uint32_t u32ClientID; /**< IN The id of the caller. */
928 uint32_t u32Function; /**< IN Function number. */
929 uint32_t cParms; /**< IN How many parms. */
930 /* Parameters follow in form HGCMFunctionParameter aParms[cParms] */
931} VBoxGuestHGCMCallInfo;
932#pragma pack()
933
934#define IOCTL_VBOXGUEST_HGCM_CONNECT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3072, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMConnectInfo))
935#define IOCTL_VBOXGUEST_HGCM_DISCONNECT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3073, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMDisconnectInfo))
936#define IOCTL_VBOXGUEST_HGCM_CALL IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3074, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMCallInfo))
937
938#define VBOXGUEST_HGCM_CALL_PARMS(a) ((HGCMFunctionParameter *)((uint8_t *)(a) + sizeof (VBoxGuestHGCMCallInfo)))
939
940#endif /* VBOX_HGCM */
941
942/*
943 * Credentials request flags and structure
944 */
945
946#define VMMDEV_CREDENTIALS_STRLEN 128
947
948/** query from host whether credentials are present */
949#define VMMDEV_CREDENTIALS_QUERYPRESENCE BIT(1)
950/** read credentials from host (can be combined with clear) */
951#define VMMDEV_CREDENTIALS_READ BIT(2)
952/** clear credentials on host (can be combined with read) */
953#define VMMDEV_CREDENTIALS_CLEAR BIT(3)
954/** read credentials for judgement in the guest */
955#define VMMDEV_CREDENTIALS_READJUDGE BIT(8)
956/** clear credentials for judegement on the host */
957#define VMMDEV_CREDENTIALS_CLEARJUDGE BIT(9)
958/** report credentials acceptance by guest */
959#define VMMDEV_CREDENTIALS_JUDGE_OK BIT(10)
960/** report credentials denial by guest */
961#define VMMDEV_CREDENTIALS_JUDGE_DENY BIT(11)
962/** report that no judgement could be made by guest */
963#define VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT BIT(12)
964
965/** flag telling the guest that credentials are present */
966#define VMMDEV_CREDENTIALS_PRESENT BIT(16)
967/** flag telling guest that local logons should be prohibited */
968#define VMMDEV_CREDENTIALS_NOLOCALLOGON BIT(17)
969
970/** credentials request structure */
971#pragma pack(4)
972typedef struct _VMMDevCredentials
973{
974 /* request header */
975 VMMDevRequestHeader header;
976 /* request flags (in/out) */
977 uint32_t u32Flags;
978 /* user name (UTF-8) (out) */
979 char szUserName[VMMDEV_CREDENTIALS_STRLEN];
980 /* password (UTF-8) (out) */
981 char szPassword[VMMDEV_CREDENTIALS_STRLEN];
982 /* domain name (UTF-8) (out) */
983 char szDomain[VMMDEV_CREDENTIALS_STRLEN];
984} VMMDevCredentials;
985#pragma pack()
986
987/** inline helper to determine the request size for the given operation */
988DECLINLINE(size_t) vmmdevGetRequestSize(VMMDevRequestType requestType)
989{
990 switch (requestType)
991 {
992 case VMMDevReq_GetMouseStatus:
993 case VMMDevReq_SetMouseStatus:
994 return sizeof(VMMDevReqMouseStatus);
995 case VMMDevReq_SetPointerShape:
996 return sizeof(VMMDevReqMousePointer);
997 case VMMDevReq_GetHostVersion:
998 return sizeof(VMMDevReqHostVersion);
999 case VMMDevReq_Idle:
1000 return sizeof(VMMDevReqIdle);
1001 case VMMDevReq_GetHostTime:
1002 return sizeof(VMMDevReqHostTime);
1003 case VMMDevReq_GetHypervisorInfo:
1004 case VMMDevReq_SetHypervisorInfo:
1005 return sizeof(VMMDevReqHypervisorInfo);
1006 case VMMDevReq_SetPowerStatus:
1007 return sizeof(VMMDevPowerStateRequest);
1008 case VMMDevReq_AcknowledgeEvents:
1009 return sizeof(VMMDevEvents);
1010 case VMMDevReq_ReportGuestInfo:
1011 return sizeof(VMMDevReportGuestInfo);
1012 case VMMDevReq_GetDisplayChangeRequest:
1013 return sizeof(VMMDevDisplayChangeRequest);
1014 case VMMDevReq_VideoModeSupported:
1015 return sizeof(VMMDevVideoModeSupportedRequest);
1016 case VMMDevReq_GetHeightReduction:
1017 return sizeof(VMMDevGetHeightReductionRequest);
1018#ifdef VBOX_HGCM
1019 case VMMDevReq_HGCMConnect:
1020 return sizeof(VMMDevHGCMConnect);
1021 case VMMDevReq_HGCMDisconnect:
1022 return sizeof(VMMDevHGCMDisconnect);
1023 case VMMDevReq_HGCMCall:
1024 return sizeof(VMMDevHGCMCall);
1025#endif
1026 case VMMDevReq_VideoAccelEnable:
1027 return sizeof(VMMDevVideoAccelEnable);
1028 case VMMDevReq_VideoAccelFlush:
1029 return sizeof(VMMDevVideoAccelFlush);
1030 case VMMDevReq_QueryCredentials:
1031 return sizeof(VMMDevCredentials);
1032 default:
1033 return 0;
1034 }
1035}
1036
1037/**
1038 * Initializes a request structure.
1039 *
1040 */
1041DECLINLINE(int) vmmdevInitRequest(VMMDevRequestHeader *req, VMMDevRequestType type)
1042{
1043 uint32_t requestSize;
1044 if (!req)
1045 return VERR_INVALID_PARAMETER;
1046 requestSize = (uint32_t)vmmdevGetRequestSize(type);
1047 if (!requestSize)
1048 return VERR_INVALID_PARAMETER;
1049 req->size = requestSize;
1050 req->version = VMMDEV_REQUEST_HEADER_VERSION;
1051 req->requestType = type;
1052 req->rc = VERR_GENERAL_FAILURE;
1053 req->reserved1 = 0;
1054 req->reserved2 = 0;
1055 return VINF_SUCCESS;
1056}
1057
1058/** @} */
1059
1060#endif /* __VBox_VBoxGuest_h__ */
Note: See TracBrowser for help on using the repository browser.

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