VirtualBox

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

Last change on this file since 6281 was 6281, checked in by vboxsync, 17 years ago

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