VirtualBox

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

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

Renamed
  • 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 * VBoxGuest IOCTL codes and structures.
901 *
902 * The range 0..15 is for basic driver communication.
903 * The range 16..31 is for HGCM communcation.
904 * The range 32..47 is reserved for future use.
905 * The range 48..63 is for OS specific communcation.
906 * The 7th bit is reserved for future hacks.
907 * The 8th bit is reserved for distinguishing between 32-bit and 64-bit
908 * processes in future 64-bit guest additions.
909 *
910 * While windows IOCTL function number has to start at 2048 and stop at 4096 there
911 * never was any need to do this for everyone. A simple ((Function) | 0x800) would
912 * have sufficed. On Linux we're now intruding upon the type field. Fortunately
913 * this hasn't caused any trouble because the FILE_DEVICE_UNKNOWN value was set
914 * to 0x22 (if it were 0x2C it would not have worked soo smoothly). The situation
915 * would've been the same for *BSD and Darwin since they seems to share common
916 * _IOC() heritage.
917 *
918 * However, on good old OS/2 we only have 8-bit handy for the function number. The
919 * result from using the old IOCTL function numbers her would've been overlapping
920 * between the two ranges.
921 *
922 * To fix this problem and get rid of all the unnecessary windowsy crap that I
923 * bet was copied from my SUPDRVIOC.h once upon a time (although the concept of
924 * prefixing macros with the purpose of avoid clashes with system stuff and
925 * to indicate exactly how owns them seems to have been lost somewhere along
926 * the way), I've introduced a VBOXGUEST_IOCTL_CODE for defining generic IN/OUT
927 * IOCtls on new ports of the additions.
928 *
929 * @remark When creating new IOCtl interfaces keep in mind that not all OSes supports
930 * reporting back the output size. (This got messed up a little bit in VBoxDrv.)
931 *
932 * OS/2 restricts the in/out data size to 64KB, while Linux, BSD and Darwin are
933 * limited by a 14 bits size field (16KB). So, special considerations need to
934 * be taken if more input/output needs to be passed around.
935 *
936 * When passing variable sized input/output special care need to be taken on
937 * Unix platforms (if we're going to play by the rules) since the size is
938 * passed as part of the IOCtl code there. IIRC Darwin will use the size to
939 * perform locking and in/out copying, I don't quite know about linux and *BSD.
940 *
941 * @remark If adding interfaces that only has input or only has output, some new macros
942 * needs to be created so the most efficient IOCtl data buffering method can be
943 * used.
944 *
945 * @{
946 */
947#ifdef __AMD64__
948# define VBOXGUEST_IOCTL_FLAG 128
949#elif defined(__X86__)
950# define VBOXGUEST_IOCTL_FLAG 0
951#else
952# error "dunno which arch this is!"
953#endif
954
955#if defined(__WIN__)
956# define IOCTL_CODE(DeviceType, Function, Method, Access, DataSize_ignored) \
957 ( ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
958
959#elif defined(__OS2__)
960# define VBOXGUEST_IOCTL_CATEGORY 0xc2
961# define VBOXGUEST_IOCTL_CODE(Function, Size) ((unsigned char)(Function))
962# define VBOXGUEST_IOCTL_CATEGORY_FAST 0xc3 /**< Also defined in VBoxGuestA-os2.asm. */
963# define VBOXGUEST_IOCTL_CODE_FAST(Function) ((unsigned char)(Function))
964
965#elif defined(__LINUX__)
966# define IOCTL_CODE(DeviceType, Function, Method_ignored, Access_ignored, DataSize) \
967 ( (3 << 30) | ((DeviceType) << 8) | (Function) | ((DataSize) << 16) )
968# define METHOD_BUFFERED 0
969# define FILE_WRITE_ACCESS 0x0002
970# define FILE_DEVICE_UNKNOWN 0x00000022
971
972#elif 0 /* BSD style - needs some adjusting _IORW takes a type and not a size. */
973# include <sys/ioccom.h>
974# define VBOXGUEST_IOCTL_CODE(Function, Size) _IORW('V', (Function) | VBOXGUEST_IOCTL_FLAG, (Size))
975# define VBOXGUEST_IOCTL_CODE_FAST(Function) _IO( 'V', (Function) | VBOXGUEST_IOCTL_FLAG)
976
977#else
978/* PORTME */
979#endif
980
981/** IOCTL to VBoxGuest to query the VMMDev IO port region start. */
982#ifdef VBOXGUEST_IOCTL_CODE
983# define VBOXGUEST_IOCTL_GETVMMDEVPORT VBOXGUEST_IOCTL_CODE(1, sizeof(VBoxGuestPortInfo))
984# define IOCTL_VBOXGUEST_GETVMMDEVPORT VBOXGUEST_IOCTL_GETVMMDEVPORT
985#else
986# define IOCTL_VBOXGUEST_GETVMMDEVPORT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2048, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestPortInfo))
987#endif
988
989#pragma pack(4)
990typedef struct _VBoxGuestPortInfo
991{
992 uint32_t portAddress;
993 VMMDevMemory *pVMMDevMemory;
994} VBoxGuestPortInfo;
995
996/** IOCTL to VBoxGuest to wait for a VMMDev host notification */
997#ifdef VBOXGUEST_IOCTL_CODE
998# define VBOXGUEST_IOCTL_WAITEVENT VBOXGUEST_IOCTL_CODE(2, sizeof(VBoxGuestWaitEventInfo))
999# define IOCTL_VBOXGUEST_WAITEVENT VBOXGUEST_IOCTL_WAITEVENT
1000#else
1001# define IOCTL_VBOXGUEST_WAITEVENT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2049, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestWaitEventInfo))
1002#endif
1003
1004/**
1005 * Result codes for VBoxGuestWaitEventInfo::u32Result
1006 * @{
1007 */
1008/** Successful completion, an event occured. */
1009#define VBOXGUEST_WAITEVENT_OK (0)
1010/** Successful completion, timed out. */
1011#define VBOXGUEST_WAITEVENT_TIMEOUT (1)
1012/** Wait was interrupted. */
1013#define VBOXGUEST_WAITEVENT_INTERRUPTED (2)
1014/** An error occured while processing the request. */
1015#define VBOXGUEST_WAITEVENT_ERROR (3)
1016/** @} */
1017
1018/** Input and output buffers layout of the IOCTL_VBOXGUEST_WAITEVENT */
1019typedef struct _VBoxGuestWaitEventInfo
1020{
1021 /** timeout in milliseconds */
1022 uint32_t u32TimeoutIn;
1023 /** events to wait for */
1024 uint32_t u32EventMaskIn;
1025 /** result code */
1026 uint32_t u32Result;
1027 /** events occured */
1028 uint32_t u32EventFlagsOut;
1029} VBoxGuestWaitEventInfo;
1030
1031/** IOCTL to VBoxGuest to perform a VMM request
1032 * @remark The data buffer for this IOCtl has an variable size, keep this in mind
1033 * on systems where this matters. */
1034#ifdef VBOXGUEST_IOCTL_CODE
1035# define VBOXGUEST_IOCTL_VMMREQUEST(Size) VBOXGUEST_IOCTL_CODE(3, sizeof(VMMDevRequestHeader))
1036# define IOCTL_VBOXGUEST_VMMREQUEST VBOXGUEST_IOCTL_VMMREQUEST(sizeof(VMMDevRequestHeader))
1037#else
1038# define IOCTL_VBOXGUEST_VMMREQUEST IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2050, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VMMDevRequestHeader))
1039#endif
1040
1041/** Input and output buffer layout of the IOCTL_VBOXGUEST_CTL_FILTER_MASK. */
1042typedef struct _VBoxGuestFilterMaskInfo
1043{
1044 uint32_t u32OrMask;
1045 uint32_t u32NotMask;
1046} VBoxGuestFilterMaskInfo;
1047#pragma pack()
1048
1049/** IOCTL to VBoxGuest to control event filter mask */
1050#ifdef VBOXGUEST_IOCTL_CODE
1051# define VBOXGUEST_IOCTL_CTL_FILTER_MASK VBOXGUEST_IOCTL_CODE(4, sizeof(VBoxGuestFilterMaskInfo))
1052# define IOCTL_VBOXGUEST_CTL_FILTER_MASK VBOXGUEST_IOCTL_CTL_FILTER_MASK
1053#else
1054# define IOCTL_VBOXGUEST_CTL_FILTER_MASK IOCTL_CODE(FILE_DEVICE_UNKNOWN, 2051, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof (VBoxGuestFilterMaskInfo))
1055#endif
1056
1057#ifdef VBOX_HGCM
1058/* These structures are shared between the driver and other binaries,
1059 * therefore packing must be defined explicitely.
1060 */
1061#pragma pack(1)
1062typedef struct _VBoxGuestHGCMConnectInfo
1063{
1064 uint32_t result; /**< OUT */
1065 HGCMServiceLocation Loc; /**< IN */
1066 uint32_t u32ClientID; /**< OUT */
1067} VBoxGuestHGCMConnectInfo;
1068
1069typedef struct _VBoxGuestHGCMDisconnectInfo
1070{
1071 uint32_t result; /**< OUT */
1072 uint32_t u32ClientID; /**< IN */
1073} VBoxGuestHGCMDisconnectInfo;
1074
1075typedef struct _VBoxGuestHGCMCallInfo
1076{
1077 uint32_t result; /**< OUT Host HGCM return code.*/
1078 uint32_t u32ClientID; /**< IN The id of the caller. */
1079 uint32_t u32Function; /**< IN Function number. */
1080 uint32_t cParms; /**< IN How many parms. */
1081 /* Parameters follow in form HGCMFunctionParameter aParms[cParms] */
1082} VBoxGuestHGCMCallInfo;
1083#pragma pack()
1084
1085#ifdef VBOXGUEST_IOCTL_CODE
1086# define VBOXGUEST_IOCTL_HGCM_CONNECT VBOXGUEST_IOCTL_CODE(16, sizeof(VBoxGuestHGCMConnectInfo))
1087# define IOCTL_VBOXGUEST_HGCM_CONNECT VBOXGUEST_IOCTL_HGCM_CONNECT
1088# define VBOXGUEST_IOCTL_HGCM_DISCONNECT VBOXGUEST_IOCTL_CODE(17, sizeof(VBoxGuestHGCMDisconnectInfo))
1089# define IOCTL_VBOXGUEST_HGCM_DISCONNECT VBOXGUEST_IOCTL_HGCM_DISCONNECT
1090# define VBOXGUEST_IOCTL_HGCM_CALL(Size) VBOXGUEST_IOCTL_CODE(18, (Size))
1091# define IOCTL_VBOXGUEST_HGCM_CALL VBOXGUEST_IOCTL_HGCM_CALL(sizeof(VBoxGuestHGCMCallInfo))
1092# define VBOXGUEST_IOCTL_CLIPBOARD_CONNECT VBOXGUEST_IOCTL_CODE(19, sizeof(uint32_t))
1093# define IOCTL_VBOXGUEST_CLIPBOARD_CONNECT VBOXGUEST_IOCTL_CLIPBOARD_CONNECT
1094#else
1095# define IOCTL_VBOXGUEST_HGCM_CONNECT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3072, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMConnectInfo))
1096# define IOCTL_VBOXGUEST_HGCM_DISCONNECT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3073, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMDisconnectInfo))
1097# define IOCTL_VBOXGUEST_HGCM_CALL IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3074, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(VBoxGuestHGCMCallInfo))
1098# define IOCTL_VBOXGUEST_CLIPBOARD_CONNECT IOCTL_CODE(FILE_DEVICE_UNKNOWN, 3075, METHOD_BUFFERED, FILE_WRITE_ACCESS, sizeof(uint32_t))
1099#endif
1100
1101#define VBOXGUEST_HGCM_CALL_PARMS(a) ((HGCMFunctionParameter *)((uint8_t *)(a) + sizeof (VBoxGuestHGCMCallInfo)))
1102
1103#endif /* VBOX_HGCM */
1104
1105/*
1106 * Credentials request flags and structure
1107 */
1108
1109#define VMMDEV_CREDENTIALS_STRLEN 128
1110
1111/** query from host whether credentials are present */
1112#define VMMDEV_CREDENTIALS_QUERYPRESENCE BIT(1)
1113/** read credentials from host (can be combined with clear) */
1114#define VMMDEV_CREDENTIALS_READ BIT(2)
1115/** clear credentials on host (can be combined with read) */
1116#define VMMDEV_CREDENTIALS_CLEAR BIT(3)
1117/** read credentials for judgement in the guest */
1118#define VMMDEV_CREDENTIALS_READJUDGE BIT(8)
1119/** clear credentials for judegement on the host */
1120#define VMMDEV_CREDENTIALS_CLEARJUDGE BIT(9)
1121/** report credentials acceptance by guest */
1122#define VMMDEV_CREDENTIALS_JUDGE_OK BIT(10)
1123/** report credentials denial by guest */
1124#define VMMDEV_CREDENTIALS_JUDGE_DENY BIT(11)
1125/** report that no judgement could be made by guest */
1126#define VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT BIT(12)
1127
1128/** flag telling the guest that credentials are present */
1129#define VMMDEV_CREDENTIALS_PRESENT BIT(16)
1130/** flag telling guest that local logons should be prohibited */
1131#define VMMDEV_CREDENTIALS_NOLOCALLOGON BIT(17)
1132
1133/** credentials request structure */
1134#pragma pack(4)
1135typedef struct _VMMDevCredentials
1136{
1137 /* request header */
1138 VMMDevRequestHeader header;
1139 /* request flags (in/out) */
1140 uint32_t u32Flags;
1141 /* user name (UTF-8) (out) */
1142 char szUserName[VMMDEV_CREDENTIALS_STRLEN];
1143 /* password (UTF-8) (out) */
1144 char szPassword[VMMDEV_CREDENTIALS_STRLEN];
1145 /* domain name (UTF-8) (out) */
1146 char szDomain[VMMDEV_CREDENTIALS_STRLEN];
1147} VMMDevCredentials;
1148#pragma pack()
1149
1150/** inline helper to determine the request size for the given operation */
1151DECLINLINE(size_t) vmmdevGetRequestSize(VMMDevRequestType requestType)
1152{
1153 switch (requestType)
1154 {
1155 case VMMDevReq_GetMouseStatus:
1156 case VMMDevReq_SetMouseStatus:
1157 return sizeof(VMMDevReqMouseStatus);
1158 case VMMDevReq_SetPointerShape:
1159 return sizeof(VMMDevReqMousePointer);
1160 case VMMDevReq_GetHostVersion:
1161 return sizeof(VMMDevReqHostVersion);
1162 case VMMDevReq_Idle:
1163 return sizeof(VMMDevReqIdle);
1164 case VMMDevReq_GetHostTime:
1165 return sizeof(VMMDevReqHostTime);
1166 case VMMDevReq_GetHypervisorInfo:
1167 case VMMDevReq_SetHypervisorInfo:
1168 return sizeof(VMMDevReqHypervisorInfo);
1169 case VMMDevReq_SetPowerStatus:
1170 return sizeof(VMMDevPowerStateRequest);
1171 case VMMDevReq_AcknowledgeEvents:
1172 return sizeof(VMMDevEvents);
1173 case VMMDevReq_ReportGuestInfo:
1174 return sizeof(VMMDevReportGuestInfo);
1175 case VMMDevReq_GetDisplayChangeRequest:
1176 return sizeof(VMMDevDisplayChangeRequest);
1177 case VMMDevReq_GetDisplayChangeRequest2:
1178 return sizeof(VMMDevDisplayChangeRequest2);
1179 case VMMDevReq_VideoModeSupported:
1180 return sizeof(VMMDevVideoModeSupportedRequest);
1181 case VMMDevReq_GetHeightReduction:
1182 return sizeof(VMMDevGetHeightReductionRequest);
1183#ifdef VBOX_HGCM
1184 case VMMDevReq_HGCMConnect:
1185 return sizeof(VMMDevHGCMConnect);
1186 case VMMDevReq_HGCMDisconnect:
1187 return sizeof(VMMDevHGCMDisconnect);
1188 case VMMDevReq_HGCMCall:
1189 return sizeof(VMMDevHGCMCall);
1190#endif
1191 case VMMDevReq_VideoAccelEnable:
1192 return sizeof(VMMDevVideoAccelEnable);
1193 case VMMDevReq_VideoAccelFlush:
1194 return sizeof(VMMDevVideoAccelFlush);
1195 case VMMDevReq_VideoSetVisibleRegion:
1196 return sizeof(VMMDevVideoSetVisibleRegion);
1197 case VMMDevReq_QueryCredentials:
1198 return sizeof(VMMDevCredentials);
1199#ifdef DEBUG
1200 case VMMDevReq_LogString:
1201 return sizeof(VMMDevReqLogString);
1202#endif
1203 default:
1204 return 0;
1205 }
1206}
1207
1208/**
1209 * Initializes a request structure.
1210 *
1211 */
1212DECLINLINE(int) vmmdevInitRequest(VMMDevRequestHeader *req, VMMDevRequestType type)
1213{
1214 uint32_t requestSize;
1215 if (!req)
1216 return VERR_INVALID_PARAMETER;
1217 requestSize = (uint32_t)vmmdevGetRequestSize(type);
1218 if (!requestSize)
1219 return VERR_INVALID_PARAMETER;
1220 req->size = requestSize;
1221 req->version = VMMDEV_REQUEST_HEADER_VERSION;
1222 req->requestType = type;
1223 req->rc = VERR_GENERAL_FAILURE;
1224 req->reserved1 = 0;
1225 req->reserved2 = 0;
1226 return VINF_SUCCESS;
1227}
1228
1229
1230#ifdef __OS2__
1231
1232/**
1233 * The data buffer layout for the IDC entry point (AttachDD).
1234 *
1235 * @remark This is defined in multiple 16-bit headers / sources.
1236 * Some places it's called VBGOS2IDC to short things a bit.
1237 */
1238typedef struct VBOXGUESTOS2IDCCONNECT
1239{
1240 /** VMMDEV_VERSION. */
1241 uint32_t u32Version;
1242 /** Opaque session handle. */
1243 uint32_t u32Session;
1244
1245 /**
1246 * The 32-bit service entry point.
1247 *
1248 * @returns VBox status code.
1249 * @param u32Session The above session handle.
1250 * @param iFunction The requested function.
1251 * @param pvData The input/output data buffer. The caller ensures that this
1252 * cannot be swapped out, or that it's acceptable to take a
1253 * page in fault in the current context. If the request doesn't
1254 * take input or produces output, apssing NULL is okay.
1255 * @param cbData The size of the data buffer.
1256 * @param pcbDataReturned Where to store the amount of data that's returned.
1257 * This can be NULL if pvData is NULL.
1258 */
1259 DECLCALLBACKMEMBER(int, pfnServiceEP)(uint32_t u32Session, unsigned iFunction, void *pvData, size_t cbData, size_t *pcbDataReturned);
1260
1261 /** The 16-bit service entry point for C code (cdecl).
1262 *
1263 * It's the same as the 32-bit entry point, but the types has
1264 * changed to 16-bit equivalents.
1265 *
1266 * @code
1267 * int far cdecl
1268 * VBoxGuestOs2IDCService16(uint32_t u32Session, uint16_t iFunction,
1269 * void far *fpvData, uint16_t cbData, uint16_t far *pcbDataReturned);
1270 * @endcode
1271 */
1272 RTFAR16 fpfnServiceEP;
1273
1274 /** The 16-bit service entry point for Assembly code (register).
1275 *
1276 * This is just a wrapper around fpfnServiceEP to simplify calls
1277 * from 16-bit assembly code.
1278 *
1279 * @returns (e)ax: VBox status code; cx: The amount of data returned.
1280 *
1281 * @param u32Session eax - The above session handle.
1282 * @param iFunction dl - The requested function.
1283 * @param pvData es:bx - The input/output data buffer.
1284 * @param cbData cx - The size of the data buffer.
1285 */
1286 RTFAR16 fpfnServiceAsmEP;
1287} VBOXGUESTOS2IDCCONNECT;
1288/** Pointer to VBOXGUESTOS2IDCCONNECT buffer. */
1289typedef VBOXGUESTOS2IDCCONNECT *PVBOXGUESTOS2IDCCONNECT;
1290
1291/** OS/2 specific: IDC client disconnect request.
1292 *
1293 * This takes no input and it doesn't return anything. Obviously this
1294 * is only recognized if it arrives thru the IDC service EP.
1295 */
1296#define VBOXGUEST_IOCTL_OS2_IDC_DISCONNECT VBOXGUEST_IOCTL_CODE(48, sizeof(uint32_t))
1297
1298#endif /* __OS2__ */
1299
1300/** @} */
1301
1302
1303#ifdef IN_RING3
1304
1305/** @def VBGLR3DECL
1306 * Ring 3 VBGL declaration.
1307 * @param type The return type of the function declaration.
1308 */
1309#define VBGLR3DECL(type) type VBOXCALL
1310
1311__BEGIN_DECLS
1312VBGLR3DECL(int) VbglR3Init(void);
1313VBGLR3DECL(void) VbglR3Term(void);
1314VBGLR3DECL(int) VbglR3GRPerform(VMMDevRequestHeader *pReq);
1315# ifdef __iprt_time_h__
1316VBGLR3DECL(int) VbglR3GetHostTime(PRTTIMESPEC pTime);
1317# endif
1318
1319VBGLR3DECL(int) VbglR3ClipboardConnect(uint32_t *pu32ClientId);
1320VBGLR3DECL(int) VbglR3ClipboardDisconnect(uint32_t u32ClientId);
1321VBGLR3DECL(int) VbglR3ClipboardGetHostMsg(uint32_t u32ClientId, uint32_t *pMsg, uint32_t *pfFormats);
1322VBGLR3DECL(int) VbglR3ClipboardReadData(uint32_t u32ClientId, uint32_t fFormat, void *pv, uint32_t cb, uint32_t *pcb);
1323VBGLR3DECL(int) VbglR3ClipboardReportFormats(uint32_t u32ClientId, uint32_t fFormats);
1324VBGLR3DECL(int) VbglR3ClipboardWriteData(uint32_t u32ClientId, uint32_t fFormat, void *pv, uint32_t cb);
1325
1326__END_DECLS
1327
1328#endif /* IN_RING3 */
1329
1330#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