VirtualBox

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

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

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