VirtualBox

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

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

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