VirtualBox

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

Last change on this file since 13469 was 12813, checked in by vboxsync, 16 years ago

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