VirtualBox

source: vbox/trunk/src/VBox/Devices/VMMDev/VMMDev.cpp@ 71891

Last change on this file since 71891 was 71891, checked in by vboxsync, 7 years ago

VMMDev: VMMDevHGCM rewrite
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 163.4 KB
Line 
1/* $Id: VMMDev.cpp 71891 2018-04-18 09:15:38Z vboxsync $ */
2/** @file
3 * VMMDev - Guest <-> VMM/Host communication device.
4 */
5
6/*
7 * Copyright (C) 2006-2017 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/** @page pg_vmmdev The VMM Device.
19 *
20 * The VMM device is a custom hardware device emulation for communicating with
21 * the guest additions.
22 *
23 * Whenever host wants to inform guest about something an IRQ notification will
24 * be raised.
25 *
26 * VMMDev PDM interface will contain the guest notification method.
27 *
28 * There is a 32 bit event mask which will be read by guest on an interrupt. A
29 * non zero bit in the mask means that the specific event occurred and requires
30 * processing on guest side.
31 *
32 * After reading the event mask guest must issue a generic request
33 * AcknowlegdeEvents.
34 *
35 * IRQ line is set to 1 (request) if there are unprocessed events, that is the
36 * event mask is not zero.
37 *
38 * After receiving an interrupt and checking event mask, the guest must process
39 * events using the event specific mechanism.
40 *
41 * That is if mouse capabilities were changed, guest will use
42 * VMMDev_GetMouseStatus generic request.
43 *
44 * Event mask is only a set of flags indicating that guest must proceed with a
45 * procedure.
46 *
47 * Unsupported events are therefore ignored. The guest additions must inform
48 * host which events they want to receive, to avoid unnecessary IRQ processing.
49 * By default no events are signalled to guest.
50 *
51 * This seems to be fast method. It requires only one context switch for an
52 * event processing.
53 *
54 *
55 * @section sec_vmmdev_heartbeat Heartbeat
56 *
57 * The heartbeat is a feature to monitor whether the guest OS is hung or not.
58 *
59 * The main kernel component of the guest additions, VBoxGuest, sets up a timer
60 * at a frequency returned by VMMDevReq_HeartbeatConfigure
61 * (VMMDevReqHeartbeat::cNsInterval, VMMDEV::cNsHeartbeatInterval) and performs
62 * a VMMDevReq_GuestHeartbeat request every time the timer ticks.
63 *
64 * The host side (VMMDev) arms a timer with a more distant deadline
65 * (VMMDEV::cNsHeartbeatTimeout), twice cNsHeartbeatInterval by default. Each
66 * time a VMMDevReq_GuestHeartbeat request comes in, the timer is rearmed with
67 * the same relative deadline. So, as long as VMMDevReq_GuestHeartbeat comes
68 * when they should, the host timer will never fire.
69 *
70 * When the timer fires, we consider the guest as hung / flatlined / dead.
71 * Currently we only LogRel that, but it's easy to extend this with an event in
72 * Main API.
73 *
74 * Should the guest reawaken at some later point, we LogRel that event and
75 * continue as normal. Again something which would merit an API event.
76 *
77 */
78
79
80/*********************************************************************************************************************************
81* Header Files *
82*********************************************************************************************************************************/
83/* Enable dev_vmm Log3 statements to get IRQ-related logging. */
84#define LOG_GROUP LOG_GROUP_DEV_VMM
85#include <VBoxVideo.h> /* For VBVA definitions. */
86#include <VBox/VMMDev.h>
87#include <VBox/vmm/mm.h>
88#include <VBox/log.h>
89#include <VBox/param.h>
90#include <iprt/path.h>
91#include <iprt/dir.h>
92#include <iprt/file.h>
93#include <VBox/vmm/pgm.h>
94#include <VBox/err.h>
95#include <VBox/vmm/vm.h> /* for VM_IS_EMT */
96#include <VBox/dbg.h>
97#include <VBox/version.h>
98
99#include <iprt/asm.h>
100#include <iprt/asm-amd64-x86.h>
101#include <iprt/assert.h>
102#include <iprt/buildconfig.h>
103#include <iprt/string.h>
104#include <iprt/time.h>
105#ifndef IN_RC
106# include <iprt/mem.h>
107#endif
108#ifdef IN_RING3
109# include <iprt/uuid.h>
110#endif
111
112#include "VMMDevState.h"
113#ifdef VBOX_WITH_HGCM
114# include "VMMDevHGCM.h"
115#endif
116#ifndef VBOX_WITHOUT_TESTING_FEATURES
117# include "VMMDevTesting.h"
118#endif
119
120
121/*********************************************************************************************************************************
122* Defined Constants And Macros *
123*********************************************************************************************************************************/
124#define VMMDEV_INTERFACE_VERSION_IS_1_03(s) \
125 ( RT_HIWORD((s)->guestInfo.interfaceVersion) == 1 \
126 && RT_LOWORD((s)->guestInfo.interfaceVersion) == 3 )
127
128#define VMMDEV_INTERFACE_VERSION_IS_OK(additionsVersion) \
129 ( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
130 && RT_LOWORD(additionsVersion) <= RT_LOWORD(VMMDEV_VERSION) )
131
132#define VMMDEV_INTERFACE_VERSION_IS_OLD(additionsVersion) \
133 ( (RT_HIWORD(additionsVersion) < RT_HIWORD(VMMDEV_VERSION) \
134 || ( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
135 && RT_LOWORD(additionsVersion) <= RT_LOWORD(VMMDEV_VERSION) ) )
136
137#define VMMDEV_INTERFACE_VERSION_IS_TOO_OLD(additionsVersion) \
138 ( RT_HIWORD(additionsVersion) < RT_HIWORD(VMMDEV_VERSION) )
139
140#define VMMDEV_INTERFACE_VERSION_IS_NEW(additionsVersion) \
141 ( RT_HIWORD(additionsVersion) > RT_HIWORD(VMMDEV_VERSION) \
142 || ( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
143 && RT_LOWORD(additionsVersion) > RT_LOWORD(VMMDEV_VERSION) ) )
144
145/** Default interval in nanoseconds between guest heartbeats.
146 * Used when no HeartbeatInterval is set in CFGM and for setting
147 * HB check timer if the guest's heartbeat frequency is less than 1Hz. */
148#define VMMDEV_HEARTBEAT_DEFAULT_INTERVAL (2U*RT_NS_1SEC_64)
149
150
151#ifndef VBOX_DEVICE_STRUCT_TESTCASE
152
153/* -=-=-=-=- Misc Helpers -=-=-=-=- */
154
155/**
156 * Log information about the Guest Additions.
157 *
158 * @param pGuestInfo The information we've got from the Guest Additions driver.
159 */
160static void vmmdevLogGuestOsInfo(VBoxGuestInfo *pGuestInfo)
161{
162 const char *pszOs;
163 switch (pGuestInfo->osType & ~VBOXOSTYPE_x64)
164 {
165 case VBOXOSTYPE_DOS: pszOs = "DOS"; break;
166 case VBOXOSTYPE_Win31: pszOs = "Windows 3.1"; break;
167 case VBOXOSTYPE_Win9x: pszOs = "Windows 9x"; break;
168 case VBOXOSTYPE_Win95: pszOs = "Windows 95"; break;
169 case VBOXOSTYPE_Win98: pszOs = "Windows 98"; break;
170 case VBOXOSTYPE_WinMe: pszOs = "Windows Me"; break;
171 case VBOXOSTYPE_WinNT: pszOs = "Windows NT"; break;
172 case VBOXOSTYPE_WinNT3x: pszOs = "Windows NT 3.x"; break;
173 case VBOXOSTYPE_WinNT4: pszOs = "Windows NT4"; break;
174 case VBOXOSTYPE_Win2k: pszOs = "Windows 2k"; break;
175 case VBOXOSTYPE_WinXP: pszOs = "Windows XP"; break;
176 case VBOXOSTYPE_Win2k3: pszOs = "Windows 2k3"; break;
177 case VBOXOSTYPE_WinVista: pszOs = "Windows Vista"; break;
178 case VBOXOSTYPE_Win2k8: pszOs = "Windows 2k8"; break;
179 case VBOXOSTYPE_Win7: pszOs = "Windows 7"; break;
180 case VBOXOSTYPE_Win8: pszOs = "Windows 8"; break;
181 case VBOXOSTYPE_Win2k12_x64 & ~VBOXOSTYPE_x64: pszOs = "Windows 2k12"; break;
182 case VBOXOSTYPE_Win81: pszOs = "Windows 8.1"; break;
183 case VBOXOSTYPE_Win10: pszOs = "Windows 10"; break;
184 case VBOXOSTYPE_Win2k16_x64 & ~VBOXOSTYPE_x64: pszOs = "Windows 2k16"; break;
185 case VBOXOSTYPE_OS2: pszOs = "OS/2"; break;
186 case VBOXOSTYPE_OS2Warp3: pszOs = "OS/2 Warp 3"; break;
187 case VBOXOSTYPE_OS2Warp4: pszOs = "OS/2 Warp 4"; break;
188 case VBOXOSTYPE_OS2Warp45: pszOs = "OS/2 Warp 4.5"; break;
189 case VBOXOSTYPE_ECS: pszOs = "OS/2 ECS"; break;
190 case VBOXOSTYPE_OS21x: pszOs = "OS/2 2.1x"; break;
191 case VBOXOSTYPE_Linux: pszOs = "Linux"; break;
192 case VBOXOSTYPE_Linux22: pszOs = "Linux 2.2"; break;
193 case VBOXOSTYPE_Linux24: pszOs = "Linux 2.4"; break;
194 case VBOXOSTYPE_Linux26: pszOs = "Linux >= 2.6"; break;
195 case VBOXOSTYPE_ArchLinux: pszOs = "ArchLinux"; break;
196 case VBOXOSTYPE_Debian: pszOs = "Debian"; break;
197 case VBOXOSTYPE_OpenSUSE: pszOs = "openSUSE"; break;
198 case VBOXOSTYPE_FedoraCore: pszOs = "Fedora"; break;
199 case VBOXOSTYPE_Gentoo: pszOs = "Gentoo"; break;
200 case VBOXOSTYPE_Mandriva: pszOs = "Mandriva"; break;
201 case VBOXOSTYPE_RedHat: pszOs = "RedHat"; break;
202 case VBOXOSTYPE_Turbolinux: pszOs = "TurboLinux"; break;
203 case VBOXOSTYPE_Ubuntu: pszOs = "Ubuntu"; break;
204 case VBOXOSTYPE_Xandros: pszOs = "Xandros"; break;
205 case VBOXOSTYPE_Oracle: pszOs = "Oracle Linux"; break;
206 case VBOXOSTYPE_FreeBSD: pszOs = "FreeBSD"; break;
207 case VBOXOSTYPE_OpenBSD: pszOs = "OpenBSD"; break;
208 case VBOXOSTYPE_NetBSD: pszOs = "NetBSD"; break;
209 case VBOXOSTYPE_Netware: pszOs = "Netware"; break;
210 case VBOXOSTYPE_Solaris: pszOs = "Solaris"; break;
211 case VBOXOSTYPE_OpenSolaris: pszOs = "OpenSolaris"; break;
212 case VBOXOSTYPE_Solaris11_x64 & ~VBOXOSTYPE_x64: pszOs = "Solaris 11"; break;
213 case VBOXOSTYPE_MacOS: pszOs = "Mac OS X"; break;
214 case VBOXOSTYPE_MacOS106: pszOs = "Mac OS X 10.6"; break;
215 case VBOXOSTYPE_MacOS107_x64 & ~VBOXOSTYPE_x64: pszOs = "Mac OS X 10.7"; break;
216 case VBOXOSTYPE_MacOS108_x64 & ~VBOXOSTYPE_x64: pszOs = "Mac OS X 10.8"; break;
217 case VBOXOSTYPE_MacOS109_x64 & ~VBOXOSTYPE_x64: pszOs = "Mac OS X 10.9"; break;
218 case VBOXOSTYPE_MacOS1010_x64 & ~VBOXOSTYPE_x64: pszOs = "Mac OS X 10.10"; break;
219 case VBOXOSTYPE_MacOS1011_x64 & ~VBOXOSTYPE_x64: pszOs = "Mac OS X 10.11"; break;
220 case VBOXOSTYPE_MacOS1012_x64 & ~VBOXOSTYPE_x64: pszOs = "macOS 10.12"; break;
221 case VBOXOSTYPE_MacOS1013_x64 & ~VBOXOSTYPE_x64: pszOs = "macOS 10.13"; break;
222 case VBOXOSTYPE_Haiku: pszOs = "Haiku"; break;
223 default: pszOs = "unknown"; break;
224 }
225 LogRel(("VMMDev: Guest Additions information report: Interface = 0x%08X osType = 0x%08X (%s, %u-bit)\n",
226 pGuestInfo->interfaceVersion, pGuestInfo->osType, pszOs,
227 pGuestInfo->osType & VBOXOSTYPE_x64 ? 64 : 32));
228}
229
230/**
231 * Sets the IRQ (raise it or lower it) for 1.03 additions.
232 *
233 * @param pThis The VMMDev state.
234 * @thread Any.
235 * @remarks Must be called owning the critical section.
236 */
237static void vmmdevSetIRQ_Legacy(PVMMDEV pThis)
238{
239 if (pThis->fu32AdditionsOk)
240 {
241 /* Filter unsupported events */
242 uint32_t fEvents = pThis->u32HostEventFlags & pThis->pVMMDevRAMR3->V.V1_03.u32GuestEventMask;
243
244 Log(("vmmdevSetIRQ: fEvents=%#010x, u32HostEventFlags=%#010x, u32GuestEventMask=%#010x.\n",
245 fEvents, pThis->u32HostEventFlags, pThis->pVMMDevRAMR3->V.V1_03.u32GuestEventMask));
246
247 /* Move event flags to VMMDev RAM */
248 pThis->pVMMDevRAMR3->V.V1_03.u32HostEvents = fEvents;
249
250 uint32_t uIRQLevel = 0;
251 if (fEvents)
252 {
253 /* Clear host flags which will be delivered to guest. */
254 pThis->u32HostEventFlags &= ~fEvents;
255 Log(("vmmdevSetIRQ: u32HostEventFlags=%#010x\n", pThis->u32HostEventFlags));
256 uIRQLevel = 1;
257 }
258
259 /* Set IRQ level for pin 0 (see NoWait comment in vmmdevMaybeSetIRQ). */
260 /** @todo make IRQ pin configurable, at least a symbolic constant */
261 PDMDevHlpPCISetIrqNoWait(pThis->pDevIns, 0, uIRQLevel);
262 Log(("vmmdevSetIRQ: IRQ set %d\n", uIRQLevel));
263 }
264 else
265 Log(("vmmdevSetIRQ: IRQ is not generated, guest has not yet reported to us.\n"));
266}
267
268/**
269 * Sets the IRQ if there are events to be delivered.
270 *
271 * @param pThis The VMMDev state.
272 * @thread Any.
273 * @remarks Must be called owning the critical section.
274 */
275static void vmmdevMaybeSetIRQ(PVMMDEV pThis)
276{
277 Log3(("vmmdevMaybeSetIRQ: u32HostEventFlags=%#010x, u32GuestFilterMask=%#010x.\n",
278 pThis->u32HostEventFlags, pThis->u32GuestFilterMask));
279
280 if (pThis->u32HostEventFlags & pThis->u32GuestFilterMask)
281 {
282 /*
283 * Note! No need to wait for the IRQs to be set (if we're not luck
284 * with the locks, etc). It is a notification about something,
285 * which has already happened.
286 */
287 pThis->pVMMDevRAMR3->V.V1_04.fHaveEvents = true;
288 PDMDevHlpPCISetIrqNoWait(pThis->pDevIns, 0, 1);
289 Log3(("vmmdevMaybeSetIRQ: IRQ set.\n"));
290 }
291}
292
293/**
294 * Notifies the guest about new events (@a fAddEvents).
295 *
296 * @param pThis The VMMDev state.
297 * @param fAddEvents New events to add.
298 * @thread Any.
299 * @remarks Must be called owning the critical section.
300 */
301static void vmmdevNotifyGuestWorker(PVMMDEV pThis, uint32_t fAddEvents)
302{
303 Log3(("vmmdevNotifyGuestWorker: fAddEvents=%#010x.\n", fAddEvents));
304 Assert(PDMCritSectIsOwner(&pThis->CritSect));
305
306 if (!VMMDEV_INTERFACE_VERSION_IS_1_03(pThis))
307 {
308 Log3(("vmmdevNotifyGuestWorker: New additions detected.\n"));
309
310 if (pThis->fu32AdditionsOk)
311 {
312 const bool fHadEvents = (pThis->u32HostEventFlags & pThis->u32GuestFilterMask) != 0;
313
314 Log3(("vmmdevNotifyGuestWorker: fHadEvents=%d, u32HostEventFlags=%#010x, u32GuestFilterMask=%#010x.\n",
315 fHadEvents, pThis->u32HostEventFlags, pThis->u32GuestFilterMask));
316
317 pThis->u32HostEventFlags |= fAddEvents;
318
319 if (!fHadEvents)
320 vmmdevMaybeSetIRQ(pThis);
321 }
322 else
323 {
324 pThis->u32HostEventFlags |= fAddEvents;
325 Log(("vmmdevNotifyGuestWorker: IRQ is not generated, guest has not yet reported to us.\n"));
326 }
327 }
328 else
329 {
330 Log3(("vmmdevNotifyGuestWorker: Old additions detected.\n"));
331
332 pThis->u32HostEventFlags |= fAddEvents;
333 vmmdevSetIRQ_Legacy(pThis);
334 }
335}
336
337
338
339/* -=-=-=-=- Interfaces shared with VMMDevHGCM.cpp -=-=-=-=- */
340
341/**
342 * Notifies the guest about new events (@a fAddEvents).
343 *
344 * This is used by VMMDev.cpp as well as VMMDevHGCM.cpp.
345 *
346 * @param pThis The VMMDev state.
347 * @param fAddEvents New events to add.
348 * @thread Any.
349 */
350void VMMDevNotifyGuest(PVMMDEV pThis, uint32_t fAddEvents)
351{
352 Log3(("VMMDevNotifyGuest: fAddEvents=%#010x\n", fAddEvents));
353
354 /*
355 * Only notify the VM when it's running.
356 */
357 VMSTATE enmVMState = PDMDevHlpVMState(pThis->pDevIns);
358/** @todo r=bird: Shouldn't there be more states here? Wouldn't we drop
359 * notifications now when we're in the process of suspending or
360 * similar? */
361 if ( enmVMState == VMSTATE_RUNNING
362 || enmVMState == VMSTATE_RUNNING_LS)
363 {
364 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
365 vmmdevNotifyGuestWorker(pThis, fAddEvents);
366 PDMCritSectLeave(&pThis->CritSect);
367 }
368}
369
370/**
371 * Code shared by VMMDevReq_CtlGuestFilterMask and HGCM for controlling the
372 * events the guest are interested in.
373 *
374 * @param pThis The VMMDev state.
375 * @param fOrMask Events to add (VMMDEV_EVENT_XXX). Pass 0 for no
376 * change.
377 * @param fNotMask Events to remove (VMMDEV_EVENT_XXX). Pass 0 for no
378 * change.
379 *
380 * @remarks When HGCM will automatically enable VMMDEV_EVENT_HGCM when the guest
381 * starts submitting HGCM requests. Otherwise, the events are
382 * controlled by the guest.
383 */
384void VMMDevCtlSetGuestFilterMask(PVMMDEV pThis, uint32_t fOrMask, uint32_t fNotMask)
385{
386 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
387
388 const bool fHadEvents = (pThis->u32HostEventFlags & pThis->u32GuestFilterMask) != 0;
389
390 Log(("VMMDevCtlSetGuestFilterMask: fOrMask=%#010x, u32NotMask=%#010x, fHadEvents=%d.\n", fOrMask, fNotMask, fHadEvents));
391 if (fHadEvents)
392 {
393 if (!pThis->fNewGuestFilterMask)
394 pThis->u32NewGuestFilterMask = pThis->u32GuestFilterMask;
395
396 pThis->u32NewGuestFilterMask |= fOrMask;
397 pThis->u32NewGuestFilterMask &= ~fNotMask;
398 pThis->fNewGuestFilterMask = true;
399 }
400 else
401 {
402 pThis->u32GuestFilterMask |= fOrMask;
403 pThis->u32GuestFilterMask &= ~fNotMask;
404 vmmdevMaybeSetIRQ(pThis);
405 }
406
407 PDMCritSectLeave(&pThis->CritSect);
408}
409
410
411
412/* -=-=-=-=- Request processing functions. -=-=-=-=- */
413
414/**
415 * Handles VMMDevReq_ReportGuestInfo.
416 *
417 * @returns VBox status code that the guest should see.
418 * @param pThis The VMMDev instance data.
419 * @param pRequestHeader The header of the request to handle.
420 */
421static int vmmdevReqHandler_ReportGuestInfo(PVMMDEV pThis, VMMDevRequestHeader *pRequestHeader)
422{
423 AssertMsgReturn(pRequestHeader->size == sizeof(VMMDevReportGuestInfo), ("%u\n", pRequestHeader->size), VERR_INVALID_PARAMETER);
424 VBoxGuestInfo const *pInfo = &((VMMDevReportGuestInfo *)pRequestHeader)->guestInfo;
425
426 if (memcmp(&pThis->guestInfo, pInfo, sizeof(*pInfo)) != 0)
427 {
428 /* Make a copy of supplied information. */
429 pThis->guestInfo = *pInfo;
430
431 /* Check additions interface version. */
432 pThis->fu32AdditionsOk = VMMDEV_INTERFACE_VERSION_IS_OK(pThis->guestInfo.interfaceVersion);
433
434 vmmdevLogGuestOsInfo(&pThis->guestInfo);
435
436 if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestInfo)
437 pThis->pDrv->pfnUpdateGuestInfo(pThis->pDrv, &pThis->guestInfo);
438 }
439
440 if (!pThis->fu32AdditionsOk)
441 return VERR_VERSION_MISMATCH;
442
443 /* Clear our IRQ in case it was high for whatever reason. */
444 PDMDevHlpPCISetIrqNoWait(pThis->pDevIns, 0, 0);
445
446 return VINF_SUCCESS;
447}
448
449
450/**
451 * Handles VMMDevReq_GuestHeartbeat.
452 *
453 * @returns VBox status code that the guest should see.
454 * @param pThis The VMMDev instance data.
455 */
456static int vmmDevReqHandler_GuestHeartbeat(PVMMDEV pThis)
457{
458 int rc;
459 if (pThis->fHeartbeatActive)
460 {
461 uint64_t const nsNowTS = TMTimerGetNano(pThis->pFlatlinedTimer);
462 if (!pThis->fFlatlined)
463 { /* likely */ }
464 else
465 {
466 LogRel(("VMMDev: GuestHeartBeat: Guest is alive (gone %'llu ns)\n", nsNowTS - pThis->nsLastHeartbeatTS));
467 ASMAtomicWriteBool(&pThis->fFlatlined, false);
468 }
469 ASMAtomicWriteU64(&pThis->nsLastHeartbeatTS, nsNowTS);
470
471 /* Postpone (or restart if we missed a beat) the timeout timer. */
472 rc = TMTimerSetNano(pThis->pFlatlinedTimer, pThis->cNsHeartbeatTimeout);
473 }
474 else
475 rc = VINF_SUCCESS;
476 return rc;
477}
478
479
480/**
481 * Timer that fires when where have been no heartbeats for a given time.
482 *
483 * @remarks Does not take the VMMDev critsect.
484 */
485static DECLCALLBACK(void) vmmDevHeartbeatFlatlinedTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
486{
487 RT_NOREF1(pDevIns);
488 PVMMDEV pThis = (PVMMDEV)pvUser;
489 if (pThis->fHeartbeatActive)
490 {
491 uint64_t cNsElapsed = TMTimerGetNano(pTimer) - pThis->nsLastHeartbeatTS;
492 if ( !pThis->fFlatlined
493 && cNsElapsed >= pThis->cNsHeartbeatInterval)
494 {
495 LogRel(("VMMDev: vmmDevHeartbeatFlatlinedTimer: Guest seems to be unresponsive. Last heartbeat received %RU64 seconds ago\n",
496 cNsElapsed / RT_NS_1SEC));
497 ASMAtomicWriteBool(&pThis->fFlatlined, true);
498 }
499 }
500}
501
502
503/**
504 * Handles VMMDevReq_HeartbeatConfigure.
505 *
506 * @returns VBox status code that the guest should see.
507 * @param pThis The VMMDev instance data.
508 * @param pReqHdr The header of the request to handle.
509 */
510static int vmmDevReqHandler_HeartbeatConfigure(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
511{
512 AssertMsgReturn(pReqHdr->size == sizeof(VMMDevReqHeartbeat), ("%u\n", pReqHdr->size), VERR_INVALID_PARAMETER);
513 VMMDevReqHeartbeat *pReq = (VMMDevReqHeartbeat *)pReqHdr;
514 int rc;
515
516 pReq->cNsInterval = pThis->cNsHeartbeatInterval;
517
518 if (pReq->fEnabled != pThis->fHeartbeatActive)
519 {
520 ASMAtomicWriteBool(&pThis->fHeartbeatActive, pReq->fEnabled);
521 if (pReq->fEnabled)
522 {
523 /*
524 * Activate the heartbeat monitor.
525 */
526 pThis->nsLastHeartbeatTS = TMTimerGetNano(pThis->pFlatlinedTimer);
527 rc = TMTimerSetNano(pThis->pFlatlinedTimer, pThis->cNsHeartbeatTimeout);
528 if (RT_SUCCESS(rc))
529 LogRel(("VMMDev: Heartbeat flatline timer set to trigger after %'RU64 ns\n", pThis->cNsHeartbeatTimeout));
530 else
531 LogRel(("VMMDev: Error starting flatline timer (heartbeat): %Rrc\n", rc));
532 }
533 else
534 {
535 /*
536 * Deactivate the heartbeat monitor.
537 */
538 rc = TMTimerStop(pThis->pFlatlinedTimer);
539 LogRel(("VMMDev: Heartbeat checking timer has been stopped (rc=%Rrc)\n", rc));
540 }
541 }
542 else
543 {
544 LogRel(("VMMDev: vmmDevReqHandler_HeartbeatConfigure: No change (fHeartbeatActive=%RTbool).\n", pThis->fHeartbeatActive));
545 rc = VINF_SUCCESS;
546 }
547
548 return rc;
549}
550
551
552/**
553 * Validates a publisher tag.
554 *
555 * @returns true / false.
556 * @param pszTag Tag to validate.
557 */
558static bool vmmdevReqIsValidPublisherTag(const char *pszTag)
559{
560 /* Note! This character set is also found in Config.kmk. */
561 static char const s_szValidChars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz()[]{}+-.,";
562
563 while (*pszTag != '\0')
564 {
565 if (!strchr(s_szValidChars, *pszTag))
566 return false;
567 pszTag++;
568 }
569 return true;
570}
571
572
573/**
574 * Validates a build tag.
575 *
576 * @returns true / false.
577 * @param pszTag Tag to validate.
578 */
579static bool vmmdevReqIsValidBuildTag(const char *pszTag)
580{
581 int cchPrefix;
582 if (!strncmp(pszTag, "RC", 2))
583 cchPrefix = 2;
584 else if (!strncmp(pszTag, "BETA", 4))
585 cchPrefix = 4;
586 else if (!strncmp(pszTag, "ALPHA", 5))
587 cchPrefix = 5;
588 else
589 return false;
590
591 if (pszTag[cchPrefix] == '\0')
592 return true;
593
594 uint8_t u8;
595 int rc = RTStrToUInt8Full(&pszTag[cchPrefix], 10, &u8);
596 return rc == VINF_SUCCESS;
597}
598
599
600/**
601 * Handles VMMDevReq_ReportGuestInfo2.
602 *
603 * @returns VBox status code that the guest should see.
604 * @param pThis The VMMDev instance data.
605 * @param pReqHdr The header of the request to handle.
606 */
607static int vmmdevReqHandler_ReportGuestInfo2(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
608{
609 AssertMsgReturn(pReqHdr->size == sizeof(VMMDevReportGuestInfo2), ("%u\n", pReqHdr->size), VERR_INVALID_PARAMETER);
610 VBoxGuestInfo2 const *pInfo2 = &((VMMDevReportGuestInfo2 *)pReqHdr)->guestInfo;
611
612 LogRel(("VMMDev: Guest Additions information report: Version %d.%d.%d r%d '%.*s'\n",
613 pInfo2->additionsMajor, pInfo2->additionsMinor, pInfo2->additionsBuild,
614 pInfo2->additionsRevision, sizeof(pInfo2->szName), pInfo2->szName));
615
616 /* The interface was introduced in 3.2 and will definitely not be
617 backported beyond 3.0 (bird). */
618 AssertMsgReturn(pInfo2->additionsMajor >= 3,
619 ("%u.%u.%u\n", pInfo2->additionsMajor, pInfo2->additionsMinor, pInfo2->additionsBuild),
620 VERR_INVALID_PARAMETER);
621
622 /* The version must fit in a full version compression. */
623 uint32_t uFullVersion = VBOX_FULL_VERSION_MAKE(pInfo2->additionsMajor, pInfo2->additionsMinor, pInfo2->additionsBuild);
624 AssertMsgReturn( VBOX_FULL_VERSION_GET_MAJOR(uFullVersion) == pInfo2->additionsMajor
625 && VBOX_FULL_VERSION_GET_MINOR(uFullVersion) == pInfo2->additionsMinor
626 && VBOX_FULL_VERSION_GET_BUILD(uFullVersion) == pInfo2->additionsBuild,
627 ("%u.%u.%u\n", pInfo2->additionsMajor, pInfo2->additionsMinor, pInfo2->additionsBuild),
628 VERR_OUT_OF_RANGE);
629
630 /*
631 * Validate the name.
632 * Be less strict towards older additions (< v4.1.50).
633 */
634 AssertCompile(sizeof(pThis->guestInfo2.szName) == sizeof(pInfo2->szName));
635 AssertReturn(RTStrEnd(pInfo2->szName, sizeof(pInfo2->szName)) != NULL, VERR_INVALID_PARAMETER);
636 const char *pszName = pInfo2->szName;
637
638 /* The version number which shouldn't be there. */
639 char szTmp[sizeof(pInfo2->szName)];
640 size_t cchStart = RTStrPrintf(szTmp, sizeof(szTmp), "%u.%u.%u", pInfo2->additionsMajor, pInfo2->additionsMinor, pInfo2->additionsBuild);
641 AssertMsgReturn(!strncmp(pszName, szTmp, cchStart), ("%s != %s\n", pszName, szTmp), VERR_INVALID_PARAMETER);
642 pszName += cchStart;
643
644 /* Now we can either have nothing or a build tag or/and a publisher tag. */
645 if (*pszName != '\0')
646 {
647 const char *pszRelaxedName = "";
648 bool const fStrict = pInfo2->additionsMajor > 4
649 || (pInfo2->additionsMajor == 4 && pInfo2->additionsMinor > 1)
650 || (pInfo2->additionsMajor == 4 && pInfo2->additionsMinor == 1 && pInfo2->additionsBuild >= 50);
651 bool fOk = false;
652 if (*pszName == '_')
653 {
654 pszName++;
655 strcpy(szTmp, pszName);
656 char *pszTag2 = strchr(szTmp, '_');
657 if (!pszTag2)
658 {
659 fOk = vmmdevReqIsValidBuildTag(szTmp)
660 || vmmdevReqIsValidPublisherTag(szTmp);
661 }
662 else
663 {
664 *pszTag2++ = '\0';
665 fOk = vmmdevReqIsValidBuildTag(szTmp);
666 if (fOk)
667 {
668 fOk = vmmdevReqIsValidPublisherTag(pszTag2);
669 if (!fOk)
670 pszRelaxedName = szTmp;
671 }
672 }
673 }
674
675 if (!fOk)
676 {
677 AssertLogRelMsgReturn(!fStrict, ("%s", pszName), VERR_INVALID_PARAMETER);
678
679 /* non-strict mode, just zap the extra stuff. */
680 LogRel(("VMMDev: ReportGuestInfo2: Ignoring unparsable version name bits: '%s' -> '%s'.\n", pszName, pszRelaxedName));
681 pszName = pszRelaxedName;
682 }
683 }
684
685 /*
686 * Save the info and tell Main or whoever is listening.
687 */
688 pThis->guestInfo2.uFullVersion = uFullVersion;
689 pThis->guestInfo2.uRevision = pInfo2->additionsRevision;
690 pThis->guestInfo2.fFeatures = pInfo2->additionsFeatures;
691 strcpy(pThis->guestInfo2.szName, pszName);
692
693 if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestInfo2)
694 pThis->pDrv->pfnUpdateGuestInfo2(pThis->pDrv, uFullVersion, pszName, pInfo2->additionsRevision, pInfo2->additionsFeatures);
695
696 /* Clear our IRQ in case it was high for whatever reason. */
697 PDMDevHlpPCISetIrqNoWait(pThis->pDevIns, 0, 0);
698
699 return VINF_SUCCESS;
700}
701
702
703/**
704 * Allocates a new facility status entry, initializing it to inactive.
705 *
706 * @returns Pointer to a facility status entry on success, NULL on failure
707 * (table full).
708 * @param pThis The VMMDev instance data.
709 * @param enmFacility The facility type code.
710 * @param fFixed This is set when allocating the standard entries
711 * from the constructor.
712 * @param pTimeSpecNow Optionally giving the entry timestamp to use (ctor).
713 */
714static PVMMDEVFACILITYSTATUSENTRY
715vmmdevAllocFacilityStatusEntry(PVMMDEV pThis, VBoxGuestFacilityType enmFacility, bool fFixed, PCRTTIMESPEC pTimeSpecNow)
716{
717 /* If full, expunge one inactive entry. */
718 if (pThis->cFacilityStatuses == RT_ELEMENTS(pThis->aFacilityStatuses))
719 {
720 uint32_t i = pThis->cFacilityStatuses;
721 while (i-- > 0)
722 {
723 if ( pThis->aFacilityStatuses[i].enmStatus == VBoxGuestFacilityStatus_Inactive
724 && !pThis->aFacilityStatuses[i].fFixed)
725 {
726 pThis->cFacilityStatuses--;
727 int cToMove = pThis->cFacilityStatuses - i;
728 if (cToMove)
729 memmove(&pThis->aFacilityStatuses[i], &pThis->aFacilityStatuses[i + 1],
730 cToMove * sizeof(pThis->aFacilityStatuses[i]));
731 RT_ZERO(pThis->aFacilityStatuses[pThis->cFacilityStatuses]);
732 break;
733 }
734 }
735
736 if (pThis->cFacilityStatuses == RT_ELEMENTS(pThis->aFacilityStatuses))
737 return NULL;
738 }
739
740 /* Find location in array (it's sorted). */
741 uint32_t i = pThis->cFacilityStatuses;
742 while (i-- > 0)
743 if ((uint32_t)pThis->aFacilityStatuses[i].enmFacility < (uint32_t)enmFacility)
744 break;
745 i++;
746
747 /* Move. */
748 int cToMove = pThis->cFacilityStatuses - i;
749 if (cToMove > 0)
750 memmove(&pThis->aFacilityStatuses[i + 1], &pThis->aFacilityStatuses[i],
751 cToMove * sizeof(pThis->aFacilityStatuses[i]));
752 pThis->cFacilityStatuses++;
753
754 /* Initialize. */
755 pThis->aFacilityStatuses[i].enmFacility = enmFacility;
756 pThis->aFacilityStatuses[i].enmStatus = VBoxGuestFacilityStatus_Inactive;
757 pThis->aFacilityStatuses[i].fFixed = fFixed;
758 pThis->aFacilityStatuses[i].afPadding[0] = 0;
759 pThis->aFacilityStatuses[i].afPadding[1] = 0;
760 pThis->aFacilityStatuses[i].afPadding[2] = 0;
761 pThis->aFacilityStatuses[i].fFlags = 0;
762 if (pTimeSpecNow)
763 pThis->aFacilityStatuses[i].TimeSpecTS = *pTimeSpecNow;
764 else
765 RTTimeSpecSetNano(&pThis->aFacilityStatuses[i].TimeSpecTS, 0);
766
767 return &pThis->aFacilityStatuses[i];
768}
769
770
771/**
772 * Gets a facility status entry, allocating a new one if not already present.
773 *
774 * @returns Pointer to a facility status entry on success, NULL on failure
775 * (table full).
776 * @param pThis The VMMDev instance data.
777 * @param enmFacility The facility type code.
778 */
779static PVMMDEVFACILITYSTATUSENTRY vmmdevGetFacilityStatusEntry(PVMMDEV pThis, VBoxGuestFacilityType enmFacility)
780{
781 /** @todo change to binary search. */
782 uint32_t i = pThis->cFacilityStatuses;
783 while (i-- > 0)
784 {
785 if (pThis->aFacilityStatuses[i].enmFacility == enmFacility)
786 return &pThis->aFacilityStatuses[i];
787 if ((uint32_t)pThis->aFacilityStatuses[i].enmFacility < (uint32_t)enmFacility)
788 break;
789 }
790 return vmmdevAllocFacilityStatusEntry(pThis, enmFacility, false /*fFixed*/, NULL);
791}
792
793
794/**
795 * Handles VMMDevReq_ReportGuestStatus.
796 *
797 * @returns VBox status code that the guest should see.
798 * @param pThis The VMMDev instance data.
799 * @param pReqHdr The header of the request to handle.
800 */
801static int vmmdevReqHandler_ReportGuestStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
802{
803 /*
804 * Validate input.
805 */
806 AssertMsgReturn(pReqHdr->size == sizeof(VMMDevReportGuestStatus), ("%u\n", pReqHdr->size), VERR_INVALID_PARAMETER);
807 VBoxGuestStatus *pStatus = &((VMMDevReportGuestStatus *)pReqHdr)->guestStatus;
808 AssertMsgReturn( pStatus->facility > VBoxGuestFacilityType_Unknown
809 && pStatus->facility <= VBoxGuestFacilityType_All,
810 ("%d\n", pStatus->facility),
811 VERR_INVALID_PARAMETER);
812 AssertMsgReturn(pStatus->status == (VBoxGuestFacilityStatus)(uint16_t)pStatus->status,
813 ("%#x (%u)\n", pStatus->status, pStatus->status),
814 VERR_OUT_OF_RANGE);
815
816 /*
817 * Do the update.
818 */
819 RTTIMESPEC Now;
820 RTTimeNow(&Now);
821 if (pStatus->facility == VBoxGuestFacilityType_All)
822 {
823 uint32_t i = pThis->cFacilityStatuses;
824 while (i-- > 0)
825 {
826 pThis->aFacilityStatuses[i].TimeSpecTS = Now;
827 pThis->aFacilityStatuses[i].enmStatus = pStatus->status;
828 pThis->aFacilityStatuses[i].fFlags = pStatus->flags;
829 }
830 }
831 else
832 {
833 PVMMDEVFACILITYSTATUSENTRY pEntry = vmmdevGetFacilityStatusEntry(pThis, pStatus->facility);
834 if (!pEntry)
835 {
836 LogRelMax(10, ("VMMDev: Facility table is full - facility=%u status=%u\n", pStatus->facility, pStatus->status));
837 return VERR_OUT_OF_RESOURCES;
838 }
839
840 pEntry->TimeSpecTS = Now;
841 pEntry->enmStatus = pStatus->status;
842 pEntry->fFlags = pStatus->flags;
843 }
844
845 if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestStatus)
846 pThis->pDrv->pfnUpdateGuestStatus(pThis->pDrv, pStatus->facility, pStatus->status, pStatus->flags, &Now);
847
848 return VINF_SUCCESS;
849}
850
851
852/**
853 * Handles VMMDevReq_ReportGuestUserState.
854 *
855 * @returns VBox status code that the guest should see.
856 * @param pThis The VMMDev instance data.
857 * @param pReqHdr The header of the request to handle.
858 */
859static int vmmdevReqHandler_ReportGuestUserState(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
860{
861 /*
862 * Validate input.
863 */
864 VMMDevReportGuestUserState *pReq = (VMMDevReportGuestUserState *)pReqHdr;
865 AssertMsgReturn(pReq->header.size >= sizeof(*pReq), ("%u\n", pReqHdr->size), VERR_INVALID_PARAMETER);
866
867 if ( pThis->pDrv
868 && pThis->pDrv->pfnUpdateGuestUserState)
869 {
870 /* Play safe. */
871 AssertReturn(pReq->header.size <= _2K, VERR_TOO_MUCH_DATA);
872 AssertReturn(pReq->status.cbUser <= 256, VERR_TOO_MUCH_DATA);
873 AssertReturn(pReq->status.cbDomain <= 256, VERR_TOO_MUCH_DATA);
874 AssertReturn(pReq->status.cbDetails <= _1K, VERR_TOO_MUCH_DATA);
875
876 /* pbDynamic marks the beginning of the struct's dynamically
877 * allocated data area. */
878 uint8_t *pbDynamic = (uint8_t *)&pReq->status.szUser;
879 uint32_t cbLeft = pReqHdr->size - RT_OFFSETOF(VMMDevReportGuestUserState, status.szUser);
880
881 /* The user. */
882 AssertReturn(pReq->status.cbUser > 0, VERR_INVALID_PARAMETER); /* User name is required. */
883 AssertReturn(pReq->status.cbUser <= cbLeft, VERR_INVALID_PARAMETER);
884 const char *pszUser = (const char *)pbDynamic;
885 AssertReturn(RTStrEnd(pszUser, pReq->status.cbUser), VERR_INVALID_PARAMETER);
886 int rc = RTStrValidateEncoding(pszUser);
887 AssertRCReturn(rc, rc);
888
889 /* Advance to the next field. */
890 pbDynamic += pReq->status.cbUser;
891 cbLeft -= pReq->status.cbUser;
892
893 /* pszDomain can be NULL. */
894 AssertReturn(pReq->status.cbDomain <= cbLeft, VERR_INVALID_PARAMETER);
895 const char *pszDomain = NULL;
896 if (pReq->status.cbDomain)
897 {
898 pszDomain = (const char *)pbDynamic;
899 AssertReturn(RTStrEnd(pszDomain, pReq->status.cbDomain), VERR_INVALID_PARAMETER);
900 rc = RTStrValidateEncoding(pszDomain);
901 AssertRCReturn(rc, rc);
902
903 /* Advance to the next field. */
904 pbDynamic += pReq->status.cbDomain;
905 cbLeft -= pReq->status.cbDomain;
906 }
907
908 /* pbDetails can be NULL. */
909 const uint8_t *pbDetails = NULL;
910 AssertReturn(pReq->status.cbDetails <= cbLeft, VERR_INVALID_PARAMETER);
911 if (pReq->status.cbDetails > 0)
912 pbDetails = pbDynamic;
913
914 pThis->pDrv->pfnUpdateGuestUserState(pThis->pDrv, pszUser, pszDomain, (uint32_t)pReq->status.state,
915 pbDetails, pReq->status.cbDetails);
916 }
917
918 return VINF_SUCCESS;
919}
920
921
922/**
923 * Handles VMMDevReq_ReportGuestCapabilities.
924 *
925 * @returns VBox status code that the guest should see.
926 * @param pThis The VMMDev instance data.
927 * @param pReqHdr The header of the request to handle.
928 */
929static int vmmdevReqHandler_ReportGuestCapabilities(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
930{
931 VMMDevReqGuestCapabilities *pReq = (VMMDevReqGuestCapabilities *)pReqHdr;
932 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
933
934 /* Enable VMMDEV_GUEST_SUPPORTS_GRAPHICS automatically for guests using the old
935 * request to report their capabilities.
936 */
937 const uint32_t fu32Caps = pReq->caps | VMMDEV_GUEST_SUPPORTS_GRAPHICS;
938
939 if (pThis->guestCaps != fu32Caps)
940 {
941 /* make a copy of supplied information */
942 pThis->guestCaps = fu32Caps;
943
944 LogRel(("VMMDev: Guest Additions capability report (legacy): (0x%x) seamless: %s, hostWindowMapping: %s, graphics: yes\n",
945 fu32Caps,
946 fu32Caps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
947 fu32Caps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no"));
948
949 if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestCapabilities)
950 pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, fu32Caps);
951 }
952 return VINF_SUCCESS;
953}
954
955
956/**
957 * Handles VMMDevReq_SetGuestCapabilities.
958 *
959 * @returns VBox status code that the guest should see.
960 * @param pThis The VMMDev instance data.
961 * @param pReqHdr The header of the request to handle.
962 */
963static int vmmdevReqHandler_SetGuestCapabilities(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
964{
965 VMMDevReqGuestCapabilities2 *pReq = (VMMDevReqGuestCapabilities2 *)pReqHdr;
966 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
967
968 uint32_t fu32Caps = pThis->guestCaps;
969 fu32Caps |= pReq->u32OrMask;
970 fu32Caps &= ~pReq->u32NotMask;
971
972 LogRel(("VMMDev: Guest Additions capability report: (%#x -> %#x) seamless: %s, hostWindowMapping: %s, graphics: %s\n",
973 pThis->guestCaps, fu32Caps,
974 fu32Caps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
975 fu32Caps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no",
976 fu32Caps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? "yes" : "no"));
977
978 pThis->guestCaps = fu32Caps;
979
980 if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestCapabilities)
981 pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, fu32Caps);
982
983 return VINF_SUCCESS;
984}
985
986
987/**
988 * Handles VMMDevReq_GetMouseStatus.
989 *
990 * @returns VBox status code that the guest should see.
991 * @param pThis The VMMDev instance data.
992 * @param pReqHdr The header of the request to handle.
993 */
994static int vmmdevReqHandler_GetMouseStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
995{
996 VMMDevReqMouseStatus *pReq = (VMMDevReqMouseStatus *)pReqHdr;
997 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
998
999 pReq->mouseFeatures = pThis->mouseCapabilities
1000 & VMMDEV_MOUSE_MASK;
1001 pReq->pointerXPos = pThis->mouseXAbs;
1002 pReq->pointerYPos = pThis->mouseYAbs;
1003 LogRel2(("VMMDev: vmmdevReqHandler_GetMouseStatus: mouseFeatures=%#x, xAbs=%d, yAbs=%d\n",
1004 pReq->mouseFeatures, pReq->pointerXPos, pReq->pointerYPos));
1005 return VINF_SUCCESS;
1006}
1007
1008
1009/**
1010 * Handles VMMDevReq_SetMouseStatus.
1011 *
1012 * @returns VBox status code that the guest should see.
1013 * @param pThis The VMMDev instance data.
1014 * @param pReqHdr The header of the request to handle.
1015 */
1016static int vmmdevReqHandler_SetMouseStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1017{
1018 VMMDevReqMouseStatus *pReq = (VMMDevReqMouseStatus *)pReqHdr;
1019 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1020
1021 LogRelFlow(("VMMDev: vmmdevReqHandler_SetMouseStatus: mouseFeatures=%#x\n", pReq->mouseFeatures));
1022
1023 bool fNotify = false;
1024 if ( (pReq->mouseFeatures & VMMDEV_MOUSE_NOTIFY_HOST_MASK)
1025 != ( pThis->mouseCapabilities
1026 & VMMDEV_MOUSE_NOTIFY_HOST_MASK))
1027 fNotify = true;
1028
1029 pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_MASK;
1030 pThis->mouseCapabilities |= (pReq->mouseFeatures & VMMDEV_MOUSE_GUEST_MASK);
1031
1032 LogRelFlow(("VMMDev: vmmdevReqHandler_SetMouseStatus: New host capabilities: %#x\n", pThis->mouseCapabilities));
1033
1034 /*
1035 * Notify connector if something changed.
1036 */
1037 if (fNotify)
1038 {
1039 LogRelFlow(("VMMDev: vmmdevReqHandler_SetMouseStatus: Notifying connector\n"));
1040 pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
1041 }
1042
1043 return VINF_SUCCESS;
1044}
1045
1046static int vmmdevVerifyPointerShape(VMMDevReqMousePointer *pReq)
1047{
1048 /* Should be enough for most mouse pointers. */
1049 if (pReq->width > 8192 || pReq->height > 8192)
1050 return VERR_INVALID_PARAMETER;
1051
1052 uint32_t cbShape = (pReq->width + 7) / 8 * pReq->height; /* size of the AND mask */
1053 cbShape = ((cbShape + 3) & ~3) + pReq->width * 4 * pReq->height; /* + gap + size of the XOR mask */
1054 if (RT_UOFFSETOF(VMMDevReqMousePointer, pointerData) + cbShape > pReq->header.size)
1055 return VERR_INVALID_PARAMETER;
1056
1057 return VINF_SUCCESS;
1058}
1059
1060/**
1061 * Handles VMMDevReq_SetPointerShape.
1062 *
1063 * @returns VBox status code that the guest should see.
1064 * @param pThis The VMMDev instance data.
1065 * @param pReqHdr The header of the request to handle.
1066 */
1067static int vmmdevReqHandler_SetPointerShape(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1068{
1069 VMMDevReqMousePointer *pReq = (VMMDevReqMousePointer *)pReqHdr;
1070 if (pReq->header.size < sizeof(*pReq))
1071 {
1072 AssertMsg(pReq->header.size == 0x10028 && pReq->header.version == 10000, /* don't complain about legacy!!! */
1073 ("VMMDev mouse shape structure has invalid size %d (%#x) version=%d!\n",
1074 pReq->header.size, pReq->header.size, pReq->header.version));
1075 return VERR_INVALID_PARAMETER;
1076 }
1077
1078 bool fVisible = RT_BOOL(pReq->fFlags & VBOX_MOUSE_POINTER_VISIBLE);
1079 bool fAlpha = RT_BOOL(pReq->fFlags & VBOX_MOUSE_POINTER_ALPHA);
1080 bool fShape = RT_BOOL(pReq->fFlags & VBOX_MOUSE_POINTER_SHAPE);
1081
1082 Log(("VMMDevReq_SetPointerShape: visible: %d, alpha: %d, shape = %d, width: %d, height: %d\n",
1083 fVisible, fAlpha, fShape, pReq->width, pReq->height));
1084
1085 if (pReq->header.size == sizeof(VMMDevReqMousePointer))
1086 {
1087 /* The guest did not provide the shape actually. */
1088 fShape = false;
1089 }
1090
1091 /* forward call to driver */
1092 if (fShape)
1093 {
1094 int rc = vmmdevVerifyPointerShape(pReq);
1095 if (RT_FAILURE(rc))
1096 return rc;
1097
1098 pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
1099 fVisible,
1100 fAlpha,
1101 pReq->xHot, pReq->yHot,
1102 pReq->width, pReq->height,
1103 pReq->pointerData);
1104 }
1105 else
1106 {
1107 pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
1108 fVisible,
1109 0,
1110 0, 0,
1111 0, 0,
1112 NULL);
1113 }
1114
1115 pThis->fHostCursorRequested = fVisible;
1116 return VINF_SUCCESS;
1117}
1118
1119
1120/**
1121 * Handles VMMDevReq_GetHostTime.
1122 *
1123 * @returns VBox status code that the guest should see.
1124 * @param pThis The VMMDev instance data.
1125 * @param pReqHdr The header of the request to handle.
1126 */
1127static int vmmdevReqHandler_GetHostTime(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1128{
1129 VMMDevReqHostTime *pReq = (VMMDevReqHostTime *)pReqHdr;
1130 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1131
1132 if (RT_LIKELY(!pThis->fGetHostTimeDisabled))
1133 {
1134 RTTIMESPEC now;
1135 pReq->time = RTTimeSpecGetMilli(PDMDevHlpTMUtcNow(pThis->pDevIns, &now));
1136 return VINF_SUCCESS;
1137 }
1138 return VERR_NOT_SUPPORTED;
1139}
1140
1141
1142/**
1143 * Handles VMMDevReq_GetHypervisorInfo.
1144 *
1145 * @returns VBox status code that the guest should see.
1146 * @param pThis The VMMDev instance data.
1147 * @param pReqHdr The header of the request to handle.
1148 */
1149static int vmmdevReqHandler_GetHypervisorInfo(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1150{
1151 VMMDevReqHypervisorInfo *pReq = (VMMDevReqHypervisorInfo *)pReqHdr;
1152 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1153
1154 return PGMR3MappingsSize(PDMDevHlpGetVM(pThis->pDevIns), &pReq->hypervisorSize);
1155}
1156
1157
1158/**
1159 * Handles VMMDevReq_SetHypervisorInfo.
1160 *
1161 * @returns VBox status code that the guest should see.
1162 * @param pThis The VMMDev instance data.
1163 * @param pReqHdr The header of the request to handle.
1164 */
1165static int vmmdevReqHandler_SetHypervisorInfo(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1166{
1167 VMMDevReqHypervisorInfo *pReq = (VMMDevReqHypervisorInfo *)pReqHdr;
1168 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1169
1170 int rc;
1171 PVM pVM = PDMDevHlpGetVM(pThis->pDevIns);
1172 if (pReq->hypervisorStart == 0)
1173 rc = PGMR3MappingsUnfix(pVM);
1174 else
1175 {
1176 /* only if the client has queried the size before! */
1177 uint32_t cbMappings;
1178 rc = PGMR3MappingsSize(pVM, &cbMappings);
1179 if (RT_SUCCESS(rc) && pReq->hypervisorSize == cbMappings)
1180 {
1181 /* new reservation */
1182 rc = PGMR3MappingsFix(pVM, pReq->hypervisorStart, pReq->hypervisorSize);
1183 LogRel(("VMMDev: Guest reported fixed hypervisor window at 0%010x LB %#x (rc=%Rrc)\n",
1184 pReq->hypervisorStart, pReq->hypervisorSize, rc));
1185 }
1186 else if (RT_FAILURE(rc))
1187 rc = VERR_TRY_AGAIN;
1188 }
1189 return rc;
1190}
1191
1192
1193/**
1194 * Handles VMMDevReq_RegisterPatchMemory.
1195 *
1196 * @returns VBox status code that the guest should see.
1197 * @param pThis The VMMDev instance data.
1198 * @param pReqHdr The header of the request to handle.
1199 */
1200static int vmmdevReqHandler_RegisterPatchMemory(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1201{
1202 VMMDevReqPatchMemory *pReq = (VMMDevReqPatchMemory *)pReqHdr;
1203 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1204
1205 return VMMR3RegisterPatchMemory(PDMDevHlpGetVM(pThis->pDevIns), pReq->pPatchMem, pReq->cbPatchMem);
1206}
1207
1208
1209/**
1210 * Handles VMMDevReq_DeregisterPatchMemory.
1211 *
1212 * @returns VBox status code that the guest should see.
1213 * @param pThis The VMMDev instance data.
1214 * @param pReqHdr The header of the request to handle.
1215 */
1216static int vmmdevReqHandler_DeregisterPatchMemory(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1217{
1218 VMMDevReqPatchMemory *pReq = (VMMDevReqPatchMemory *)pReqHdr;
1219 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1220
1221 return VMMR3DeregisterPatchMemory(PDMDevHlpGetVM(pThis->pDevIns), pReq->pPatchMem, pReq->cbPatchMem);
1222}
1223
1224
1225/**
1226 * Handles VMMDevReq_SetPowerStatus.
1227 *
1228 * @returns VBox status code that the guest should see.
1229 * @param pThis The VMMDev instance data.
1230 * @param pReqHdr The header of the request to handle.
1231 */
1232static int vmmdevReqHandler_SetPowerStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1233{
1234 VMMDevPowerStateRequest *pReq = (VMMDevPowerStateRequest *)pReqHdr;
1235 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1236
1237 switch (pReq->powerState)
1238 {
1239 case VMMDevPowerState_Pause:
1240 {
1241 LogRel(("VMMDev: Guest requests the VM to be suspended (paused)\n"));
1242 return PDMDevHlpVMSuspend(pThis->pDevIns);
1243 }
1244
1245 case VMMDevPowerState_PowerOff:
1246 {
1247 LogRel(("VMMDev: Guest requests the VM to be turned off\n"));
1248 return PDMDevHlpVMPowerOff(pThis->pDevIns);
1249 }
1250
1251 case VMMDevPowerState_SaveState:
1252 {
1253 if (true /*pThis->fAllowGuestToSaveState*/)
1254 {
1255 LogRel(("VMMDev: Guest requests the VM to be saved and powered off\n"));
1256 return PDMDevHlpVMSuspendSaveAndPowerOff(pThis->pDevIns);
1257 }
1258 LogRel(("VMMDev: Guest requests the VM to be saved and powered off, declined\n"));
1259 return VERR_ACCESS_DENIED;
1260 }
1261
1262 default:
1263 AssertMsgFailed(("VMMDev: Invalid power state request: %d\n", pReq->powerState));
1264 return VERR_INVALID_PARAMETER;
1265 }
1266}
1267
1268
1269/**
1270 * Handles VMMDevReq_GetDisplayChangeRequest
1271 *
1272 * @returns VBox status code that the guest should see.
1273 * @param pThis The VMMDev instance data.
1274 * @param pReqHdr The header of the request to handle.
1275 * @remarks Deprecated.
1276 */
1277static int vmmdevReqHandler_GetDisplayChangeRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1278{
1279 VMMDevDisplayChangeRequest *pReq = (VMMDevDisplayChangeRequest *)pReqHdr;
1280 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1281
1282/**
1283 * @todo It looks like a multi-monitor guest which only uses
1284 * @c VMMDevReq_GetDisplayChangeRequest (not the *2 version) will get
1285 * into a @c VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST event loop if it tries
1286 * to acknowlege host requests for additional monitors. Should the loop
1287 * which checks for those requests be removed?
1288 */
1289
1290 DISPLAYCHANGEREQUEST *pDispRequest = &pThis->displayChangeData.aRequests[0];
1291
1292 if (pReq->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
1293 {
1294 /* Current request has been read at least once. */
1295 pDispRequest->fPending = false;
1296
1297 /* Check if there are more pending requests. */
1298 for (unsigned i = 1; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1299 {
1300 if (pThis->displayChangeData.aRequests[i].fPending)
1301 {
1302 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
1303 break;
1304 }
1305 }
1306
1307 /* Remember which resolution the client has queried, subsequent reads
1308 * will return the same values. */
1309 pDispRequest->lastReadDisplayChangeRequest = pDispRequest->displayChangeRequest;
1310 pThis->displayChangeData.fGuestSentChangeEventAck = true;
1311 }
1312
1313 if (pThis->displayChangeData.fGuestSentChangeEventAck)
1314 {
1315 pReq->xres = pDispRequest->lastReadDisplayChangeRequest.xres;
1316 pReq->yres = pDispRequest->lastReadDisplayChangeRequest.yres;
1317 pReq->bpp = pDispRequest->lastReadDisplayChangeRequest.bpp;
1318 }
1319 else
1320 {
1321 /* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
1322 * read the last valid video mode hint. This happens when the guest X server
1323 * determines the initial mode. */
1324 pReq->xres = pDispRequest->displayChangeRequest.xres;
1325 pReq->yres = pDispRequest->displayChangeRequest.yres;
1326 pReq->bpp = pDispRequest->displayChangeRequest.bpp;
1327 }
1328 Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d\n", pReq->xres, pReq->yres, pReq->bpp));
1329
1330 return VINF_SUCCESS;
1331}
1332
1333
1334/**
1335 * Handles VMMDevReq_GetDisplayChangeRequest2.
1336 *
1337 * @returns VBox status code that the guest should see.
1338 * @param pThis The VMMDev instance data.
1339 * @param pReqHdr The header of the request to handle.
1340 */
1341static int vmmdevReqHandler_GetDisplayChangeRequest2(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1342{
1343 VMMDevDisplayChangeRequest2 *pReq = (VMMDevDisplayChangeRequest2 *)pReqHdr;
1344 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1345
1346 DISPLAYCHANGEREQUEST *pDispRequest = NULL;
1347
1348 if (pReq->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
1349 {
1350 /* Select a pending request to report. */
1351 unsigned i;
1352 for (i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1353 {
1354 if (pThis->displayChangeData.aRequests[i].fPending)
1355 {
1356 pDispRequest = &pThis->displayChangeData.aRequests[i];
1357 /* Remember which request should be reported. */
1358 pThis->displayChangeData.iCurrentMonitor = i;
1359 Log3(("VMMDev: will report pending request for %u\n", i));
1360 break;
1361 }
1362 }
1363
1364 /* Check if there are more pending requests. */
1365 i++;
1366 for (; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1367 {
1368 if (pThis->displayChangeData.aRequests[i].fPending)
1369 {
1370 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
1371 Log3(("VMMDev: another pending at %u\n", i));
1372 break;
1373 }
1374 }
1375
1376 if (pDispRequest)
1377 {
1378 /* Current request has been read at least once. */
1379 pDispRequest->fPending = false;
1380
1381 /* Remember which resolution the client has queried, subsequent reads
1382 * will return the same values. */
1383 pDispRequest->lastReadDisplayChangeRequest = pDispRequest->displayChangeRequest;
1384 pThis->displayChangeData.fGuestSentChangeEventAck = true;
1385 }
1386 else
1387 {
1388 Log3(("VMMDev: no pending request!!!\n"));
1389 }
1390 }
1391
1392 if (!pDispRequest)
1393 {
1394 Log3(("VMMDev: default to %d\n", pThis->displayChangeData.iCurrentMonitor));
1395 pDispRequest = &pThis->displayChangeData.aRequests[pThis->displayChangeData.iCurrentMonitor];
1396 }
1397
1398 if (pThis->displayChangeData.fGuestSentChangeEventAck)
1399 {
1400 pReq->xres = pDispRequest->lastReadDisplayChangeRequest.xres;
1401 pReq->yres = pDispRequest->lastReadDisplayChangeRequest.yres;
1402 pReq->bpp = pDispRequest->lastReadDisplayChangeRequest.bpp;
1403 pReq->display = pDispRequest->lastReadDisplayChangeRequest.display;
1404 }
1405 else
1406 {
1407 /* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
1408 * read the last valid video mode hint. This happens when the guest X server
1409 * determines the initial video mode. */
1410 pReq->xres = pDispRequest->displayChangeRequest.xres;
1411 pReq->yres = pDispRequest->displayChangeRequest.yres;
1412 pReq->bpp = pDispRequest->displayChangeRequest.bpp;
1413 pReq->display = pDispRequest->displayChangeRequest.display;
1414 }
1415 Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d at %d\n",
1416 pReq->xres, pReq->yres, pReq->bpp, pReq->display));
1417
1418 return VINF_SUCCESS;
1419}
1420
1421
1422/**
1423 * Handles VMMDevReq_GetDisplayChangeRequestEx.
1424 *
1425 * @returns VBox status code that the guest should see.
1426 * @param pThis The VMMDev instance data.
1427 * @param pReqHdr The header of the request to handle.
1428 */
1429static int vmmdevReqHandler_GetDisplayChangeRequestEx(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1430{
1431 VMMDevDisplayChangeRequestEx *pReq = (VMMDevDisplayChangeRequestEx *)pReqHdr;
1432 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1433
1434 DISPLAYCHANGEREQUEST *pDispRequest = NULL;
1435
1436 if (pReq->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
1437 {
1438 /* Select a pending request to report. */
1439 unsigned i;
1440 for (i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1441 {
1442 if (pThis->displayChangeData.aRequests[i].fPending)
1443 {
1444 pDispRequest = &pThis->displayChangeData.aRequests[i];
1445 /* Remember which request should be reported. */
1446 pThis->displayChangeData.iCurrentMonitor = i;
1447 Log3(("VMMDev: will report pending request for %d\n",
1448 i));
1449 break;
1450 }
1451 }
1452
1453 /* Check if there are more pending requests. */
1454 i++;
1455 for (; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1456 {
1457 if (pThis->displayChangeData.aRequests[i].fPending)
1458 {
1459 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
1460 Log3(("VMMDev: another pending at %d\n",
1461 i));
1462 break;
1463 }
1464 }
1465
1466 if (pDispRequest)
1467 {
1468 /* Current request has been read at least once. */
1469 pDispRequest->fPending = false;
1470
1471 /* Remember which resolution the client has queried, subsequent reads
1472 * will return the same values. */
1473 pDispRequest->lastReadDisplayChangeRequest = pDispRequest->displayChangeRequest;
1474 pThis->displayChangeData.fGuestSentChangeEventAck = true;
1475 }
1476 else
1477 {
1478 Log3(("VMMDev: no pending request!!!\n"));
1479 }
1480 }
1481
1482 if (!pDispRequest)
1483 {
1484 Log3(("VMMDev: default to %d\n",
1485 pThis->displayChangeData.iCurrentMonitor));
1486 pDispRequest = &pThis->displayChangeData.aRequests[pThis->displayChangeData.iCurrentMonitor];
1487 }
1488
1489 if (pThis->displayChangeData.fGuestSentChangeEventAck)
1490 {
1491 pReq->xres = pDispRequest->lastReadDisplayChangeRequest.xres;
1492 pReq->yres = pDispRequest->lastReadDisplayChangeRequest.yres;
1493 pReq->bpp = pDispRequest->lastReadDisplayChangeRequest.bpp;
1494 pReq->display = pDispRequest->lastReadDisplayChangeRequest.display;
1495 pReq->cxOrigin = pDispRequest->lastReadDisplayChangeRequest.xOrigin;
1496 pReq->cyOrigin = pDispRequest->lastReadDisplayChangeRequest.yOrigin;
1497 pReq->fEnabled = pDispRequest->lastReadDisplayChangeRequest.fEnabled;
1498 pReq->fChangeOrigin = pDispRequest->lastReadDisplayChangeRequest.fChangeOrigin;
1499 }
1500 else
1501 {
1502 /* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
1503 * read the last valid video mode hint. This happens when the guest X server
1504 * determines the initial video mode. */
1505 pReq->xres = pDispRequest->displayChangeRequest.xres;
1506 pReq->yres = pDispRequest->displayChangeRequest.yres;
1507 pReq->bpp = pDispRequest->displayChangeRequest.bpp;
1508 pReq->display = pDispRequest->displayChangeRequest.display;
1509 pReq->cxOrigin = pDispRequest->displayChangeRequest.xOrigin;
1510 pReq->cyOrigin = pDispRequest->displayChangeRequest.yOrigin;
1511 pReq->fEnabled = pDispRequest->displayChangeRequest.fEnabled;
1512 pReq->fChangeOrigin = pDispRequest->displayChangeRequest.fChangeOrigin;
1513
1514 }
1515 Log(("VMMDevEx: returning display change request xres = %d, yres = %d, bpp = %d id %d xPos = %d, yPos = %d & Enabled=%d\n",
1516 pReq->xres, pReq->yres, pReq->bpp, pReq->display, pReq->cxOrigin, pReq->cyOrigin, pReq->fEnabled));
1517
1518 return VINF_SUCCESS;
1519}
1520
1521
1522/**
1523 * Handles VMMDevReq_VideoModeSupported.
1524 *
1525 * Query whether the given video mode is supported.
1526 *
1527 * @returns VBox status code that the guest should see.
1528 * @param pThis The VMMDev instance data.
1529 * @param pReqHdr The header of the request to handle.
1530 */
1531static int vmmdevReqHandler_VideoModeSupported(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1532{
1533 VMMDevVideoModeSupportedRequest *pReq = (VMMDevVideoModeSupportedRequest *)pReqHdr;
1534 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1535
1536 /* forward the call */
1537 return pThis->pDrv->pfnVideoModeSupported(pThis->pDrv,
1538 0, /* primary screen. */
1539 pReq->width,
1540 pReq->height,
1541 pReq->bpp,
1542 &pReq->fSupported);
1543}
1544
1545
1546/**
1547 * Handles VMMDevReq_VideoModeSupported2.
1548 *
1549 * Query whether the given video mode is supported for a specific display
1550 *
1551 * @returns VBox status code that the guest should see.
1552 * @param pThis The VMMDev instance data.
1553 * @param pReqHdr The header of the request to handle.
1554 */
1555static int vmmdevReqHandler_VideoModeSupported2(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1556{
1557 VMMDevVideoModeSupportedRequest2 *pReq = (VMMDevVideoModeSupportedRequest2 *)pReqHdr;
1558 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1559
1560 /* forward the call */
1561 return pThis->pDrv->pfnVideoModeSupported(pThis->pDrv,
1562 pReq->display,
1563 pReq->width,
1564 pReq->height,
1565 pReq->bpp,
1566 &pReq->fSupported);
1567}
1568
1569
1570
1571/**
1572 * Handles VMMDevReq_GetHeightReduction.
1573 *
1574 * @returns VBox status code that the guest should see.
1575 * @param pThis The VMMDev instance data.
1576 * @param pReqHdr The header of the request to handle.
1577 */
1578static int vmmdevReqHandler_GetHeightReduction(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1579{
1580 VMMDevGetHeightReductionRequest *pReq = (VMMDevGetHeightReductionRequest *)pReqHdr;
1581 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1582
1583 /* forward the call */
1584 return pThis->pDrv->pfnGetHeightReduction(pThis->pDrv, &pReq->heightReduction);
1585}
1586
1587
1588/**
1589 * Handles VMMDevReq_AcknowledgeEvents.
1590 *
1591 * @returns VBox status code that the guest should see.
1592 * @param pThis The VMMDev instance data.
1593 * @param pReqHdr The header of the request to handle.
1594 */
1595static int vmmdevReqHandler_AcknowledgeEvents(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1596{
1597 VMMDevEvents *pReq = (VMMDevEvents *)pReqHdr;
1598 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1599
1600 if (!VMMDEV_INTERFACE_VERSION_IS_1_03(pThis))
1601 {
1602 if (pThis->fNewGuestFilterMask)
1603 {
1604 pThis->fNewGuestFilterMask = false;
1605 pThis->u32GuestFilterMask = pThis->u32NewGuestFilterMask;
1606 }
1607
1608 pReq->events = pThis->u32HostEventFlags & pThis->u32GuestFilterMask;
1609
1610 pThis->u32HostEventFlags &= ~pThis->u32GuestFilterMask;
1611 pThis->pVMMDevRAMR3->V.V1_04.fHaveEvents = false;
1612 PDMDevHlpPCISetIrqNoWait(pThis->pDevIns, 0, 0);
1613 }
1614 else
1615 vmmdevSetIRQ_Legacy(pThis);
1616 return VINF_SUCCESS;
1617}
1618
1619
1620/**
1621 * Handles VMMDevReq_CtlGuestFilterMask.
1622 *
1623 * @returns VBox status code that the guest should see.
1624 * @param pThis The VMMDev instance data.
1625 * @param pReqHdr The header of the request to handle.
1626 */
1627static int vmmdevReqHandler_CtlGuestFilterMask(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1628{
1629 VMMDevCtlGuestFilterMask *pReq = (VMMDevCtlGuestFilterMask *)pReqHdr;
1630 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1631
1632 LogRelFlow(("VMMDev: vmmdevReqHandler_CtlGuestFilterMask: OR mask: %#x, NOT mask: %#x\n", pReq->u32OrMask, pReq->u32NotMask));
1633
1634 /* HGCM event notification is enabled by the VMMDev device
1635 * automatically when any HGCM command is issued. The guest
1636 * cannot disable these notifications. */
1637 VMMDevCtlSetGuestFilterMask(pThis, pReq->u32OrMask, pReq->u32NotMask & ~VMMDEV_EVENT_HGCM);
1638 return VINF_SUCCESS;
1639}
1640
1641#ifdef VBOX_WITH_HGCM
1642
1643/**
1644 * Handles VMMDevReq_HGCMConnect.
1645 *
1646 * @returns VBox status code that the guest should see.
1647 * @param pThis The VMMDev instance data.
1648 * @param pReqHdr The header of the request to handle.
1649 * @param GCPhysReqHdr The guest physical address of the request header.
1650 */
1651static int vmmdevReqHandler_HGCMConnect(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr, RTGCPHYS GCPhysReqHdr)
1652{
1653 VMMDevHGCMConnect *pReq = (VMMDevHGCMConnect *)pReqHdr;
1654 AssertMsgReturn(pReq->header.header.size >= sizeof(*pReq), ("%u\n", pReq->header.header.size), VERR_INVALID_PARAMETER); /** @todo Not sure why this is >= ... */
1655
1656 if (pThis->pHGCMDrv)
1657 {
1658 Log(("VMMDevReq_HGCMConnect\n"));
1659 return vmmdevHGCMConnect(pThis, pReq, GCPhysReqHdr);
1660 }
1661
1662 Log(("VMMDevReq_HGCMConnect: HGCM Connector is NULL!\n"));
1663 return VERR_NOT_SUPPORTED;
1664}
1665
1666
1667/**
1668 * Handles VMMDevReq_HGCMDisconnect.
1669 *
1670 * @returns VBox status code that the guest should see.
1671 * @param pThis The VMMDev instance data.
1672 * @param pReqHdr The header of the request to handle.
1673 * @param GCPhysReqHdr The guest physical address of the request header.
1674 */
1675static int vmmdevReqHandler_HGCMDisconnect(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr, RTGCPHYS GCPhysReqHdr)
1676{
1677 VMMDevHGCMDisconnect *pReq = (VMMDevHGCMDisconnect *)pReqHdr;
1678 AssertMsgReturn(pReq->header.header.size >= sizeof(*pReq), ("%u\n", pReq->header.header.size), VERR_INVALID_PARAMETER); /** @todo Not sure why this >= ... */
1679
1680 if (pThis->pHGCMDrv)
1681 {
1682 Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
1683 return vmmdevHGCMDisconnect(pThis, pReq, GCPhysReqHdr);
1684 }
1685
1686 Log(("VMMDevReq_VMMDevHGCMDisconnect: HGCM Connector is NULL!\n"));
1687 return VERR_NOT_SUPPORTED;
1688}
1689
1690
1691/**
1692 * Handles VMMDevReq_HGCMCall.
1693 *
1694 * @returns VBox status code that the guest should see.
1695 * @param pThis The VMMDev instance data.
1696 * @param pReqHdr The header of the request to handle.
1697 * @param GCPhysReqHdr The guest physical address of the request header.
1698 */
1699static int vmmdevReqHandler_HGCMCall(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr, RTGCPHYS GCPhysReqHdr)
1700{
1701 VMMDevHGCMCall *pReq = (VMMDevHGCMCall *)pReqHdr;
1702 AssertMsgReturn(pReq->header.header.size >= sizeof(*pReq), ("%u\n", pReq->header.header.size), VERR_INVALID_PARAMETER);
1703
1704 if (pThis->pHGCMDrv)
1705 {
1706 Log2(("VMMDevReq_HGCMCall: sizeof(VMMDevHGCMRequest) = %04X\n", sizeof(VMMDevHGCMCall)));
1707 Log2(("%.*Rhxd\n", pReq->header.header.size, pReq));
1708
1709 return vmmdevHGCMCall(pThis, pReq, pReq->header.header.size, GCPhysReqHdr, pReq->header.header.requestType);
1710 }
1711
1712 Log(("VMMDevReq_HGCMCall: HGCM Connector is NULL!\n"));
1713 return VERR_NOT_SUPPORTED;
1714}
1715
1716/**
1717 * Handles VMMDevReq_HGCMCancel.
1718 *
1719 * @returns VBox status code that the guest should see.
1720 * @param pThis The VMMDev instance data.
1721 * @param pReqHdr The header of the request to handle.
1722 * @param GCPhysReqHdr The guest physical address of the request header.
1723 */
1724static int vmmdevReqHandler_HGCMCancel(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr, RTGCPHYS GCPhysReqHdr)
1725{
1726 VMMDevHGCMCancel *pReq = (VMMDevHGCMCancel *)pReqHdr;
1727 AssertMsgReturn(pReq->header.header.size >= sizeof(*pReq), ("%u\n", pReq->header.header.size), VERR_INVALID_PARAMETER); /** @todo Not sure why this >= ... */
1728
1729 if (pThis->pHGCMDrv)
1730 {
1731 Log(("VMMDevReq_VMMDevHGCMCancel\n"));
1732 return vmmdevHGCMCancel(pThis, pReq, GCPhysReqHdr);
1733 }
1734
1735 Log(("VMMDevReq_VMMDevHGCMCancel: HGCM Connector is NULL!\n"));
1736 return VERR_NOT_SUPPORTED;
1737}
1738
1739
1740/**
1741 * Handles VMMDevReq_HGCMCancel2.
1742 *
1743 * @returns VBox status code that the guest should see.
1744 * @param pThis The VMMDev instance data.
1745 * @param pReqHdr The header of the request to handle.
1746 */
1747static int vmmdevReqHandler_HGCMCancel2(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1748{
1749 VMMDevHGCMCancel2 *pReq = (VMMDevHGCMCancel2 *)pReqHdr;
1750 AssertMsgReturn(pReq->header.size >= sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER); /** @todo Not sure why this >= ... */
1751
1752 if (pThis->pHGCMDrv)
1753 {
1754 Log(("VMMDevReq_HGCMCancel2\n"));
1755 return vmmdevHGCMCancel2(pThis, pReq->physReqToCancel);
1756 }
1757
1758 Log(("VMMDevReq_HGCMConnect2: HGCM Connector is NULL!\n"));
1759 return VERR_NOT_SUPPORTED;
1760}
1761
1762#endif /* VBOX_WITH_HGCM */
1763
1764
1765/**
1766 * Handles VMMDevReq_VideoAccelEnable.
1767 *
1768 * @returns VBox status code that the guest should see.
1769 * @param pThis The VMMDev instance data.
1770 * @param pReqHdr The header of the request to handle.
1771 */
1772static int vmmdevReqHandler_VideoAccelEnable(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1773{
1774 VMMDevVideoAccelEnable *pReq = (VMMDevVideoAccelEnable *)pReqHdr;
1775 AssertMsgReturn(pReq->header.size >= sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER); /** @todo Not sure why this >= ... */
1776
1777 if (!pThis->pDrv)
1778 {
1779 Log(("VMMDevReq_VideoAccelEnable Connector is NULL!!\n"));
1780 return VERR_NOT_SUPPORTED;
1781 }
1782
1783 if (pReq->cbRingBuffer != VMMDEV_VBVA_RING_BUFFER_SIZE)
1784 {
1785 /* The guest driver seems compiled with different headers. */
1786 LogRelMax(16,("VMMDevReq_VideoAccelEnable guest ring buffer size %#x, should be %#x!!\n", pReq->cbRingBuffer, VMMDEV_VBVA_RING_BUFFER_SIZE));
1787 return VERR_INVALID_PARAMETER;
1788 }
1789
1790 /* The request is correct. */
1791 pReq->fu32Status |= VBVA_F_STATUS_ACCEPTED;
1792
1793 LogFlow(("VMMDevReq_VideoAccelEnable pReq->u32Enable = %d\n", pReq->u32Enable));
1794
1795 int rc = pReq->u32Enable
1796 ? pThis->pDrv->pfnVideoAccelEnable(pThis->pDrv, true, &pThis->pVMMDevRAMR3->vbvaMemory)
1797 : pThis->pDrv->pfnVideoAccelEnable(pThis->pDrv, false, NULL);
1798
1799 if ( pReq->u32Enable
1800 && RT_SUCCESS(rc))
1801 {
1802 pReq->fu32Status |= VBVA_F_STATUS_ENABLED;
1803
1804 /* Remember that guest successfully enabled acceleration.
1805 * We need to reestablish it on restoring the VM from saved state.
1806 */
1807 pThis->u32VideoAccelEnabled = 1;
1808 }
1809 else
1810 {
1811 /* The acceleration was not enabled. Remember that. */
1812 pThis->u32VideoAccelEnabled = 0;
1813 }
1814 return VINF_SUCCESS;
1815}
1816
1817
1818/**
1819 * Handles VMMDevReq_VideoAccelFlush.
1820 *
1821 * @returns VBox status code that the guest should see.
1822 * @param pThis The VMMDev instance data.
1823 * @param pReqHdr The header of the request to handle.
1824 */
1825static int vmmdevReqHandler_VideoAccelFlush(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1826{
1827 VMMDevVideoAccelFlush *pReq = (VMMDevVideoAccelFlush *)pReqHdr;
1828 AssertMsgReturn(pReq->header.size >= sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER); /** @todo Not sure why this >= ... */
1829
1830 if (!pThis->pDrv)
1831 {
1832 Log(("VMMDevReq_VideoAccelFlush: Connector is NULL!!!\n"));
1833 return VERR_NOT_SUPPORTED;
1834 }
1835
1836 pThis->pDrv->pfnVideoAccelFlush(pThis->pDrv);
1837 return VINF_SUCCESS;
1838}
1839
1840
1841/**
1842 * Handles VMMDevReq_VideoSetVisibleRegion.
1843 *
1844 * @returns VBox status code that the guest should see.
1845 * @param pThis The VMMDev instance data.
1846 * @param pReqHdr The header of the request to handle.
1847 */
1848static int vmmdevReqHandler_VideoSetVisibleRegion(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1849{
1850 VMMDevVideoSetVisibleRegion *pReq = (VMMDevVideoSetVisibleRegion *)pReqHdr;
1851 AssertMsgReturn(pReq->header.size + sizeof(RTRECT) >= sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1852
1853 if (!pThis->pDrv)
1854 {
1855 Log(("VMMDevReq_VideoSetVisibleRegion: Connector is NULL!!!\n"));
1856 return VERR_NOT_SUPPORTED;
1857 }
1858
1859 if ( pReq->cRect > _1M /* restrict to sane range */
1860 || pReq->header.size != sizeof(VMMDevVideoSetVisibleRegion) + pReq->cRect * sizeof(RTRECT) - sizeof(RTRECT))
1861 {
1862 Log(("VMMDevReq_VideoSetVisibleRegion: cRects=%#x doesn't match size=%#x or is out of bounds\n",
1863 pReq->cRect, pReq->header.size));
1864 return VERR_INVALID_PARAMETER;
1865 }
1866
1867 Log(("VMMDevReq_VideoSetVisibleRegion %d rectangles\n", pReq->cRect));
1868 /* forward the call */
1869 return pThis->pDrv->pfnSetVisibleRegion(pThis->pDrv, pReq->cRect, &pReq->Rect);
1870}
1871
1872
1873/**
1874 * Handles VMMDevReq_GetSeamlessChangeRequest.
1875 *
1876 * @returns VBox status code that the guest should see.
1877 * @param pThis The VMMDev instance data.
1878 * @param pReqHdr The header of the request to handle.
1879 */
1880static int vmmdevReqHandler_GetSeamlessChangeRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1881{
1882 VMMDevSeamlessChangeRequest *pReq = (VMMDevSeamlessChangeRequest *)pReqHdr;
1883 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1884
1885 /* just pass on the information */
1886 Log(("VMMDev: returning seamless change request mode=%d\n", pThis->fSeamlessEnabled));
1887 if (pThis->fSeamlessEnabled)
1888 pReq->mode = VMMDev_Seamless_Visible_Region;
1889 else
1890 pReq->mode = VMMDev_Seamless_Disabled;
1891
1892 if (pReq->eventAck == VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST)
1893 {
1894 /* Remember which mode the client has queried. */
1895 pThis->fLastSeamlessEnabled = pThis->fSeamlessEnabled;
1896 }
1897
1898 return VINF_SUCCESS;
1899}
1900
1901
1902/**
1903 * Handles VMMDevReq_GetVRDPChangeRequest.
1904 *
1905 * @returns VBox status code that the guest should see.
1906 * @param pThis The VMMDev instance data.
1907 * @param pReqHdr The header of the request to handle.
1908 */
1909static int vmmdevReqHandler_GetVRDPChangeRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1910{
1911 VMMDevVRDPChangeRequest *pReq = (VMMDevVRDPChangeRequest *)pReqHdr;
1912 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1913
1914 /* just pass on the information */
1915 Log(("VMMDev: returning VRDP status %d level %d\n", pThis->fVRDPEnabled, pThis->uVRDPExperienceLevel));
1916
1917 pReq->u8VRDPActive = pThis->fVRDPEnabled;
1918 pReq->u32VRDPExperienceLevel = pThis->uVRDPExperienceLevel;
1919
1920 return VINF_SUCCESS;
1921}
1922
1923
1924/**
1925 * Handles VMMDevReq_GetMemBalloonChangeRequest.
1926 *
1927 * @returns VBox status code that the guest should see.
1928 * @param pThis The VMMDev instance data.
1929 * @param pReqHdr The header of the request to handle.
1930 */
1931static int vmmdevReqHandler_GetMemBalloonChangeRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1932{
1933 VMMDevGetMemBalloonChangeRequest *pReq = (VMMDevGetMemBalloonChangeRequest *)pReqHdr;
1934 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1935
1936 /* just pass on the information */
1937 Log(("VMMDev: returning memory balloon size =%d\n", pThis->cMbMemoryBalloon));
1938 pReq->cBalloonChunks = pThis->cMbMemoryBalloon;
1939 pReq->cPhysMemChunks = pThis->cbGuestRAM / (uint64_t)_1M;
1940
1941 if (pReq->eventAck == VMMDEV_EVENT_BALLOON_CHANGE_REQUEST)
1942 {
1943 /* Remember which mode the client has queried. */
1944 pThis->cMbMemoryBalloonLast = pThis->cMbMemoryBalloon;
1945 }
1946
1947 return VINF_SUCCESS;
1948}
1949
1950
1951/**
1952 * Handles VMMDevReq_ChangeMemBalloon.
1953 *
1954 * @returns VBox status code that the guest should see.
1955 * @param pThis The VMMDev instance data.
1956 * @param pReqHdr The header of the request to handle.
1957 */
1958static int vmmdevReqHandler_ChangeMemBalloon(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1959{
1960 VMMDevChangeMemBalloon *pReq = (VMMDevChangeMemBalloon *)pReqHdr;
1961 AssertMsgReturn(pReq->header.size >= sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1962 AssertMsgReturn(pReq->cPages == VMMDEV_MEMORY_BALLOON_CHUNK_PAGES, ("%u\n", pReq->cPages), VERR_INVALID_PARAMETER);
1963 AssertMsgReturn(pReq->header.size == (uint32_t)RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[pReq->cPages]),
1964 ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1965
1966 Log(("VMMDevReq_ChangeMemBalloon\n"));
1967 int rc = PGMR3PhysChangeMemBalloon(PDMDevHlpGetVM(pThis->pDevIns), !!pReq->fInflate, pReq->cPages, pReq->aPhysPage);
1968 if (pReq->fInflate)
1969 STAM_REL_U32_INC(&pThis->StatMemBalloonChunks);
1970 else
1971 STAM_REL_U32_DEC(&pThis->StatMemBalloonChunks);
1972 return rc;
1973}
1974
1975
1976/**
1977 * Handles VMMDevReq_GetStatisticsChangeRequest.
1978 *
1979 * @returns VBox status code that the guest should see.
1980 * @param pThis The VMMDev instance data.
1981 * @param pReqHdr The header of the request to handle.
1982 */
1983static int vmmdevReqHandler_GetStatisticsChangeRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1984{
1985 VMMDevGetStatisticsChangeRequest *pReq = (VMMDevGetStatisticsChangeRequest *)pReqHdr;
1986 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1987
1988 Log(("VMMDevReq_GetStatisticsChangeRequest\n"));
1989 /* just pass on the information */
1990 Log(("VMMDev: returning statistics interval %d seconds\n", pThis->u32StatIntervalSize));
1991 pReq->u32StatInterval = pThis->u32StatIntervalSize;
1992
1993 if (pReq->eventAck == VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST)
1994 {
1995 /* Remember which mode the client has queried. */
1996 pThis->u32LastStatIntervalSize= pThis->u32StatIntervalSize;
1997 }
1998
1999 return VINF_SUCCESS;
2000}
2001
2002
2003/**
2004 * Handles VMMDevReq_ReportGuestStats.
2005 *
2006 * @returns VBox status code that the guest should see.
2007 * @param pThis The VMMDev instance data.
2008 * @param pReqHdr The header of the request to handle.
2009 */
2010static int vmmdevReqHandler_ReportGuestStats(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2011{
2012 VMMDevReportGuestStats *pReq = (VMMDevReportGuestStats *)pReqHdr;
2013 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2014
2015 Log(("VMMDevReq_ReportGuestStats\n"));
2016#ifdef LOG_ENABLED
2017 VBoxGuestStatistics *pGuestStats = &pReq->guestStats;
2018
2019 Log(("Current statistics:\n"));
2020 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_IDLE)
2021 Log(("CPU%u: CPU Load Idle %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Idle));
2022
2023 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_KERNEL)
2024 Log(("CPU%u: CPU Load Kernel %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Kernel));
2025
2026 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_USER)
2027 Log(("CPU%u: CPU Load User %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_User));
2028
2029 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_THREADS)
2030 Log(("CPU%u: Thread %d\n", pGuestStats->u32CpuId, pGuestStats->u32Threads));
2031
2032 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PROCESSES)
2033 Log(("CPU%u: Processes %d\n", pGuestStats->u32CpuId, pGuestStats->u32Processes));
2034
2035 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_HANDLES)
2036 Log(("CPU%u: Handles %d\n", pGuestStats->u32CpuId, pGuestStats->u32Handles));
2037
2038 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEMORY_LOAD)
2039 Log(("CPU%u: Memory Load %d%%\n", pGuestStats->u32CpuId, pGuestStats->u32MemoryLoad));
2040
2041 /* Note that reported values are in pages; upper layers expect them in megabytes */
2042 Log(("CPU%u: Page size %-4d bytes\n", pGuestStats->u32CpuId, pGuestStats->u32PageSize));
2043 Assert(pGuestStats->u32PageSize == 4096);
2044
2045 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_TOTAL)
2046 Log(("CPU%u: Total physical memory %-4d MB\n", pGuestStats->u32CpuId, (pGuestStats->u32PhysMemTotal + (_1M/_4K)-1) / (_1M/_4K)));
2047
2048 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_AVAIL)
2049 Log(("CPU%u: Free physical memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemAvail / (_1M/_4K)));
2050
2051 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_BALLOON)
2052 Log(("CPU%u: Memory balloon size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemBalloon / (_1M/_4K)));
2053
2054 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_COMMIT_TOTAL)
2055 Log(("CPU%u: Committed memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemCommitTotal / (_1M/_4K)));
2056
2057 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_TOTAL)
2058 Log(("CPU%u: Total kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelTotal / (_1M/_4K)));
2059
2060 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_PAGED)
2061 Log(("CPU%u: Paged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelPaged / (_1M/_4K)));
2062
2063 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_NONPAGED)
2064 Log(("CPU%u: Nonpaged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelNonPaged / (_1M/_4K)));
2065
2066 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_SYSTEM_CACHE)
2067 Log(("CPU%u: System cache size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemSystemCache / (_1M/_4K)));
2068
2069 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PAGE_FILE_SIZE)
2070 Log(("CPU%u: Page file size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PageFileSize / (_1M/_4K)));
2071 Log(("Statistics end *******************\n"));
2072#endif /* LOG_ENABLED */
2073
2074 /* forward the call */
2075 return pThis->pDrv->pfnReportStatistics(pThis->pDrv, &pReq->guestStats);
2076}
2077
2078
2079/**
2080 * Handles VMMDevReq_QueryCredentials.
2081 *
2082 * @returns VBox status code that the guest should see.
2083 * @param pThis The VMMDev instance data.
2084 * @param pReqHdr The header of the request to handle.
2085 */
2086static int vmmdevReqHandler_QueryCredentials(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2087{
2088 VMMDevCredentials *pReq = (VMMDevCredentials *)pReqHdr;
2089 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2090
2091 /* let's start by nulling out the data */
2092 memset(pReq->szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2093 memset(pReq->szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2094 memset(pReq->szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2095
2096 /* should we return whether we got credentials for a logon? */
2097 if (pReq->u32Flags & VMMDEV_CREDENTIALS_QUERYPRESENCE)
2098 {
2099 if ( pThis->pCredentials->Logon.szUserName[0]
2100 || pThis->pCredentials->Logon.szPassword[0]
2101 || pThis->pCredentials->Logon.szDomain[0])
2102 pReq->u32Flags |= VMMDEV_CREDENTIALS_PRESENT;
2103 else
2104 pReq->u32Flags &= ~VMMDEV_CREDENTIALS_PRESENT;
2105 }
2106
2107 /* does the guest want to read logon credentials? */
2108 if (pReq->u32Flags & VMMDEV_CREDENTIALS_READ)
2109 {
2110 if (pThis->pCredentials->Logon.szUserName[0])
2111 strcpy(pReq->szUserName, pThis->pCredentials->Logon.szUserName);
2112 if (pThis->pCredentials->Logon.szPassword[0])
2113 strcpy(pReq->szPassword, pThis->pCredentials->Logon.szPassword);
2114 if (pThis->pCredentials->Logon.szDomain[0])
2115 strcpy(pReq->szDomain, pThis->pCredentials->Logon.szDomain);
2116 if (!pThis->pCredentials->Logon.fAllowInteractiveLogon)
2117 pReq->u32Flags |= VMMDEV_CREDENTIALS_NOLOCALLOGON;
2118 else
2119 pReq->u32Flags &= ~VMMDEV_CREDENTIALS_NOLOCALLOGON;
2120 }
2121
2122 if (!pThis->fKeepCredentials)
2123 {
2124 /* does the caller want us to destroy the logon credentials? */
2125 if (pReq->u32Flags & VMMDEV_CREDENTIALS_CLEAR)
2126 {
2127 memset(pThis->pCredentials->Logon.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2128 memset(pThis->pCredentials->Logon.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2129 memset(pThis->pCredentials->Logon.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2130 }
2131 }
2132
2133 /* does the guest want to read credentials for verification? */
2134 if (pReq->u32Flags & VMMDEV_CREDENTIALS_READJUDGE)
2135 {
2136 if (pThis->pCredentials->Judge.szUserName[0])
2137 strcpy(pReq->szUserName, pThis->pCredentials->Judge.szUserName);
2138 if (pThis->pCredentials->Judge.szPassword[0])
2139 strcpy(pReq->szPassword, pThis->pCredentials->Judge.szPassword);
2140 if (pThis->pCredentials->Judge.szDomain[0])
2141 strcpy(pReq->szDomain, pThis->pCredentials->Judge.szDomain);
2142 }
2143
2144 /* does the caller want us to destroy the judgement credentials? */
2145 if (pReq->u32Flags & VMMDEV_CREDENTIALS_CLEARJUDGE)
2146 {
2147 memset(pThis->pCredentials->Judge.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2148 memset(pThis->pCredentials->Judge.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2149 memset(pThis->pCredentials->Judge.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2150 }
2151
2152 return VINF_SUCCESS;
2153}
2154
2155
2156/**
2157 * Handles VMMDevReq_ReportCredentialsJudgement.
2158 *
2159 * @returns VBox status code that the guest should see.
2160 * @param pThis The VMMDev instance data.
2161 * @param pReqHdr The header of the request to handle.
2162 */
2163static int vmmdevReqHandler_ReportCredentialsJudgement(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2164{
2165 VMMDevCredentials *pReq = (VMMDevCredentials *)pReqHdr;
2166 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2167
2168 /* what does the guest think about the credentials? (note: the order is important here!) */
2169 if (pReq->u32Flags & VMMDEV_CREDENTIALS_JUDGE_DENY)
2170 pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_DENY);
2171 else if (pReq->u32Flags & VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT)
2172 pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT);
2173 else if (pReq->u32Flags & VMMDEV_CREDENTIALS_JUDGE_OK)
2174 pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_OK);
2175 else
2176 {
2177 Log(("VMMDevReq_ReportCredentialsJudgement: invalid flags: %d!!!\n", pReq->u32Flags));
2178 /** @todo why don't we return VERR_INVALID_PARAMETER to the guest? */
2179 }
2180
2181 return VINF_SUCCESS;
2182}
2183
2184
2185/**
2186 * Handles VMMDevReq_GetHostVersion.
2187 *
2188 * @returns VBox status code that the guest should see.
2189 * @param pReqHdr The header of the request to handle.
2190 * @since 3.1.0
2191 * @note The ring-0 VBoxGuestLib uses this to check whether
2192 * VMMDevHGCMParmType_PageList is supported.
2193 */
2194static int vmmdevReqHandler_GetHostVersion(VMMDevRequestHeader *pReqHdr)
2195{
2196 VMMDevReqHostVersion *pReq = (VMMDevReqHostVersion *)pReqHdr;
2197 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2198
2199 pReq->major = RTBldCfgVersionMajor();
2200 pReq->minor = RTBldCfgVersionMinor();
2201 pReq->build = RTBldCfgVersionBuild();
2202 pReq->revision = RTBldCfgRevision();
2203 pReq->features = VMMDEV_HVF_HGCM_PHYS_PAGE_LIST;
2204 return VINF_SUCCESS;
2205}
2206
2207
2208/**
2209 * Handles VMMDevReq_GetCpuHotPlugRequest.
2210 *
2211 * @returns VBox status code that the guest should see.
2212 * @param pThis The VMMDev instance data.
2213 * @param pReqHdr The header of the request to handle.
2214 */
2215static int vmmdevReqHandler_GetCpuHotPlugRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2216{
2217 VMMDevGetCpuHotPlugRequest *pReq = (VMMDevGetCpuHotPlugRequest *)pReqHdr;
2218 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2219
2220 pReq->enmEventType = pThis->enmCpuHotPlugEvent;
2221 pReq->idCpuCore = pThis->idCpuCore;
2222 pReq->idCpuPackage = pThis->idCpuPackage;
2223
2224 /* Clear the event */
2225 pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_None;
2226 pThis->idCpuCore = UINT32_MAX;
2227 pThis->idCpuPackage = UINT32_MAX;
2228
2229 return VINF_SUCCESS;
2230}
2231
2232
2233/**
2234 * Handles VMMDevReq_SetCpuHotPlugStatus.
2235 *
2236 * @returns VBox status code that the guest should see.
2237 * @param pThis The VMMDev instance data.
2238 * @param pReqHdr The header of the request to handle.
2239 */
2240static int vmmdevReqHandler_SetCpuHotPlugStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2241{
2242 VMMDevCpuHotPlugStatusRequest *pReq = (VMMDevCpuHotPlugStatusRequest *)pReqHdr;
2243 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2244
2245 if (pReq->enmStatusType == VMMDevCpuStatusType_Disable)
2246 pThis->fCpuHotPlugEventsEnabled = false;
2247 else if (pReq->enmStatusType == VMMDevCpuStatusType_Enable)
2248 pThis->fCpuHotPlugEventsEnabled = true;
2249 else
2250 return VERR_INVALID_PARAMETER;
2251 return VINF_SUCCESS;
2252}
2253
2254
2255#ifdef DEBUG
2256/**
2257 * Handles VMMDevReq_LogString.
2258 *
2259 * @returns VBox status code that the guest should see.
2260 * @param pReqHdr The header of the request to handle.
2261 */
2262static int vmmdevReqHandler_LogString(VMMDevRequestHeader *pReqHdr)
2263{
2264 VMMDevReqLogString *pReq = (VMMDevReqLogString *)pReqHdr;
2265 AssertMsgReturn(pReq->header.size >= sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2266 AssertMsgReturn(pReq->szString[pReq->header.size - RT_OFFSETOF(VMMDevReqLogString, szString) - 1] == '\0',
2267 ("not null terminated\n"), VERR_INVALID_PARAMETER);
2268
2269 LogIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("DEBUG LOG: %s", pReq->szString));
2270 return VINF_SUCCESS;
2271}
2272#endif /* DEBUG */
2273
2274/**
2275 * Handles VMMDevReq_GetSessionId.
2276 *
2277 * Get a unique "session" ID for this VM, where the ID will be different after each
2278 * start, reset or restore of the VM. This can be used for restore detection
2279 * inside the guest.
2280 *
2281 * @returns VBox status code that the guest should see.
2282 * @param pThis The VMMDev instance data.
2283 * @param pReqHdr The header of the request to handle.
2284 */
2285static int vmmdevReqHandler_GetSessionId(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2286{
2287 VMMDevReqSessionId *pReq = (VMMDevReqSessionId *)pReqHdr;
2288 AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2289
2290 pReq->idSession = pThis->idSession;
2291 return VINF_SUCCESS;
2292}
2293
2294
2295#ifdef VBOX_WITH_PAGE_SHARING
2296
2297/**
2298 * Handles VMMDevReq_RegisterSharedModule.
2299 *
2300 * @returns VBox status code that the guest should see.
2301 * @param pThis The VMMDev instance data.
2302 * @param pReqHdr The header of the request to handle.
2303 */
2304static int vmmdevReqHandler_RegisterSharedModule(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2305{
2306 /*
2307 * Basic input validation (more done by GMM).
2308 */
2309 VMMDevSharedModuleRegistrationRequest *pReq = (VMMDevSharedModuleRegistrationRequest *)pReqHdr;
2310 AssertMsgReturn(pReq->header.size >= sizeof(VMMDevSharedModuleRegistrationRequest),
2311 ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2312 AssertMsgReturn(pReq->header.size == RT_UOFFSETOF(VMMDevSharedModuleRegistrationRequest, aRegions[pReq->cRegions]),
2313 ("%u cRegions=%u\n", pReq->header.size, pReq->cRegions), VERR_INVALID_PARAMETER);
2314
2315 AssertReturn(RTStrEnd(pReq->szName, sizeof(pReq->szName)), VERR_INVALID_PARAMETER);
2316 AssertReturn(RTStrEnd(pReq->szVersion, sizeof(pReq->szVersion)), VERR_INVALID_PARAMETER);
2317 int rc = RTStrValidateEncoding(pReq->szName);
2318 AssertRCReturn(rc, rc);
2319 rc = RTStrValidateEncoding(pReq->szVersion);
2320 AssertRCReturn(rc, rc);
2321
2322 /*
2323 * Forward the request to the VMM.
2324 */
2325 return PGMR3SharedModuleRegister(PDMDevHlpGetVM(pThis->pDevIns), pReq->enmGuestOS, pReq->szName, pReq->szVersion,
2326 pReq->GCBaseAddr, pReq->cbModule, pReq->cRegions, pReq->aRegions);
2327}
2328
2329/**
2330 * Handles VMMDevReq_UnregisterSharedModule.
2331 *
2332 * @returns VBox status code that the guest should see.
2333 * @param pThis The VMMDev instance data.
2334 * @param pReqHdr The header of the request to handle.
2335 */
2336static int vmmdevReqHandler_UnregisterSharedModule(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2337{
2338 /*
2339 * Basic input validation.
2340 */
2341 VMMDevSharedModuleUnregistrationRequest *pReq = (VMMDevSharedModuleUnregistrationRequest *)pReqHdr;
2342 AssertMsgReturn(pReq->header.size == sizeof(VMMDevSharedModuleUnregistrationRequest),
2343 ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2344
2345 AssertReturn(RTStrEnd(pReq->szName, sizeof(pReq->szName)), VERR_INVALID_PARAMETER);
2346 AssertReturn(RTStrEnd(pReq->szVersion, sizeof(pReq->szVersion)), VERR_INVALID_PARAMETER);
2347 int rc = RTStrValidateEncoding(pReq->szName);
2348 AssertRCReturn(rc, rc);
2349 rc = RTStrValidateEncoding(pReq->szVersion);
2350 AssertRCReturn(rc, rc);
2351
2352 /*
2353 * Forward the request to the VMM.
2354 */
2355 return PGMR3SharedModuleUnregister(PDMDevHlpGetVM(pThis->pDevIns), pReq->szName, pReq->szVersion,
2356 pReq->GCBaseAddr, pReq->cbModule);
2357}
2358
2359/**
2360 * Handles VMMDevReq_CheckSharedModules.
2361 *
2362 * @returns VBox status code that the guest should see.
2363 * @param pThis The VMMDev instance data.
2364 * @param pReqHdr The header of the request to handle.
2365 */
2366static int vmmdevReqHandler_CheckSharedModules(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2367{
2368 VMMDevSharedModuleCheckRequest *pReq = (VMMDevSharedModuleCheckRequest *)pReqHdr;
2369 AssertMsgReturn(pReq->header.size == sizeof(VMMDevSharedModuleCheckRequest),
2370 ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2371 return PGMR3SharedModuleCheckAll(PDMDevHlpGetVM(pThis->pDevIns));
2372}
2373
2374/**
2375 * Handles VMMDevReq_GetPageSharingStatus.
2376 *
2377 * @returns VBox status code that the guest should see.
2378 * @param pThis The VMMDev instance data.
2379 * @param pReqHdr The header of the request to handle.
2380 */
2381static int vmmdevReqHandler_GetPageSharingStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2382{
2383 VMMDevPageSharingStatusRequest *pReq = (VMMDevPageSharingStatusRequest *)pReqHdr;
2384 AssertMsgReturn(pReq->header.size == sizeof(VMMDevPageSharingStatusRequest),
2385 ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2386
2387 pReq->fEnabled = false;
2388 int rc = pThis->pDrv->pfnIsPageFusionEnabled(pThis->pDrv, &pReq->fEnabled);
2389 if (RT_FAILURE(rc))
2390 pReq->fEnabled = false;
2391 return VINF_SUCCESS;
2392}
2393
2394
2395/**
2396 * Handles VMMDevReq_DebugIsPageShared.
2397 *
2398 * @returns VBox status code that the guest should see.
2399 * @param pThis The VMMDev instance data.
2400 * @param pReqHdr The header of the request to handle.
2401 */
2402static int vmmdevReqHandler_DebugIsPageShared(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2403{
2404 VMMDevPageIsSharedRequest *pReq = (VMMDevPageIsSharedRequest *)pReqHdr;
2405 AssertMsgReturn(pReq->header.size == sizeof(VMMDevPageIsSharedRequest),
2406 ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2407
2408# ifdef DEBUG
2409 return PGMR3SharedModuleGetPageState(PDMDevHlpGetVM(pThis->pDevIns), pReq->GCPtrPage, &pReq->fShared, &pReq->uPageFlags);
2410# else
2411 RT_NOREF1(pThis);
2412 return VERR_NOT_IMPLEMENTED;
2413# endif
2414}
2415
2416#endif /* VBOX_WITH_PAGE_SHARING */
2417
2418
2419/**
2420 * Handles VMMDevReq_WriteCoreDumpe
2421 *
2422 * @returns VBox status code that the guest should see.
2423 * @param pThis The VMMDev instance data.
2424 * @param pReqHdr Pointer to the request header.
2425 */
2426static int vmmdevReqHandler_WriteCoreDump(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2427{
2428 VMMDevReqWriteCoreDump *pReq = (VMMDevReqWriteCoreDump *)pReqHdr;
2429 AssertMsgReturn(pReq->header.size == sizeof(VMMDevReqWriteCoreDump), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2430
2431 /*
2432 * Only available if explicitly enabled by the user.
2433 */
2434 if (!pThis->fGuestCoreDumpEnabled)
2435 return VERR_ACCESS_DENIED;
2436
2437 /*
2438 * User makes sure the directory exists before composing the path.
2439 */
2440 if (!RTDirExists(pThis->szGuestCoreDumpDir))
2441 return VERR_PATH_NOT_FOUND;
2442
2443 char szCorePath[RTPATH_MAX];
2444 RTStrCopy(szCorePath, sizeof(szCorePath), pThis->szGuestCoreDumpDir);
2445 RTPathAppend(szCorePath, sizeof(szCorePath), "VBox.core");
2446
2447 /*
2448 * Rotate existing cores based on number of additional cores to keep around.
2449 */
2450 if (pThis->cGuestCoreDumps > 0)
2451 for (int64_t i = pThis->cGuestCoreDumps - 1; i >= 0; i--)
2452 {
2453 char szFilePathOld[RTPATH_MAX];
2454 if (i == 0)
2455 RTStrCopy(szFilePathOld, sizeof(szFilePathOld), szCorePath);
2456 else
2457 RTStrPrintf(szFilePathOld, sizeof(szFilePathOld), "%s.%lld", szCorePath, i);
2458
2459 char szFilePathNew[RTPATH_MAX];
2460 RTStrPrintf(szFilePathNew, sizeof(szFilePathNew), "%s.%lld", szCorePath, i + 1);
2461 int vrc = RTFileMove(szFilePathOld, szFilePathNew, RTFILEMOVE_FLAGS_REPLACE);
2462 if (vrc == VERR_FILE_NOT_FOUND)
2463 RTFileDelete(szFilePathNew);
2464 }
2465
2466 /*
2467 * Write the core file.
2468 */
2469 PUVM pUVM = PDMDevHlpGetUVM(pThis->pDevIns);
2470 return DBGFR3CoreWrite(pUVM, szCorePath, true /*fReplaceFile*/);
2471}
2472
2473
2474/**
2475 * Dispatch the request to the appropriate handler function.
2476 *
2477 * @returns Port I/O handler exit code.
2478 * @param pThis The VMM device instance data.
2479 * @param pReqHdr The request header (cached in host memory).
2480 * @param GCPhysReqHdr The guest physical address of the request (for
2481 * HGCM).
2482 * @param pfDelayedUnlock Where to indicate whether the critical section exit
2483 * needs to be delayed till after the request has been
2484 * written back. This is a HGCM kludge, see critsect
2485 * work in hgcmCompletedWorker for more details.
2486 */
2487static int vmmdevReqDispatcher(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr, RTGCPHYS GCPhysReqHdr, bool *pfDelayedUnlock)
2488{
2489 int rcRet = VINF_SUCCESS;
2490 *pfDelayedUnlock = false;
2491
2492 switch (pReqHdr->requestType)
2493 {
2494 case VMMDevReq_ReportGuestInfo:
2495 pReqHdr->rc = vmmdevReqHandler_ReportGuestInfo(pThis, pReqHdr);
2496 break;
2497
2498 case VMMDevReq_ReportGuestInfo2:
2499 pReqHdr->rc = vmmdevReqHandler_ReportGuestInfo2(pThis, pReqHdr);
2500 break;
2501
2502 case VMMDevReq_ReportGuestStatus:
2503 pReqHdr->rc = vmmdevReqHandler_ReportGuestStatus(pThis, pReqHdr);
2504 break;
2505
2506 case VMMDevReq_ReportGuestUserState:
2507 pReqHdr->rc = vmmdevReqHandler_ReportGuestUserState(pThis, pReqHdr);
2508 break;
2509
2510 case VMMDevReq_ReportGuestCapabilities:
2511 pReqHdr->rc = vmmdevReqHandler_ReportGuestCapabilities(pThis, pReqHdr);
2512 break;
2513
2514 case VMMDevReq_SetGuestCapabilities:
2515 pReqHdr->rc = vmmdevReqHandler_SetGuestCapabilities(pThis, pReqHdr);
2516 break;
2517
2518 case VMMDevReq_WriteCoreDump:
2519 pReqHdr->rc = vmmdevReqHandler_WriteCoreDump(pThis, pReqHdr);
2520 break;
2521
2522 case VMMDevReq_GetMouseStatus:
2523 pReqHdr->rc = vmmdevReqHandler_GetMouseStatus(pThis, pReqHdr);
2524 break;
2525
2526 case VMMDevReq_SetMouseStatus:
2527 pReqHdr->rc = vmmdevReqHandler_SetMouseStatus(pThis, pReqHdr);
2528 break;
2529
2530 case VMMDevReq_SetPointerShape:
2531 pReqHdr->rc = vmmdevReqHandler_SetPointerShape(pThis, pReqHdr);
2532 break;
2533
2534 case VMMDevReq_GetHostTime:
2535 pReqHdr->rc = vmmdevReqHandler_GetHostTime(pThis, pReqHdr);
2536 break;
2537
2538 case VMMDevReq_GetHypervisorInfo:
2539 pReqHdr->rc = vmmdevReqHandler_GetHypervisorInfo(pThis, pReqHdr);
2540 break;
2541
2542 case VMMDevReq_SetHypervisorInfo:
2543 pReqHdr->rc = vmmdevReqHandler_SetHypervisorInfo(pThis, pReqHdr);
2544 break;
2545
2546 case VMMDevReq_RegisterPatchMemory:
2547 pReqHdr->rc = vmmdevReqHandler_RegisterPatchMemory(pThis, pReqHdr);
2548 break;
2549
2550 case VMMDevReq_DeregisterPatchMemory:
2551 pReqHdr->rc = vmmdevReqHandler_DeregisterPatchMemory(pThis, pReqHdr);
2552 break;
2553
2554 case VMMDevReq_SetPowerStatus:
2555 {
2556 int rc = pReqHdr->rc = vmmdevReqHandler_SetPowerStatus(pThis, pReqHdr);
2557 if (rc != VINF_SUCCESS && RT_SUCCESS(rc))
2558 rcRet = rc;
2559 break;
2560 }
2561
2562 case VMMDevReq_GetDisplayChangeRequest:
2563 pReqHdr->rc = vmmdevReqHandler_GetDisplayChangeRequest(pThis, pReqHdr);
2564 break;
2565
2566 case VMMDevReq_GetDisplayChangeRequest2:
2567 pReqHdr->rc = vmmdevReqHandler_GetDisplayChangeRequest2(pThis, pReqHdr);
2568 break;
2569
2570 case VMMDevReq_GetDisplayChangeRequestEx:
2571 pReqHdr->rc = vmmdevReqHandler_GetDisplayChangeRequestEx(pThis, pReqHdr);
2572 break;
2573
2574 case VMMDevReq_VideoModeSupported:
2575 pReqHdr->rc = vmmdevReqHandler_VideoModeSupported(pThis, pReqHdr);
2576 break;
2577
2578 case VMMDevReq_VideoModeSupported2:
2579 pReqHdr->rc = vmmdevReqHandler_VideoModeSupported2(pThis, pReqHdr);
2580 break;
2581
2582 case VMMDevReq_GetHeightReduction:
2583 pReqHdr->rc = vmmdevReqHandler_GetHeightReduction(pThis, pReqHdr);
2584 break;
2585
2586 case VMMDevReq_AcknowledgeEvents:
2587 pReqHdr->rc = vmmdevReqHandler_AcknowledgeEvents(pThis, pReqHdr);
2588 break;
2589
2590 case VMMDevReq_CtlGuestFilterMask:
2591 pReqHdr->rc = vmmdevReqHandler_CtlGuestFilterMask(pThis, pReqHdr);
2592 break;
2593
2594#ifdef VBOX_WITH_HGCM
2595 case VMMDevReq_HGCMConnect:
2596 pReqHdr->rc = vmmdevReqHandler_HGCMConnect(pThis, pReqHdr, GCPhysReqHdr);
2597 *pfDelayedUnlock = true;
2598 break;
2599
2600 case VMMDevReq_HGCMDisconnect:
2601 pReqHdr->rc = vmmdevReqHandler_HGCMDisconnect(pThis, pReqHdr, GCPhysReqHdr);
2602 *pfDelayedUnlock = true;
2603 break;
2604
2605# ifdef VBOX_WITH_64_BITS_GUESTS
2606 case VMMDevReq_HGCMCall32:
2607 case VMMDevReq_HGCMCall64:
2608# else
2609 case VMMDevReq_HGCMCall:
2610# endif /* VBOX_WITH_64_BITS_GUESTS */
2611 pReqHdr->rc = vmmdevReqHandler_HGCMCall(pThis, pReqHdr, GCPhysReqHdr);
2612 *pfDelayedUnlock = true;
2613 break;
2614
2615 case VMMDevReq_HGCMCancel:
2616 pReqHdr->rc = vmmdevReqHandler_HGCMCancel(pThis, pReqHdr, GCPhysReqHdr);
2617 *pfDelayedUnlock = true;
2618 break;
2619
2620 case VMMDevReq_HGCMCancel2:
2621 pReqHdr->rc = vmmdevReqHandler_HGCMCancel2(pThis, pReqHdr);
2622 break;
2623#endif /* VBOX_WITH_HGCM */
2624
2625 case VMMDevReq_VideoAccelEnable:
2626 pReqHdr->rc = vmmdevReqHandler_VideoAccelEnable(pThis, pReqHdr);
2627 break;
2628
2629 case VMMDevReq_VideoAccelFlush:
2630 pReqHdr->rc = vmmdevReqHandler_VideoAccelFlush(pThis, pReqHdr);
2631 break;
2632
2633 case VMMDevReq_VideoSetVisibleRegion:
2634 pReqHdr->rc = vmmdevReqHandler_VideoSetVisibleRegion(pThis, pReqHdr);
2635 break;
2636
2637 case VMMDevReq_GetSeamlessChangeRequest:
2638 pReqHdr->rc = vmmdevReqHandler_GetSeamlessChangeRequest(pThis, pReqHdr);
2639 break;
2640
2641 case VMMDevReq_GetVRDPChangeRequest:
2642 pReqHdr->rc = vmmdevReqHandler_GetVRDPChangeRequest(pThis, pReqHdr);
2643 break;
2644
2645 case VMMDevReq_GetMemBalloonChangeRequest:
2646 pReqHdr->rc = vmmdevReqHandler_GetMemBalloonChangeRequest(pThis, pReqHdr);
2647 break;
2648
2649 case VMMDevReq_ChangeMemBalloon:
2650 pReqHdr->rc = vmmdevReqHandler_ChangeMemBalloon(pThis, pReqHdr);
2651 break;
2652
2653 case VMMDevReq_GetStatisticsChangeRequest:
2654 pReqHdr->rc = vmmdevReqHandler_GetStatisticsChangeRequest(pThis, pReqHdr);
2655 break;
2656
2657 case VMMDevReq_ReportGuestStats:
2658 pReqHdr->rc = vmmdevReqHandler_ReportGuestStats(pThis, pReqHdr);
2659 break;
2660
2661 case VMMDevReq_QueryCredentials:
2662 pReqHdr->rc = vmmdevReqHandler_QueryCredentials(pThis, pReqHdr);
2663 break;
2664
2665 case VMMDevReq_ReportCredentialsJudgement:
2666 pReqHdr->rc = vmmdevReqHandler_ReportCredentialsJudgement(pThis, pReqHdr);
2667 break;
2668
2669 case VMMDevReq_GetHostVersion:
2670 pReqHdr->rc = vmmdevReqHandler_GetHostVersion(pReqHdr);
2671 break;
2672
2673 case VMMDevReq_GetCpuHotPlugRequest:
2674 pReqHdr->rc = vmmdevReqHandler_GetCpuHotPlugRequest(pThis, pReqHdr);
2675 break;
2676
2677 case VMMDevReq_SetCpuHotPlugStatus:
2678 pReqHdr->rc = vmmdevReqHandler_SetCpuHotPlugStatus(pThis, pReqHdr);
2679 break;
2680
2681#ifdef VBOX_WITH_PAGE_SHARING
2682 case VMMDevReq_RegisterSharedModule:
2683 pReqHdr->rc = vmmdevReqHandler_RegisterSharedModule(pThis, pReqHdr);
2684 break;
2685
2686 case VMMDevReq_UnregisterSharedModule:
2687 pReqHdr->rc = vmmdevReqHandler_UnregisterSharedModule(pThis, pReqHdr);
2688 break;
2689
2690 case VMMDevReq_CheckSharedModules:
2691 pReqHdr->rc = vmmdevReqHandler_CheckSharedModules(pThis, pReqHdr);
2692 break;
2693
2694 case VMMDevReq_GetPageSharingStatus:
2695 pReqHdr->rc = vmmdevReqHandler_GetPageSharingStatus(pThis, pReqHdr);
2696 break;
2697
2698 case VMMDevReq_DebugIsPageShared:
2699 pReqHdr->rc = vmmdevReqHandler_DebugIsPageShared(pThis, pReqHdr);
2700 break;
2701
2702#endif /* VBOX_WITH_PAGE_SHARING */
2703
2704#ifdef DEBUG
2705 case VMMDevReq_LogString:
2706 pReqHdr->rc = vmmdevReqHandler_LogString(pReqHdr);
2707 break;
2708#endif
2709
2710 case VMMDevReq_GetSessionId:
2711 pReqHdr->rc = vmmdevReqHandler_GetSessionId(pThis, pReqHdr);
2712 break;
2713
2714 /*
2715 * Guest wants to give up a timeslice.
2716 * Note! This was only ever used by experimental GAs!
2717 */
2718 /** @todo maybe we could just remove this? */
2719 case VMMDevReq_Idle:
2720 {
2721 /* just return to EMT telling it that we want to halt */
2722 rcRet = VINF_EM_HALT;
2723 break;
2724 }
2725
2726 case VMMDevReq_GuestHeartbeat:
2727 pReqHdr->rc = vmmDevReqHandler_GuestHeartbeat(pThis);
2728 break;
2729
2730 case VMMDevReq_HeartbeatConfigure:
2731 pReqHdr->rc = vmmDevReqHandler_HeartbeatConfigure(pThis, pReqHdr);
2732 break;
2733
2734 default:
2735 {
2736 pReqHdr->rc = VERR_NOT_IMPLEMENTED;
2737 Log(("VMMDev unknown request type %d\n", pReqHdr->requestType));
2738 break;
2739 }
2740 }
2741 return rcRet;
2742}
2743
2744
2745/**
2746 * @callback_method_impl{FNIOMIOPORTOUT, Port I/O Handler for the generic
2747 * request interface.}
2748 */
2749static DECLCALLBACK(int) vmmdevRequestHandler(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
2750{
2751 RT_NOREF2(Port, cb);
2752 PVMMDEV pThis = (VMMDevState*)pvUser;
2753
2754 /*
2755 * The caller has passed the guest context physical address of the request
2756 * structure. We'll copy all of it into a heap buffer eventually, but we
2757 * will have to start off with the header.
2758 */
2759 VMMDevRequestHeader requestHeader;
2760 RT_ZERO(requestHeader);
2761 PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
2762
2763 /* The structure size must be greater or equal to the header size. */
2764 if (requestHeader.size < sizeof(VMMDevRequestHeader))
2765 {
2766 Log(("VMMDev request header size too small! size = %d\n", requestHeader.size));
2767 return VINF_SUCCESS;
2768 }
2769
2770 /* Check the version of the header structure. */
2771 if (requestHeader.version != VMMDEV_REQUEST_HEADER_VERSION)
2772 {
2773 Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader.version, VMMDEV_REQUEST_HEADER_VERSION));
2774 return VINF_SUCCESS;
2775 }
2776
2777 Log2(("VMMDev request issued: %d\n", requestHeader.requestType));
2778
2779 int rcRet = VINF_SUCCESS;
2780 bool fDelayedUnlock = false;
2781 VMMDevRequestHeader *pRequestHeader = NULL;
2782
2783 /* Check that is doesn't exceed the max packet size. */
2784 if (requestHeader.size <= VMMDEV_MAX_VMMDEVREQ_SIZE)
2785 {
2786 /*
2787 * We require the GAs to report it's information before we let it have
2788 * access to all the functions. The VMMDevReq_ReportGuestInfo request
2789 * is the one which unlocks the access. Newer additions will first
2790 * issue VMMDevReq_ReportGuestInfo2, older ones doesn't know this one.
2791 * Two exceptions: VMMDevReq_GetHostVersion and VMMDevReq_WriteCoreDump.
2792 */
2793 if ( pThis->fu32AdditionsOk
2794 || requestHeader.requestType == VMMDevReq_ReportGuestInfo2
2795 || requestHeader.requestType == VMMDevReq_ReportGuestInfo
2796 || requestHeader.requestType == VMMDevReq_WriteCoreDump
2797 || requestHeader.requestType == VMMDevReq_GetHostVersion
2798 )
2799 {
2800 /*
2801 * The request looks fine. Allocate a heap block for it, read the
2802 * entire package from guest memory and feed it to the dispatcher.
2803 */
2804 pRequestHeader = (VMMDevRequestHeader *)RTMemAlloc(requestHeader.size);
2805 if (pRequestHeader)
2806 {
2807 memcpy(pRequestHeader, &requestHeader, sizeof(VMMDevRequestHeader));
2808 size_t cbLeft = requestHeader.size - sizeof(VMMDevRequestHeader);
2809 if (cbLeft)
2810 PDMDevHlpPhysRead(pDevIns,
2811 (RTGCPHYS)u32 + sizeof(VMMDevRequestHeader),
2812 (uint8_t *)pRequestHeader + sizeof(VMMDevRequestHeader),
2813 cbLeft);
2814
2815 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
2816 rcRet = vmmdevReqDispatcher(pThis, pRequestHeader, u32, &fDelayedUnlock);
2817 if (!fDelayedUnlock)
2818 PDMCritSectLeave(&pThis->CritSect);
2819 }
2820 else
2821 {
2822 Log(("VMMDev: RTMemAlloc failed!\n"));
2823 requestHeader.rc = VERR_NO_MEMORY;
2824 }
2825 }
2826 else
2827 {
2828 LogRelMax(10, ("VMMDev: Guest has not yet reported to us -- refusing operation of request #%d\n",
2829 requestHeader.requestType));
2830 requestHeader.rc = VERR_NOT_SUPPORTED;
2831 }
2832 }
2833 else
2834 {
2835 LogRelMax(50, ("VMMDev: Request packet too big (%x), refusing operation\n", requestHeader.size));
2836 requestHeader.rc = VERR_NOT_SUPPORTED;
2837 }
2838
2839 /*
2840 * Write the result back to guest memory
2841 */
2842 if (pRequestHeader)
2843 {
2844 PDMDevHlpPhysWrite(pDevIns, u32, pRequestHeader, pRequestHeader->size);
2845 if (fDelayedUnlock)
2846 PDMCritSectLeave(&pThis->CritSect);
2847 RTMemFree(pRequestHeader);
2848 }
2849 else
2850 {
2851 /* early error case; write back header only */
2852 PDMDevHlpPhysWrite(pDevIns, u32, &requestHeader, sizeof(requestHeader));
2853 Assert(!fDelayedUnlock);
2854 }
2855
2856 return rcRet;
2857}
2858
2859
2860/* -=-=-=-=-=- PCI Device -=-=-=-=-=- */
2861
2862
2863/**
2864 * @callback_method_impl{FNPCIIOREGIONMAP,MMIO/MMIO2 regions}
2865 */
2866static DECLCALLBACK(int) vmmdevIORAMRegionMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
2867 RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
2868{
2869 RT_NOREF1(cb);
2870 LogFlow(("vmmdevR3IORAMRegionMap: iRegion=%d GCPhysAddress=%RGp cb=%RGp enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
2871 PVMMDEV pThis = RT_FROM_MEMBER(pPciDev, VMMDEV, PciDev);
2872 int rc;
2873
2874 if (iRegion == 1)
2875 {
2876 AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM, VERR_INTERNAL_ERROR);
2877 Assert(pThis->pVMMDevRAMR3 != NULL);
2878 if (GCPhysAddress != NIL_RTGCPHYS)
2879 {
2880 /*
2881 * Map the MMIO2 memory.
2882 */
2883 pThis->GCPhysVMMDevRAM = GCPhysAddress;
2884 Assert(pThis->GCPhysVMMDevRAM == GCPhysAddress);
2885 rc = PDMDevHlpMMIOExMap(pDevIns, pPciDev, iRegion, GCPhysAddress);
2886 }
2887 else
2888 {
2889 /*
2890 * It is about to be unmapped, just clean up.
2891 */
2892 pThis->GCPhysVMMDevRAM = NIL_RTGCPHYS32;
2893 rc = VINF_SUCCESS;
2894 }
2895 }
2896 else if (iRegion == 2)
2897 {
2898 AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM_PREFETCH, VERR_INTERNAL_ERROR);
2899 Assert(pThis->pVMMDevHeapR3 != NULL);
2900 if (GCPhysAddress != NIL_RTGCPHYS)
2901 {
2902 /*
2903 * Map the MMIO2 memory.
2904 */
2905 pThis->GCPhysVMMDevHeap = GCPhysAddress;
2906 Assert(pThis->GCPhysVMMDevHeap == GCPhysAddress);
2907 rc = PDMDevHlpMMIOExMap(pDevIns, pPciDev, iRegion, GCPhysAddress);
2908 if (RT_SUCCESS(rc))
2909 rc = PDMDevHlpRegisterVMMDevHeap(pDevIns, GCPhysAddress, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
2910 }
2911 else
2912 {
2913 /*
2914 * It is about to be unmapped, just clean up.
2915 */
2916 PDMDevHlpRegisterVMMDevHeap(pDevIns, NIL_RTGCPHYS, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
2917 pThis->GCPhysVMMDevHeap = NIL_RTGCPHYS32;
2918 rc = VINF_SUCCESS;
2919 }
2920 }
2921 else
2922 {
2923 AssertMsgFailed(("%d\n", iRegion));
2924 rc = VERR_INVALID_PARAMETER;
2925 }
2926
2927 return rc;
2928}
2929
2930
2931/**
2932 * @callback_method_impl{FNPCIIOREGIONMAP,I/O Port Region}
2933 */
2934static DECLCALLBACK(int) vmmdevIOPortRegionMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
2935 RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
2936{
2937 LogFlow(("vmmdevIOPortRegionMap: iRegion=%d GCPhysAddress=%RGp cb=%RGp enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
2938 RT_NOREF3(iRegion, cb, enmType);
2939 PVMMDEV pThis = RT_FROM_MEMBER(pPciDev, VMMDEV, PciDev);
2940
2941 Assert(enmType == PCI_ADDRESS_SPACE_IO);
2942 Assert(iRegion == 0);
2943 AssertMsg(RT_ALIGN(GCPhysAddress, 8) == GCPhysAddress, ("Expected 8 byte alignment. GCPhysAddress=%#x\n", GCPhysAddress));
2944
2945 /*
2946 * Register our port IO handlers.
2947 */
2948 int rc = PDMDevHlpIOPortRegister(pDevIns, (RTIOPORT)GCPhysAddress + VMMDEV_PORT_OFF_REQUEST, 1,
2949 pThis, vmmdevRequestHandler, NULL, NULL, NULL, "VMMDev Request Handler");
2950 AssertRC(rc);
2951 return rc;
2952}
2953
2954
2955
2956/* -=-=-=-=-=- Backdoor Logging and Time Sync. -=-=-=-=-=- */
2957
2958/**
2959 * @callback_method_impl{FNIOMIOPORTOUT, Backdoor Logging.}
2960 */
2961static DECLCALLBACK(int) vmmdevBackdoorLog(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
2962{
2963 RT_NOREF1(pvUser);
2964 PVMMDEV pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
2965
2966 if (!pThis->fBackdoorLogDisabled && cb == 1 && Port == RTLOG_DEBUG_PORT)
2967 {
2968
2969 /* The raw version. */
2970 switch (u32)
2971 {
2972 case '\r': LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <return>\n")); break;
2973 case '\n': LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <newline>\n")); break;
2974 case '\t': LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <tab>\n")); break;
2975 default: LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: %c (%02x)\n", u32, u32)); break;
2976 }
2977
2978 /* The readable, buffered version. */
2979 if (u32 == '\n' || u32 == '\r')
2980 {
2981 pThis->szMsg[pThis->iMsg] = '\0';
2982 if (pThis->iMsg)
2983 LogRelIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("VMMDev: Guest Log: %s\n", pThis->szMsg));
2984 pThis->iMsg = 0;
2985 }
2986 else
2987 {
2988 if (pThis->iMsg >= sizeof(pThis->szMsg)-1)
2989 {
2990 pThis->szMsg[pThis->iMsg] = '\0';
2991 LogRelIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("VMMDev: Guest Log: %s\n", pThis->szMsg));
2992 pThis->iMsg = 0;
2993 }
2994 pThis->szMsg[pThis->iMsg] = (char )u32;
2995 pThis->szMsg[++pThis->iMsg] = '\0';
2996 }
2997 }
2998 return VINF_SUCCESS;
2999}
3000
3001#ifdef VMMDEV_WITH_ALT_TIMESYNC
3002
3003/**
3004 * @callback_method_impl{FNIOMIOPORTOUT, Alternative time synchronization.}
3005 */
3006static DECLCALLBACK(int) vmmdevAltTimeSyncWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
3007{
3008 RT_NOREF2(pvUser, Port);
3009 PVMMDEV pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
3010 if (cb == 4)
3011 {
3012 /* Selects high (0) or low (1) DWORD. The high has to be read first. */
3013 switch (u32)
3014 {
3015 case 0:
3016 pThis->fTimesyncBackdoorLo = false;
3017 break;
3018 case 1:
3019 pThis->fTimesyncBackdoorLo = true;
3020 break;
3021 default:
3022 Log(("vmmdevAltTimeSyncWrite: Invalid access cb=%#x u32=%#x\n", cb, u32));
3023 break;
3024 }
3025 }
3026 else
3027 Log(("vmmdevAltTimeSyncWrite: Invalid access cb=%#x u32=%#x\n", cb, u32));
3028 return VINF_SUCCESS;
3029}
3030
3031/**
3032 * @callback_method_impl{FNIOMIOPORTOUT, Alternative time synchronization.}
3033 */
3034static DECLCALLBACK(int) vmmdevAltTimeSyncRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
3035{
3036 RT_NOREF2(pvUser, Port);
3037 PVMMDEV pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
3038 int rc;
3039 if (cb == 4)
3040 {
3041 if (pThis->fTimesyncBackdoorLo)
3042 *pu32 = (uint32_t)pThis->hostTime;
3043 else
3044 {
3045 /* Reading the high dword gets and saves the current time. */
3046 RTTIMESPEC Now;
3047 pThis->hostTime = RTTimeSpecGetMilli(PDMDevHlpTMUtcNow(pDevIns, &Now));
3048 *pu32 = (uint32_t)(pThis->hostTime >> 32);
3049 }
3050 rc = VINF_SUCCESS;
3051 }
3052 else
3053 {
3054 Log(("vmmdevAltTimeSyncRead: Invalid access cb=%#x\n", cb));
3055 rc = VERR_IOM_IOPORT_UNUSED;
3056 }
3057 return rc;
3058}
3059
3060#endif /* VMMDEV_WITH_ALT_TIMESYNC */
3061
3062
3063/* -=-=-=-=-=- IBase -=-=-=-=-=- */
3064
3065/**
3066 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
3067 */
3068static DECLCALLBACK(void *) vmmdevPortQueryInterface(PPDMIBASE pInterface, const char *pszIID)
3069{
3070 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IBase);
3071
3072 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
3073 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIVMMDEVPORT, &pThis->IPort);
3074#ifdef VBOX_WITH_HGCM
3075 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHGCMPORT, &pThis->IHGCMPort);
3076#endif
3077 /* Currently only for shared folders. */
3078 PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->SharedFolders.ILeds);
3079 return NULL;
3080}
3081
3082
3083/* -=-=-=-=-=- ILeds -=-=-=-=-=- */
3084
3085/**
3086 * Gets the pointer to the status LED of a unit.
3087 *
3088 * @returns VBox status code.
3089 * @param pInterface Pointer to the interface structure containing the called function pointer.
3090 * @param iLUN The unit which status LED we desire.
3091 * @param ppLed Where to store the LED pointer.
3092 */
3093static DECLCALLBACK(int) vmmdevQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
3094{
3095 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, SharedFolders.ILeds);
3096 if (iLUN == 0) /* LUN 0 is shared folders */
3097 {
3098 *ppLed = &pThis->SharedFolders.Led;
3099 return VINF_SUCCESS;
3100 }
3101 return VERR_PDM_LUN_NOT_FOUND;
3102}
3103
3104
3105/* -=-=-=-=-=- PDMIVMMDEVPORT (VMMDEV::IPort) -=-=-=-=-=- */
3106
3107/**
3108 * @interface_method_impl{PDMIVMMDEVPORT,pfnQueryAbsoluteMouse}
3109 */
3110static DECLCALLBACK(int) vmmdevIPort_QueryAbsoluteMouse(PPDMIVMMDEVPORT pInterface, int32_t *pxAbs, int32_t *pyAbs)
3111{
3112 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3113
3114 /** @todo at the first sign of trouble in this area, just enter the critsect.
3115 * As indicated by the comment below, the atomic reads serves no real purpose
3116 * here since we can assume cache coherency protocoles and int32_t alignment
3117 * rules making sure we won't see a halfwritten value. */
3118 if (pxAbs)
3119 *pxAbs = ASMAtomicReadS32(&pThis->mouseXAbs); /* why the atomic read? */
3120 if (pyAbs)
3121 *pyAbs = ASMAtomicReadS32(&pThis->mouseYAbs);
3122
3123 return VINF_SUCCESS;
3124}
3125
3126/**
3127 * @interface_method_impl{PDMIVMMDEVPORT,pfnSetAbsoluteMouse}
3128 */
3129static DECLCALLBACK(int) vmmdevIPort_SetAbsoluteMouse(PPDMIVMMDEVPORT pInterface, int32_t xAbs, int32_t yAbs)
3130{
3131 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3132 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3133
3134 if ( pThis->mouseXAbs != xAbs
3135 || pThis->mouseYAbs != yAbs)
3136 {
3137 Log2(("vmmdevIPort_SetAbsoluteMouse : settings absolute position to x = %d, y = %d\n", xAbs, yAbs));
3138 pThis->mouseXAbs = xAbs;
3139 pThis->mouseYAbs = yAbs;
3140 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
3141 }
3142
3143 PDMCritSectLeave(&pThis->CritSect);
3144 return VINF_SUCCESS;
3145}
3146
3147/**
3148 * @interface_method_impl{PDMIVMMDEVPORT,pfnQueryMouseCapabilities}
3149 */
3150static DECLCALLBACK(int) vmmdevIPort_QueryMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t *pfCapabilities)
3151{
3152 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3153 AssertPtrReturn(pfCapabilities, VERR_INVALID_PARAMETER);
3154
3155 *pfCapabilities = pThis->mouseCapabilities;
3156 return VINF_SUCCESS;
3157}
3158
3159/**
3160 * @interface_method_impl{PDMIVMMDEVPORT,pfnUpdateMouseCapabilities}
3161 */
3162static DECLCALLBACK(int)
3163vmmdevIPort_UpdateMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t fCapsAdded, uint32_t fCapsRemoved)
3164{
3165 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3166 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3167
3168 uint32_t fOldCaps = pThis->mouseCapabilities;
3169 pThis->mouseCapabilities &= ~(fCapsRemoved & VMMDEV_MOUSE_HOST_MASK);
3170 pThis->mouseCapabilities |= (fCapsAdded & VMMDEV_MOUSE_HOST_MASK)
3171 | VMMDEV_MOUSE_HOST_RECHECKS_NEEDS_HOST_CURSOR;
3172 bool fNotify = fOldCaps != pThis->mouseCapabilities;
3173
3174 LogRelFlow(("VMMDev: vmmdevIPort_UpdateMouseCapabilities: fCapsAdded=0x%x, fCapsRemoved=0x%x, fNotify=%RTbool\n", fCapsAdded,
3175 fCapsRemoved, fNotify));
3176
3177 if (fNotify)
3178 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
3179
3180 PDMCritSectLeave(&pThis->CritSect);
3181 return VINF_SUCCESS;
3182}
3183
3184/**
3185 * @interface_method_impl{PDMIVMMDEVPORT,pfnRequestDisplayChange}
3186 */
3187static DECLCALLBACK(int)
3188vmmdevIPort_RequestDisplayChange(PPDMIVMMDEVPORT pInterface, uint32_t cx, uint32_t cy, uint32_t cBits, uint32_t idxDisplay,
3189 int32_t xOrigin, int32_t yOrigin, bool fEnabled, bool fChangeOrigin)
3190{
3191 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3192
3193 if (idxDisplay >= RT_ELEMENTS(pThis->displayChangeData.aRequests))
3194 return VERR_INVALID_PARAMETER;
3195
3196 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3197
3198 DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[idxDisplay];
3199
3200 /* Verify that the new resolution is different and that guest does not yet know about it. */
3201 bool fSameResolution = (!cx || pRequest->lastReadDisplayChangeRequest.xres == cx)
3202 && (!cy || pRequest->lastReadDisplayChangeRequest.yres == cy)
3203 && (!cBits || pRequest->lastReadDisplayChangeRequest.bpp == cBits)
3204 && pRequest->lastReadDisplayChangeRequest.xOrigin == xOrigin
3205 && pRequest->lastReadDisplayChangeRequest.yOrigin == yOrigin
3206 && pRequest->lastReadDisplayChangeRequest.fEnabled == fEnabled
3207 && pRequest->lastReadDisplayChangeRequest.display == idxDisplay;
3208
3209 if (!cx && !cy && !cBits)
3210 {
3211 /* Special case of reset video mode. */
3212 fSameResolution = false;
3213 }
3214
3215 Log3(("vmmdevIPort_RequestDisplayChange: same=%d. new: cx=%d, cy=%d, cBits=%d, idxDisplay=%d.\
3216 old: cx=%d, cy=%d, cBits=%d, idxDisplay=%d. \n \
3217 ,OriginX = %d , OriginY=%d, Enabled=%d, ChangeOrigin=%d\n",
3218 fSameResolution, cx, cy, cBits, idxDisplay, pRequest->lastReadDisplayChangeRequest.xres,
3219 pRequest->lastReadDisplayChangeRequest.yres, pRequest->lastReadDisplayChangeRequest.bpp,
3220 pRequest->lastReadDisplayChangeRequest.display,
3221 xOrigin, yOrigin, fEnabled, fChangeOrigin));
3222
3223 /* we could validate the information here but hey, the guest can do that as well! */
3224 pRequest->displayChangeRequest.xres = cx;
3225 pRequest->displayChangeRequest.yres = cy;
3226 pRequest->displayChangeRequest.bpp = cBits;
3227 pRequest->displayChangeRequest.display = idxDisplay;
3228 pRequest->displayChangeRequest.xOrigin = xOrigin;
3229 pRequest->displayChangeRequest.yOrigin = yOrigin;
3230 pRequest->displayChangeRequest.fEnabled = fEnabled;
3231 pRequest->displayChangeRequest.fChangeOrigin = fChangeOrigin;
3232
3233 pRequest->fPending = !fSameResolution;
3234
3235 if (!fSameResolution)
3236 {
3237 LogRel(("VMMDev: SetVideoModeHint: Got a video mode hint (%dx%dx%d)@(%dx%d),(%d;%d) at %d\n",
3238 cx, cy, cBits, xOrigin, yOrigin, fEnabled, fChangeOrigin, idxDisplay));
3239
3240 /* IRQ so the guest knows what's going on */
3241 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
3242 }
3243
3244 PDMCritSectLeave(&pThis->CritSect);
3245 return VINF_SUCCESS;
3246}
3247
3248/**
3249 * @interface_method_impl{PDMIVMMDEVPORT,pfnRequestSeamlessChange}
3250 */
3251static DECLCALLBACK(int) vmmdevIPort_RequestSeamlessChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
3252{
3253 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3254 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3255
3256 /* Verify that the new resolution is different and that guest does not yet know about it. */
3257 bool fSameMode = (pThis->fLastSeamlessEnabled == fEnabled);
3258
3259 Log(("vmmdevIPort_RequestSeamlessChange: same=%d. new=%d\n", fSameMode, fEnabled));
3260
3261 if (!fSameMode)
3262 {
3263 /* we could validate the information here but hey, the guest can do that as well! */
3264 pThis->fSeamlessEnabled = fEnabled;
3265
3266 /* IRQ so the guest knows what's going on */
3267 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST);
3268 }
3269
3270 PDMCritSectLeave(&pThis->CritSect);
3271 return VINF_SUCCESS;
3272}
3273
3274/**
3275 * @interface_method_impl{PDMIVMMDEVPORT,pfnSetMemoryBalloon}
3276 */
3277static DECLCALLBACK(int) vmmdevIPort_SetMemoryBalloon(PPDMIVMMDEVPORT pInterface, uint32_t cMbBalloon)
3278{
3279 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3280 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3281
3282 /* Verify that the new resolution is different and that guest does not yet know about it. */
3283 Log(("vmmdevIPort_SetMemoryBalloon: old=%u new=%u\n", pThis->cMbMemoryBalloonLast, cMbBalloon));
3284 if (pThis->cMbMemoryBalloonLast != cMbBalloon)
3285 {
3286 /* we could validate the information here but hey, the guest can do that as well! */
3287 pThis->cMbMemoryBalloon = cMbBalloon;
3288
3289 /* IRQ so the guest knows what's going on */
3290 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_BALLOON_CHANGE_REQUEST);
3291 }
3292
3293 PDMCritSectLeave(&pThis->CritSect);
3294 return VINF_SUCCESS;
3295}
3296
3297/**
3298 * @interface_method_impl{PDMIVMMDEVPORT,pfnVRDPChange}
3299 */
3300static DECLCALLBACK(int) vmmdevIPort_VRDPChange(PPDMIVMMDEVPORT pInterface, bool fVRDPEnabled, uint32_t uVRDPExperienceLevel)
3301{
3302 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3303 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3304
3305 bool fSame = (pThis->fVRDPEnabled == fVRDPEnabled);
3306
3307 Log(("vmmdevIPort_VRDPChange: old=%d. new=%d\n", pThis->fVRDPEnabled, fVRDPEnabled));
3308
3309 if (!fSame)
3310 {
3311 pThis->fVRDPEnabled = fVRDPEnabled;
3312 pThis->uVRDPExperienceLevel = uVRDPExperienceLevel;
3313
3314 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_VRDP);
3315 }
3316
3317 PDMCritSectLeave(&pThis->CritSect);
3318 return VINF_SUCCESS;
3319}
3320
3321/**
3322 * @interface_method_impl{PDMIVMMDEVPORT,pfnSetStatisticsInterval}
3323 */
3324static DECLCALLBACK(int) vmmdevIPort_SetStatisticsInterval(PPDMIVMMDEVPORT pInterface, uint32_t cSecsStatInterval)
3325{
3326 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3327 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3328
3329 /* Verify that the new resolution is different and that guest does not yet know about it. */
3330 bool fSame = (pThis->u32LastStatIntervalSize == cSecsStatInterval);
3331
3332 Log(("vmmdevIPort_SetStatisticsInterval: old=%d. new=%d\n", pThis->u32LastStatIntervalSize, cSecsStatInterval));
3333
3334 if (!fSame)
3335 {
3336 /* we could validate the information here but hey, the guest can do that as well! */
3337 pThis->u32StatIntervalSize = cSecsStatInterval;
3338
3339 /* IRQ so the guest knows what's going on */
3340 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST);
3341 }
3342
3343 PDMCritSectLeave(&pThis->CritSect);
3344 return VINF_SUCCESS;
3345}
3346
3347/**
3348 * @interface_method_impl{PDMIVMMDEVPORT,pfnSetCredentials}
3349 */
3350static DECLCALLBACK(int) vmmdevIPort_SetCredentials(PPDMIVMMDEVPORT pInterface, const char *pszUsername,
3351 const char *pszPassword, const char *pszDomain, uint32_t fFlags)
3352{
3353 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3354 AssertReturn(fFlags & (VMMDEV_SETCREDENTIALS_GUESTLOGON | VMMDEV_SETCREDENTIALS_JUDGE), VERR_INVALID_PARAMETER);
3355 size_t const cchUsername = strlen(pszUsername);
3356 AssertReturn(cchUsername < VMMDEV_CREDENTIALS_SZ_SIZE, VERR_BUFFER_OVERFLOW);
3357 size_t const cchPassword = strlen(pszPassword);
3358 AssertReturn(cchPassword < VMMDEV_CREDENTIALS_SZ_SIZE, VERR_BUFFER_OVERFLOW);
3359 size_t const cchDomain = strlen(pszDomain);
3360 AssertReturn(cchDomain < VMMDEV_CREDENTIALS_SZ_SIZE, VERR_BUFFER_OVERFLOW);
3361
3362 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3363
3364 /*
3365 * Logon mode
3366 */
3367 if (fFlags & VMMDEV_SETCREDENTIALS_GUESTLOGON)
3368 {
3369 /* memorize the data */
3370 memcpy(pThis->pCredentials->Logon.szUserName, pszUsername, cchUsername);
3371 pThis->pCredentials->Logon.szUserName[cchUsername] = '\0';
3372 memcpy(pThis->pCredentials->Logon.szPassword, pszPassword, cchPassword);
3373 pThis->pCredentials->Logon.szPassword[cchPassword] = '\0';
3374 memcpy(pThis->pCredentials->Logon.szDomain, pszDomain, cchDomain);
3375 pThis->pCredentials->Logon.szDomain[cchDomain] = '\0';
3376 pThis->pCredentials->Logon.fAllowInteractiveLogon = !(fFlags & VMMDEV_SETCREDENTIALS_NOLOCALLOGON);
3377 }
3378 /*
3379 * Credentials verification mode?
3380 */
3381 else
3382 {
3383 /* memorize the data */
3384 memcpy(pThis->pCredentials->Judge.szUserName, pszUsername, cchUsername);
3385 pThis->pCredentials->Judge.szUserName[cchUsername] = '\0';
3386 memcpy(pThis->pCredentials->Judge.szPassword, pszPassword, cchPassword);
3387 pThis->pCredentials->Judge.szPassword[cchPassword] = '\0';
3388 memcpy(pThis->pCredentials->Judge.szDomain, pszDomain, cchDomain);
3389 pThis->pCredentials->Judge.szDomain[cchDomain] = '\0';
3390
3391 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_JUDGE_CREDENTIALS);
3392 }
3393
3394 PDMCritSectLeave(&pThis->CritSect);
3395 return VINF_SUCCESS;
3396}
3397
3398/**
3399 * @interface_method_impl{PDMIVMMDEVPORT,pfnVBVAChange}
3400 *
3401 * Notification from the Display. Especially useful when acceleration is
3402 * disabled after a video mode change.
3403 */
3404static DECLCALLBACK(void) vmmdevIPort_VBVAChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
3405{
3406 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3407 Log(("vmmdevIPort_VBVAChange: fEnabled = %d\n", fEnabled));
3408
3409 /* Only used by saved state, which I guess is why we don't bother with locking here. */
3410 pThis->u32VideoAccelEnabled = fEnabled;
3411}
3412
3413/**
3414 * @interface_method_impl{PDMIVMMDEVPORT,pfnCpuHotUnplug}
3415 */
3416static DECLCALLBACK(int) vmmdevIPort_CpuHotUnplug(PPDMIVMMDEVPORT pInterface, uint32_t idCpuCore, uint32_t idCpuPackage)
3417{
3418 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3419 int rc = VINF_SUCCESS;
3420
3421 Log(("vmmdevIPort_CpuHotUnplug: idCpuCore=%u idCpuPackage=%u\n", idCpuCore, idCpuPackage));
3422
3423 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3424
3425 if (pThis->fCpuHotPlugEventsEnabled)
3426 {
3427 pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_Unplug;
3428 pThis->idCpuCore = idCpuCore;
3429 pThis->idCpuPackage = idCpuPackage;
3430 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_CPU_HOTPLUG);
3431 }
3432 else
3433 rc = VERR_VMMDEV_CPU_HOTPLUG_NOT_MONITORED_BY_GUEST;
3434
3435 PDMCritSectLeave(&pThis->CritSect);
3436 return rc;
3437}
3438
3439/**
3440 * @interface_method_impl{PDMIVMMDEVPORT,pfnCpuHotPlug}
3441 */
3442static DECLCALLBACK(int) vmmdevIPort_CpuHotPlug(PPDMIVMMDEVPORT pInterface, uint32_t idCpuCore, uint32_t idCpuPackage)
3443{
3444 PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3445 int rc = VINF_SUCCESS;
3446
3447 Log(("vmmdevCpuPlug: idCpuCore=%u idCpuPackage=%u\n", idCpuCore, idCpuPackage));
3448
3449 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3450
3451 if (pThis->fCpuHotPlugEventsEnabled)
3452 {
3453 pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_Plug;
3454 pThis->idCpuCore = idCpuCore;
3455 pThis->idCpuPackage = idCpuPackage;
3456 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_CPU_HOTPLUG);
3457 }
3458 else
3459 rc = VERR_VMMDEV_CPU_HOTPLUG_NOT_MONITORED_BY_GUEST;
3460
3461 PDMCritSectLeave(&pThis->CritSect);
3462 return rc;
3463}
3464
3465
3466/* -=-=-=-=-=- Saved State -=-=-=-=-=- */
3467
3468/**
3469 * @callback_method_impl{FNSSMDEVLIVEEXEC}
3470 */
3471static DECLCALLBACK(int) vmmdevLiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
3472{
3473 RT_NOREF1(uPass);
3474 PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3475
3476 SSMR3PutBool(pSSM, pThis->fGetHostTimeDisabled);
3477 SSMR3PutBool(pSSM, pThis->fBackdoorLogDisabled);
3478 SSMR3PutBool(pSSM, pThis->fKeepCredentials);
3479 SSMR3PutBool(pSSM, pThis->fHeapEnabled);
3480
3481 return VINF_SSM_DONT_CALL_AGAIN;
3482}
3483
3484
3485/**
3486 * @callback_method_impl{FNSSMDEVSAVEEXEC}
3487 */
3488static DECLCALLBACK(int) vmmdevSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
3489{
3490 PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3491 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3492
3493 vmmdevLiveExec(pDevIns, pSSM, SSM_PASS_FINAL);
3494
3495 SSMR3PutU32(pSSM, pThis->hypervisorSize);
3496 SSMR3PutU32(pSSM, pThis->mouseCapabilities);
3497 SSMR3PutS32(pSSM, pThis->mouseXAbs);
3498 SSMR3PutS32(pSSM, pThis->mouseYAbs);
3499
3500 SSMR3PutBool(pSSM, pThis->fNewGuestFilterMask);
3501 SSMR3PutU32(pSSM, pThis->u32NewGuestFilterMask);
3502 SSMR3PutU32(pSSM, pThis->u32GuestFilterMask);
3503 SSMR3PutU32(pSSM, pThis->u32HostEventFlags);
3504 /* The following is not strictly necessary as PGM restores MMIO2, keeping it for historical reasons. */
3505 SSMR3PutMem(pSSM, &pThis->pVMMDevRAMR3->V, sizeof(pThis->pVMMDevRAMR3->V));
3506
3507 SSMR3PutMem(pSSM, &pThis->guestInfo, sizeof(pThis->guestInfo));
3508 SSMR3PutU32(pSSM, pThis->fu32AdditionsOk);
3509 SSMR3PutU32(pSSM, pThis->u32VideoAccelEnabled);
3510 SSMR3PutBool(pSSM, pThis->displayChangeData.fGuestSentChangeEventAck);
3511
3512 SSMR3PutU32(pSSM, pThis->guestCaps);
3513
3514#ifdef VBOX_WITH_HGCM
3515 vmmdevHGCMSaveState(pThis, pSSM);
3516#endif /* VBOX_WITH_HGCM */
3517
3518 SSMR3PutU32(pSSM, pThis->fHostCursorRequested);
3519
3520 SSMR3PutU32(pSSM, pThis->guestInfo2.uFullVersion);
3521 SSMR3PutU32(pSSM, pThis->guestInfo2.uRevision);
3522 SSMR3PutU32(pSSM, pThis->guestInfo2.fFeatures);
3523 SSMR3PutStrZ(pSSM, pThis->guestInfo2.szName);
3524 SSMR3PutU32(pSSM, pThis->cFacilityStatuses);
3525 for (uint32_t i = 0; i < pThis->cFacilityStatuses; i++)
3526 {
3527 SSMR3PutU32(pSSM, pThis->aFacilityStatuses[i].enmFacility);
3528 SSMR3PutU32(pSSM, pThis->aFacilityStatuses[i].fFlags);
3529 SSMR3PutU16(pSSM, (uint16_t)pThis->aFacilityStatuses[i].enmStatus);
3530 SSMR3PutS64(pSSM, RTTimeSpecGetNano(&pThis->aFacilityStatuses[i].TimeSpecTS));
3531 }
3532
3533 /* Heartbeat: */
3534 SSMR3PutBool(pSSM, pThis->fHeartbeatActive);
3535 SSMR3PutBool(pSSM, pThis->fFlatlined);
3536 SSMR3PutU64(pSSM, pThis->nsLastHeartbeatTS);
3537 TMR3TimerSave(pThis->pFlatlinedTimer, pSSM);
3538
3539 PDMCritSectLeave(&pThis->CritSect);
3540 return VINF_SUCCESS;
3541}
3542
3543/**
3544 * @callback_method_impl{FNSSMDEVLOADEXEC}
3545 */
3546static DECLCALLBACK(int) vmmdevLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
3547{
3548 /** @todo The code load code is assuming we're always loaded into a freshly
3549 * constructed VM. */
3550 PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3551 int rc;
3552
3553 if ( uVersion > VMMDEV_SAVED_STATE_VERSION
3554 || uVersion < 6)
3555 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
3556
3557 /* config */
3558 if (uVersion > VMMDEV_SAVED_STATE_VERSION_VBOX_30)
3559 {
3560 bool f;
3561 rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
3562 if (pThis->fGetHostTimeDisabled != f)
3563 LogRel(("VMMDev: Config mismatch - fGetHostTimeDisabled: config=%RTbool saved=%RTbool\n", pThis->fGetHostTimeDisabled, f));
3564
3565 rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
3566 if (pThis->fBackdoorLogDisabled != f)
3567 LogRel(("VMMDev: Config mismatch - fBackdoorLogDisabled: config=%RTbool saved=%RTbool\n", pThis->fBackdoorLogDisabled, f));
3568
3569 rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
3570 if (pThis->fKeepCredentials != f)
3571 return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fKeepCredentials: config=%RTbool saved=%RTbool"),
3572 pThis->fKeepCredentials, f);
3573 rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
3574 if (pThis->fHeapEnabled != f)
3575 return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fHeapEnabled: config=%RTbool saved=%RTbool"),
3576 pThis->fHeapEnabled, f);
3577 }
3578
3579 if (uPass != SSM_PASS_FINAL)
3580 return VINF_SUCCESS;
3581
3582 /* state */
3583 SSMR3GetU32(pSSM, &pThis->hypervisorSize);
3584 SSMR3GetU32(pSSM, &pThis->mouseCapabilities);
3585 SSMR3GetS32(pSSM, &pThis->mouseXAbs);
3586 SSMR3GetS32(pSSM, &pThis->mouseYAbs);
3587
3588 SSMR3GetBool(pSSM, &pThis->fNewGuestFilterMask);
3589 SSMR3GetU32(pSSM, &pThis->u32NewGuestFilterMask);
3590 SSMR3GetU32(pSSM, &pThis->u32GuestFilterMask);
3591 SSMR3GetU32(pSSM, &pThis->u32HostEventFlags);
3592
3593 //SSMR3GetBool(pSSM, &pThis->pVMMDevRAMR3->fHaveEvents);
3594 // here be dragons (probably)
3595 SSMR3GetMem(pSSM, &pThis->pVMMDevRAMR3->V, sizeof (pThis->pVMMDevRAMR3->V));
3596
3597 SSMR3GetMem(pSSM, &pThis->guestInfo, sizeof (pThis->guestInfo));
3598 SSMR3GetU32(pSSM, &pThis->fu32AdditionsOk);
3599 SSMR3GetU32(pSSM, &pThis->u32VideoAccelEnabled);
3600 if (uVersion > 10)
3601 SSMR3GetBool(pSSM, &pThis->displayChangeData.fGuestSentChangeEventAck);
3602
3603 rc = SSMR3GetU32(pSSM, &pThis->guestCaps);
3604
3605 /* Attributes which were temporarily introduced in r30072 */
3606 if (uVersion == 7)
3607 {
3608 uint32_t temp;
3609 SSMR3GetU32(pSSM, &temp);
3610 rc = SSMR3GetU32(pSSM, &temp);
3611 }
3612 AssertRCReturn(rc, rc);
3613
3614#ifdef VBOX_WITH_HGCM
3615 rc = vmmdevHGCMLoadState(pThis, pSSM, uVersion);
3616 AssertRCReturn(rc, rc);
3617#endif /* VBOX_WITH_HGCM */
3618
3619 if (uVersion >= 10)
3620 rc = SSMR3GetU32(pSSM, &pThis->fHostCursorRequested);
3621 AssertRCReturn(rc, rc);
3622
3623 if (uVersion > VMMDEV_SAVED_STATE_VERSION_MISSING_GUEST_INFO_2)
3624 {
3625 SSMR3GetU32(pSSM, &pThis->guestInfo2.uFullVersion);
3626 SSMR3GetU32(pSSM, &pThis->guestInfo2.uRevision);
3627 SSMR3GetU32(pSSM, &pThis->guestInfo2.fFeatures);
3628 rc = SSMR3GetStrZ(pSSM, &pThis->guestInfo2.szName[0], sizeof(pThis->guestInfo2.szName));
3629 AssertRCReturn(rc, rc);
3630 }
3631
3632 if (uVersion > VMMDEV_SAVED_STATE_VERSION_MISSING_FACILITY_STATUSES)
3633 {
3634 uint32_t cFacilityStatuses;
3635 rc = SSMR3GetU32(pSSM, &cFacilityStatuses);
3636 AssertRCReturn(rc, rc);
3637
3638 for (uint32_t i = 0; i < cFacilityStatuses; i++)
3639 {
3640 uint32_t uFacility, fFlags;
3641 uint16_t uStatus;
3642 int64_t iTimeStampNano;
3643
3644 SSMR3GetU32(pSSM, &uFacility);
3645 SSMR3GetU32(pSSM, &fFlags);
3646 SSMR3GetU16(pSSM, &uStatus);
3647 rc = SSMR3GetS64(pSSM, &iTimeStampNano);
3648 AssertRCReturn(rc, rc);
3649
3650 PVMMDEVFACILITYSTATUSENTRY pEntry = vmmdevGetFacilityStatusEntry(pThis, (VBoxGuestFacilityType)uFacility);
3651 AssertLogRelMsgReturn(pEntry,
3652 ("VMMDev: Ran out of entries restoring the guest facility statuses. Saved state has %u.\n", cFacilityStatuses),
3653 VERR_OUT_OF_RESOURCES);
3654 pEntry->enmStatus = (VBoxGuestFacilityStatus)uStatus;
3655 pEntry->fFlags = fFlags;
3656 RTTimeSpecSetNano(&pEntry->TimeSpecTS, iTimeStampNano);
3657 }
3658 }
3659
3660 /*
3661 * Heartbeat.
3662 */
3663 if (uVersion >= VMMDEV_SAVED_STATE_VERSION_HEARTBEAT)
3664 {
3665 SSMR3GetBool(pSSM, (bool *)&pThis->fHeartbeatActive);
3666 SSMR3GetBool(pSSM, (bool *)&pThis->fFlatlined);
3667 SSMR3GetU64(pSSM, (uint64_t *)&pThis->nsLastHeartbeatTS);
3668 rc = TMR3TimerLoad(pThis->pFlatlinedTimer, pSSM);
3669 AssertRCReturn(rc, rc);
3670 if (pThis->fFlatlined)
3671 LogRel(("vmmdevLoadState: Guest has flatlined. Last heartbeat %'RU64 ns before state was saved.\n",
3672 TMTimerGetNano(pThis->pFlatlinedTimer) - pThis->nsLastHeartbeatTS));
3673 }
3674
3675 /*
3676 * On a resume, we send the capabilities changed message so
3677 * that listeners can sync their state again
3678 */
3679 Log(("vmmdevLoadState: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
3680 if (pThis->pDrv)
3681 {
3682 pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
3683 if (uVersion >= 10)
3684 pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
3685 /*fVisible=*/!!pThis->fHostCursorRequested,
3686 /*fAlpha=*/false,
3687 /*xHot=*/0, /*yHot=*/0,
3688 /*cx=*/0, /*cy=*/0,
3689 /*pvShape=*/NULL);
3690 }
3691
3692 if (pThis->fu32AdditionsOk)
3693 {
3694 vmmdevLogGuestOsInfo(&pThis->guestInfo);
3695 if (pThis->pDrv)
3696 {
3697 if (pThis->guestInfo2.uFullVersion && pThis->pDrv->pfnUpdateGuestInfo2)
3698 pThis->pDrv->pfnUpdateGuestInfo2(pThis->pDrv, pThis->guestInfo2.uFullVersion, pThis->guestInfo2.szName,
3699 pThis->guestInfo2.uRevision, pThis->guestInfo2.fFeatures);
3700 if (pThis->pDrv->pfnUpdateGuestInfo)
3701 pThis->pDrv->pfnUpdateGuestInfo(pThis->pDrv, &pThis->guestInfo);
3702
3703 if (pThis->pDrv->pfnUpdateGuestStatus)
3704 {
3705 for (uint32_t i = 0; i < pThis->cFacilityStatuses; i++) /* ascending order! */
3706 if ( pThis->aFacilityStatuses[i].enmStatus != VBoxGuestFacilityStatus_Inactive
3707 || !pThis->aFacilityStatuses[i].fFixed)
3708 pThis->pDrv->pfnUpdateGuestStatus(pThis->pDrv,
3709 pThis->aFacilityStatuses[i].enmFacility,
3710 (uint16_t)pThis->aFacilityStatuses[i].enmStatus,
3711 pThis->aFacilityStatuses[i].fFlags,
3712 &pThis->aFacilityStatuses[i].TimeSpecTS);
3713 }
3714 }
3715 }
3716 if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestCapabilities)
3717 pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
3718
3719 return VINF_SUCCESS;
3720}
3721
3722/**
3723 * Load state done callback. Notify guest of restore event.
3724 *
3725 * @returns VBox status code.
3726 * @param pDevIns The device instance.
3727 * @param pSSM The handle to the saved state.
3728 */
3729static DECLCALLBACK(int) vmmdevLoadStateDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
3730{
3731 RT_NOREF1(pSSM);
3732 PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3733
3734#ifdef VBOX_WITH_HGCM
3735 int rc = vmmdevHGCMLoadStateDone(pThis);
3736 AssertLogRelRCReturn(rc, rc);
3737#endif /* VBOX_WITH_HGCM */
3738
3739 /* Reestablish the acceleration status. */
3740 if ( pThis->u32VideoAccelEnabled
3741 && pThis->pDrv)
3742 {
3743 pThis->pDrv->pfnVideoAccelEnable(pThis->pDrv, !!pThis->u32VideoAccelEnabled, &pThis->pVMMDevRAMR3->vbvaMemory);
3744 }
3745
3746 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_RESTORED);
3747
3748 return VINF_SUCCESS;
3749}
3750
3751
3752/* -=-=-=-=- PDMDEVREG -=-=-=-=- */
3753
3754/**
3755 * (Re-)initializes the MMIO2 data.
3756 *
3757 * @param pThis Pointer to the VMMDev instance data.
3758 */
3759static void vmmdevInitRam(PVMMDEV pThis)
3760{
3761 memset(pThis->pVMMDevRAMR3, 0, sizeof(VMMDevMemory));
3762 pThis->pVMMDevRAMR3->u32Size = sizeof(VMMDevMemory);
3763 pThis->pVMMDevRAMR3->u32Version = VMMDEV_MEMORY_VERSION;
3764}
3765
3766
3767/**
3768 * @interface_method_impl{PDMDEVREG,pfnReset}
3769 */
3770static DECLCALLBACK(void) vmmdevReset(PPDMDEVINS pDevIns)
3771{
3772 PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3773 PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3774
3775 /*
3776 * Reset the mouse integration feature bits
3777 */
3778 if (pThis->mouseCapabilities & VMMDEV_MOUSE_GUEST_MASK)
3779 {
3780 pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_MASK;
3781 /* notify the connector */
3782 Log(("vmmdevReset: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
3783 pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
3784 }
3785 pThis->fHostCursorRequested = false;
3786
3787 pThis->hypervisorSize = 0;
3788
3789 /* re-initialize the VMMDev memory */
3790 if (pThis->pVMMDevRAMR3)
3791 vmmdevInitRam(pThis);
3792
3793 /* credentials have to go away (by default) */
3794 if (!pThis->fKeepCredentials)
3795 {
3796 memset(pThis->pCredentials->Logon.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3797 memset(pThis->pCredentials->Logon.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3798 memset(pThis->pCredentials->Logon.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3799 }
3800 memset(pThis->pCredentials->Judge.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3801 memset(pThis->pCredentials->Judge.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3802 memset(pThis->pCredentials->Judge.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3803
3804 /* Reset means that additions will report again. */
3805 const bool fVersionChanged = pThis->fu32AdditionsOk
3806 || pThis->guestInfo.interfaceVersion
3807 || pThis->guestInfo.osType != VBOXOSTYPE_Unknown;
3808 if (fVersionChanged)
3809 Log(("vmmdevReset: fu32AdditionsOk=%d additionsVersion=%x osType=%#x\n",
3810 pThis->fu32AdditionsOk, pThis->guestInfo.interfaceVersion, pThis->guestInfo.osType));
3811 pThis->fu32AdditionsOk = false;
3812 memset (&pThis->guestInfo, 0, sizeof (pThis->guestInfo));
3813 RT_ZERO(pThis->guestInfo2);
3814 const bool fCapsChanged = pThis->guestCaps != 0; /* Report transition to 0. */
3815 pThis->guestCaps = 0;
3816
3817 /* Clear facilities. No need to tell Main as it will get a
3818 pfnUpdateGuestInfo callback. */
3819 RTTIMESPEC TimeStampNow;
3820 RTTimeNow(&TimeStampNow);
3821 uint32_t iFacility = pThis->cFacilityStatuses;
3822 while (iFacility-- > 0)
3823 {
3824 pThis->aFacilityStatuses[iFacility].enmStatus = VBoxGuestFacilityStatus_Inactive;
3825 pThis->aFacilityStatuses[iFacility].TimeSpecTS = TimeStampNow;
3826 }
3827
3828 /* clear pending display change request. */
3829 for (unsigned i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
3830 {
3831 DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[i];
3832 memset (&pRequest->lastReadDisplayChangeRequest, 0, sizeof (pRequest->lastReadDisplayChangeRequest));
3833 }
3834 pThis->displayChangeData.iCurrentMonitor = 0;
3835 pThis->displayChangeData.fGuestSentChangeEventAck = false;
3836
3837 /* disable seamless mode */
3838 pThis->fLastSeamlessEnabled = false;
3839
3840 /* disabled memory ballooning */
3841 pThis->cMbMemoryBalloonLast = 0;
3842
3843 /* disabled statistics updating */
3844 pThis->u32LastStatIntervalSize = 0;
3845
3846#ifdef VBOX_WITH_HGCM
3847 /* Clear the "HGCM event enabled" flag so the event can be automatically reenabled. */
3848 pThis->u32HGCMEnabled = 0;
3849#endif
3850
3851 /*
3852 * Deactive heartbeat.
3853 */
3854 if (pThis->fHeartbeatActive)
3855 {
3856 TMTimerStop(pThis->pFlatlinedTimer);
3857 pThis->fFlatlined = false;
3858 pThis->fHeartbeatActive = true;
3859 }
3860
3861 /*
3862 * Clear the event variables.
3863 *
3864 * XXX By design we should NOT clear pThis->u32HostEventFlags because it is designed
3865 * that way so host events do not depend on guest resets. However, the pending
3866 * event flags actually _were_ cleared since ages so we mask out events from
3867 * clearing which we really need to survive the reset. See xtracker 5767.
3868 */
3869 pThis->u32HostEventFlags &= VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
3870 pThis->u32GuestFilterMask = 0;
3871 pThis->u32NewGuestFilterMask = 0;
3872 pThis->fNewGuestFilterMask = 0;
3873
3874 /*
3875 * Call the update functions as required.
3876 */
3877 if (fVersionChanged && pThis->pDrv && pThis->pDrv->pfnUpdateGuestInfo)
3878 pThis->pDrv->pfnUpdateGuestInfo(pThis->pDrv, &pThis->guestInfo);
3879 if (fCapsChanged && pThis->pDrv && pThis->pDrv->pfnUpdateGuestCapabilities)
3880 pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
3881
3882 /*
3883 * Generate a unique session id for this VM; it will be changed for each start, reset or restore.
3884 * This can be used for restore detection inside the guest.
3885 */
3886 pThis->idSession = ASMReadTSC();
3887
3888 PDMCritSectLeave(&pThis->CritSect);
3889}
3890
3891
3892/**
3893 * @interface_method_impl{PDMDEVREG,pfnRelocate}
3894 */
3895static DECLCALLBACK(void) vmmdevRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
3896{
3897 NOREF(pDevIns);
3898 NOREF(offDelta);
3899}
3900
3901
3902/**
3903 * @interface_method_impl{PDMDEVREG,pfnDestruct}
3904 */
3905static DECLCALLBACK(int) vmmdevDestruct(PPDMDEVINS pDevIns)
3906{
3907 PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3908 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
3909
3910 /*
3911 * Wipe and free the credentials.
3912 */
3913 if (pThis->pCredentials)
3914 {
3915 RTMemWipeThoroughly(pThis->pCredentials, sizeof(*pThis->pCredentials), 10);
3916 RTMemFree(pThis->pCredentials);
3917 pThis->pCredentials = NULL;
3918 }
3919
3920#ifdef VBOX_WITH_HGCM
3921 vmmdevHGCMDestroy(pThis);
3922 RTCritSectDelete(&pThis->critsectHGCMCmdList);
3923#endif
3924
3925#ifndef VBOX_WITHOUT_TESTING_FEATURES
3926 /*
3927 * Clean up the testing device.
3928 */
3929 vmmdevTestingTerminate(pDevIns);
3930#endif
3931
3932 return VINF_SUCCESS;
3933}
3934
3935
3936/**
3937 * @interface_method_impl{PDMDEVREG,pfnConstruct}
3938 */
3939static DECLCALLBACK(int) vmmdevConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
3940{
3941 PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3942 int rc;
3943
3944 Assert(iInstance == 0);
3945 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
3946
3947 /*
3948 * Initialize data (most of it anyway).
3949 */
3950 /* Save PDM device instance data for future reference. */
3951 pThis->pDevIns = pDevIns;
3952
3953 /* PCI vendor, just a free bogus value */
3954 PCIDevSetVendorId(&pThis->PciDev, 0x80ee);
3955 /* device ID */
3956 PCIDevSetDeviceId(&pThis->PciDev, 0xcafe);
3957 /* class sub code (other type of system peripheral) */
3958 PCIDevSetClassSub(&pThis->PciDev, 0x80);
3959 /* class base code (base system peripheral) */
3960 PCIDevSetClassBase(&pThis->PciDev, 0x08);
3961 /* header type */
3962 PCIDevSetHeaderType(&pThis->PciDev, 0x00);
3963 /* interrupt on pin 0 */
3964 PCIDevSetInterruptPin(&pThis->PciDev, 0x01);
3965
3966 RTTIMESPEC TimeStampNow;
3967 RTTimeNow(&TimeStampNow);
3968 vmmdevAllocFacilityStatusEntry(pThis, VBoxGuestFacilityType_VBoxGuestDriver, true /*fFixed*/, &TimeStampNow);
3969 vmmdevAllocFacilityStatusEntry(pThis, VBoxGuestFacilityType_VBoxService, true /*fFixed*/, &TimeStampNow);
3970 vmmdevAllocFacilityStatusEntry(pThis, VBoxGuestFacilityType_VBoxTrayClient, true /*fFixed*/, &TimeStampNow);
3971 vmmdevAllocFacilityStatusEntry(pThis, VBoxGuestFacilityType_Seamless, true /*fFixed*/, &TimeStampNow);
3972 vmmdevAllocFacilityStatusEntry(pThis, VBoxGuestFacilityType_Graphics, true /*fFixed*/, &TimeStampNow);
3973 Assert(pThis->cFacilityStatuses == 5);
3974
3975 /*
3976 * Interfaces
3977 */
3978 /* IBase */
3979 pThis->IBase.pfnQueryInterface = vmmdevPortQueryInterface;
3980
3981 /* VMMDev port */
3982 pThis->IPort.pfnQueryAbsoluteMouse = vmmdevIPort_QueryAbsoluteMouse;
3983 pThis->IPort.pfnSetAbsoluteMouse = vmmdevIPort_SetAbsoluteMouse ;
3984 pThis->IPort.pfnQueryMouseCapabilities = vmmdevIPort_QueryMouseCapabilities;
3985 pThis->IPort.pfnUpdateMouseCapabilities = vmmdevIPort_UpdateMouseCapabilities;
3986 pThis->IPort.pfnRequestDisplayChange = vmmdevIPort_RequestDisplayChange;
3987 pThis->IPort.pfnSetCredentials = vmmdevIPort_SetCredentials;
3988 pThis->IPort.pfnVBVAChange = vmmdevIPort_VBVAChange;
3989 pThis->IPort.pfnRequestSeamlessChange = vmmdevIPort_RequestSeamlessChange;
3990 pThis->IPort.pfnSetMemoryBalloon = vmmdevIPort_SetMemoryBalloon;
3991 pThis->IPort.pfnSetStatisticsInterval = vmmdevIPort_SetStatisticsInterval;
3992 pThis->IPort.pfnVRDPChange = vmmdevIPort_VRDPChange;
3993 pThis->IPort.pfnCpuHotUnplug = vmmdevIPort_CpuHotUnplug;
3994 pThis->IPort.pfnCpuHotPlug = vmmdevIPort_CpuHotPlug;
3995
3996 /* Shared folder LED */
3997 pThis->SharedFolders.Led.u32Magic = PDMLED_MAGIC;
3998 pThis->SharedFolders.ILeds.pfnQueryStatusLed = vmmdevQueryStatusLed;
3999
4000#ifdef VBOX_WITH_HGCM
4001 /* HGCM port */
4002 pThis->IHGCMPort.pfnCompleted = hgcmCompleted;
4003#endif
4004
4005 pThis->pCredentials = (VMMDEVCREDS *)RTMemAllocZ(sizeof(*pThis->pCredentials));
4006 if (!pThis->pCredentials)
4007 return VERR_NO_MEMORY;
4008
4009
4010 /*
4011 * Validate and read the configuration.
4012 */
4013 PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns,
4014 "GetHostTimeDisabled|"
4015 "BackdoorLogDisabled|"
4016 "KeepCredentials|"
4017 "HeapEnabled|"
4018 "RZEnabled|"
4019 "GuestCoreDumpEnabled|"
4020 "GuestCoreDumpDir|"
4021 "GuestCoreDumpCount|"
4022 "HeartbeatInterval|"
4023 "HeartbeatTimeout|"
4024 "TestingEnabled|"
4025 "TestingMMIO|"
4026 "TestintXmlOutputFile"
4027 ,
4028 "");
4029
4030 rc = CFGMR3QueryBoolDef(pCfg, "GetHostTimeDisabled", &pThis->fGetHostTimeDisabled, false);
4031 if (RT_FAILURE(rc))
4032 return PDMDEV_SET_ERROR(pDevIns, rc,
4033 N_("Configuration error: Failed querying \"GetHostTimeDisabled\" as a boolean"));
4034
4035 rc = CFGMR3QueryBoolDef(pCfg, "BackdoorLogDisabled", &pThis->fBackdoorLogDisabled, false);
4036 if (RT_FAILURE(rc))
4037 return PDMDEV_SET_ERROR(pDevIns, rc,
4038 N_("Configuration error: Failed querying \"BackdoorLogDisabled\" as a boolean"));
4039
4040 rc = CFGMR3QueryBoolDef(pCfg, "KeepCredentials", &pThis->fKeepCredentials, false);
4041 if (RT_FAILURE(rc))
4042 return PDMDEV_SET_ERROR(pDevIns, rc,
4043 N_("Configuration error: Failed querying \"KeepCredentials\" as a boolean"));
4044
4045 rc = CFGMR3QueryBoolDef(pCfg, "HeapEnabled", &pThis->fHeapEnabled, true);
4046 if (RT_FAILURE(rc))
4047 return PDMDEV_SET_ERROR(pDevIns, rc,
4048 N_("Configuration error: Failed querying \"HeapEnabled\" as a boolean"));
4049
4050 rc = CFGMR3QueryBoolDef(pCfg, "RZEnabled", &pThis->fRZEnabled, true);
4051 if (RT_FAILURE(rc))
4052 return PDMDEV_SET_ERROR(pDevIns, rc,
4053 N_("Configuration error: Failed querying \"RZEnabled\" as a boolean"));
4054
4055 rc = CFGMR3QueryBoolDef(pCfg, "GuestCoreDumpEnabled", &pThis->fGuestCoreDumpEnabled, false);
4056 if (RT_FAILURE(rc))
4057 return PDMDEV_SET_ERROR(pDevIns, rc,
4058 N_("Configuration error: Failed querying \"GuestCoreDumpEnabled\" as a boolean"));
4059
4060 char *pszGuestCoreDumpDir = NULL;
4061 rc = CFGMR3QueryStringAllocDef(pCfg, "GuestCoreDumpDir", &pszGuestCoreDumpDir, "");
4062 if (RT_FAILURE(rc))
4063 return PDMDEV_SET_ERROR(pDevIns, rc,
4064 N_("Configuration error: Failed querying \"GuestCoreDumpDir\" as a string"));
4065
4066 RTStrCopy(pThis->szGuestCoreDumpDir, sizeof(pThis->szGuestCoreDumpDir), pszGuestCoreDumpDir);
4067 MMR3HeapFree(pszGuestCoreDumpDir);
4068
4069 rc = CFGMR3QueryU32Def(pCfg, "GuestCoreDumpCount", &pThis->cGuestCoreDumps, 3);
4070 if (RT_FAILURE(rc))
4071 return PDMDEV_SET_ERROR(pDevIns, rc,
4072 N_("Configuration error: Failed querying \"GuestCoreDumpCount\" as a 32-bit unsigned integer"));
4073
4074 rc = CFGMR3QueryU64Def(pCfg, "HeartbeatInterval", &pThis->cNsHeartbeatInterval, VMMDEV_HEARTBEAT_DEFAULT_INTERVAL);
4075 if (RT_FAILURE(rc))
4076 return PDMDEV_SET_ERROR(pDevIns, rc,
4077 N_("Configuration error: Failed querying \"HeartbeatInterval\" as a 64-bit unsigned integer"));
4078 if (pThis->cNsHeartbeatInterval < RT_NS_100MS / 2)
4079 return PDMDEV_SET_ERROR(pDevIns, rc,
4080 N_("Configuration error: Heartbeat interval \"HeartbeatInterval\" too small"));
4081
4082 rc = CFGMR3QueryU64Def(pCfg, "HeartbeatTimeout", &pThis->cNsHeartbeatTimeout, pThis->cNsHeartbeatInterval * 2);
4083 if (RT_FAILURE(rc))
4084 return PDMDEV_SET_ERROR(pDevIns, rc,
4085 N_("Configuration error: Failed querying \"HeartbeatTimeout\" as a 64-bit unsigned integer"));
4086 if (pThis->cNsHeartbeatTimeout < RT_NS_100MS)
4087 return PDMDEV_SET_ERROR(pDevIns, rc,
4088 N_("Configuration error: Heartbeat timeout \"HeartbeatTimeout\" too small"));
4089 if (pThis->cNsHeartbeatTimeout <= pThis->cNsHeartbeatInterval + RT_NS_10MS)
4090 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
4091 N_("Configuration error: Heartbeat timeout \"HeartbeatTimeout\" value (%'ull ns) is too close to the interval (%'ull ns)"),
4092 pThis->cNsHeartbeatTimeout, pThis->cNsHeartbeatInterval);
4093
4094#ifndef VBOX_WITHOUT_TESTING_FEATURES
4095 rc = CFGMR3QueryBoolDef(pCfg, "TestingEnabled", &pThis->fTestingEnabled, false);
4096 if (RT_FAILURE(rc))
4097 return PDMDEV_SET_ERROR(pDevIns, rc,
4098 N_("Configuration error: Failed querying \"TestingEnabled\" as a boolean"));
4099 rc = CFGMR3QueryBoolDef(pCfg, "TestingMMIO", &pThis->fTestingMMIO, false);
4100 if (RT_FAILURE(rc))
4101 return PDMDEV_SET_ERROR(pDevIns, rc,
4102 N_("Configuration error: Failed querying \"TestingMMIO\" as a boolean"));
4103 rc = CFGMR3QueryStringAllocDef(pCfg, "TestintXmlOutputFile", &pThis->pszTestingXmlOutput, NULL);
4104 if (RT_FAILURE(rc))
4105 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed querying \"TestintXmlOutputFile\" as a string"));
4106
4107 /** @todo image-to-load-filename? */
4108#endif
4109
4110 pThis->cbGuestRAM = MMR3PhysGetRamSize(PDMDevHlpGetVM(pDevIns));
4111
4112 /*
4113 * We do our own locking entirely. So, install NOP critsect for the device
4114 * and create our own critsect for use where it really matters (++).
4115 */
4116 rc = PDMDevHlpSetDeviceCritSect(pDevIns, PDMDevHlpCritSectGetNop(pDevIns));
4117 AssertRCReturn(rc, rc);
4118 rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, RT_SRC_POS, "VMMDev#%u", iInstance);
4119 AssertRCReturn(rc, rc);
4120
4121 /*
4122 * Register the backdoor logging port
4123 */
4124 rc = PDMDevHlpIOPortRegister(pDevIns, RTLOG_DEBUG_PORT, 1, NULL, vmmdevBackdoorLog,
4125 NULL, NULL, NULL, "VMMDev backdoor logging");
4126 AssertRCReturn(rc, rc);
4127
4128#ifdef VMMDEV_WITH_ALT_TIMESYNC
4129 /*
4130 * Alternative timesync source.
4131 *
4132 * This was orignally added for creating a simple time sync service in an
4133 * OpenBSD guest without requiring VBoxGuest and VBoxService to be ported
4134 * first. We keep it in case it comes in handy.
4135 */
4136 rc = PDMDevHlpIOPortRegister(pDevIns, 0x505, 1, NULL,
4137 vmmdevAltTimeSyncWrite, vmmdevAltTimeSyncRead,
4138 NULL, NULL, "VMMDev timesync backdoor");
4139 AssertRCReturn(rc, rc);
4140#endif
4141
4142 /*
4143 * Register the PCI device.
4144 */
4145 rc = PDMDevHlpPCIRegister(pDevIns, &pThis->PciDev);
4146 if (RT_FAILURE(rc))
4147 return rc;
4148 if (pThis->PciDev.uDevFn != 32 || iInstance != 0)
4149 Log(("!!WARNING!!: pThis->PciDev.uDevFn=%d (ignore if testcase or no started by Main)\n", pThis->PciDev.uDevFn));
4150 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 0x20, PCI_ADDRESS_SPACE_IO, vmmdevIOPortRegionMap);
4151 if (RT_FAILURE(rc))
4152 return rc;
4153 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 1, VMMDEV_RAM_SIZE, PCI_ADDRESS_SPACE_MEM, vmmdevIORAMRegionMap);
4154 if (RT_FAILURE(rc))
4155 return rc;
4156 if (pThis->fHeapEnabled)
4157 {
4158 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2, VMMDEV_HEAP_SIZE, PCI_ADDRESS_SPACE_MEM_PREFETCH, vmmdevIORAMRegionMap);
4159 if (RT_FAILURE(rc))
4160 return rc;
4161 }
4162
4163 /*
4164 * Allocate and initialize the MMIO2 memory.
4165 */
4166 rc = PDMDevHlpMMIO2Register(pDevIns, &pThis->PciDev, 1 /*iRegion*/, VMMDEV_RAM_SIZE, 0 /*fFlags*/,
4167 (void **)&pThis->pVMMDevRAMR3, "VMMDev");
4168 if (RT_FAILURE(rc))
4169 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
4170 N_("Failed to allocate %u bytes of memory for the VMM device"), VMMDEV_RAM_SIZE);
4171 vmmdevInitRam(pThis);
4172
4173 if (pThis->fHeapEnabled)
4174 {
4175 rc = PDMDevHlpMMIO2Register(pDevIns, &pThis->PciDev, 2 /*iRegion*/, VMMDEV_HEAP_SIZE, 0 /*fFlags*/,
4176 (void **)&pThis->pVMMDevHeapR3, "VMMDev Heap");
4177 if (RT_FAILURE(rc))
4178 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
4179 N_("Failed to allocate %u bytes of memory for the VMM device heap"), PAGE_SIZE);
4180
4181 /* Register the memory area with PDM so HM can access it before it's mapped. */
4182 rc = PDMDevHlpRegisterVMMDevHeap(pDevIns, NIL_RTGCPHYS, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
4183 AssertLogRelRCReturn(rc, rc);
4184 }
4185
4186#ifndef VBOX_WITHOUT_TESTING_FEATURES
4187 /*
4188 * Initialize testing.
4189 */
4190 rc = vmmdevTestingInitialize(pDevIns);
4191 if (RT_FAILURE(rc))
4192 return rc;
4193#endif
4194
4195 /*
4196 * Get the corresponding connector interface
4197 */
4198 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "VMM Driver Port");
4199 if (RT_SUCCESS(rc))
4200 {
4201 pThis->pDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIVMMDEVCONNECTOR);
4202 AssertMsgReturn(pThis->pDrv, ("LUN #0 doesn't have a VMMDev connector interface!\n"), VERR_PDM_MISSING_INTERFACE);
4203#ifdef VBOX_WITH_HGCM
4204 pThis->pHGCMDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIHGCMCONNECTOR);
4205 if (!pThis->pHGCMDrv)
4206 {
4207 Log(("LUN #0 doesn't have a HGCM connector interface, HGCM is not supported. rc=%Rrc\n", rc));
4208 /* this is not actually an error, just means that there is no support for HGCM */
4209 }
4210#endif
4211 /* Query the initial balloon size. */
4212 AssertPtr(pThis->pDrv->pfnQueryBalloonSize);
4213 rc = pThis->pDrv->pfnQueryBalloonSize(pThis->pDrv, &pThis->cMbMemoryBalloon);
4214 AssertRC(rc);
4215
4216 Log(("Initial balloon size %x\n", pThis->cMbMemoryBalloon));
4217 }
4218 else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
4219 {
4220 Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
4221 rc = VINF_SUCCESS;
4222 }
4223 else
4224 AssertMsgFailedReturn(("Failed to attach LUN #0! rc=%Rrc\n", rc), rc);
4225
4226 /*
4227 * Attach status driver for shared folders (optional).
4228 */
4229 PPDMIBASE pBase;
4230 rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
4231 if (RT_SUCCESS(rc))
4232 pThis->SharedFolders.pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
4233 else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
4234 {
4235 AssertMsgFailed(("Failed to attach to status driver. rc=%Rrc\n", rc));
4236 return rc;
4237 }
4238
4239 /*
4240 * Register saved state and init the HGCM CmdList critsect.
4241 */
4242 rc = PDMDevHlpSSMRegisterEx(pDevIns, VMMDEV_SAVED_STATE_VERSION, sizeof(*pThis), NULL,
4243 NULL, vmmdevLiveExec, NULL,
4244 NULL, vmmdevSaveExec, NULL,
4245 NULL, vmmdevLoadExec, vmmdevLoadStateDone);
4246 AssertRCReturn(rc, rc);
4247
4248 /*
4249 * Create heartbeat checking timer.
4250 */
4251 rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vmmDevHeartbeatFlatlinedTimer, pThis,
4252 TMTIMER_FLAGS_NO_CRIT_SECT, "Heartbeat flatlined", &pThis->pFlatlinedTimer);
4253 AssertRCReturn(rc, rc);
4254
4255#ifdef VBOX_WITH_HGCM
4256 RTListInit(&pThis->listHGCMCmd);
4257 rc = RTCritSectInit(&pThis->critsectHGCMCmdList);
4258 AssertRCReturn(rc, rc);
4259 pThis->u32HGCMEnabled = 0;
4260#endif /* VBOX_WITH_HGCM */
4261
4262 /*
4263 * In this version of VirtualBox the GUI checks whether "needs host cursor"
4264 * changes.
4265 */
4266 pThis->mouseCapabilities |= VMMDEV_MOUSE_HOST_RECHECKS_NEEDS_HOST_CURSOR;
4267
4268 PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatMemBalloonChunks, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT, "Memory balloon size", "/Devices/VMMDev/BalloonChunks");
4269
4270 /*
4271 * Generate a unique session id for this VM; it will be changed for each
4272 * start, reset or restore. This can be used for restore detection inside
4273 * the guest.
4274 */
4275 pThis->idSession = ASMReadTSC();
4276 return rc;
4277}
4278
4279/**
4280 * The device registration structure.
4281 */
4282extern "C" const PDMDEVREG g_DeviceVMMDev =
4283{
4284 /* u32Version */
4285 PDM_DEVREG_VERSION,
4286 /* szName */
4287 "VMMDev",
4288 /* szRCMod */
4289 "VBoxDDRC.rc",
4290 /* szR0Mod */
4291 "VBoxDDR0.r0",
4292 /* pszDescription */
4293 "VirtualBox VMM Device\n",
4294 /* fFlags */
4295 PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT | PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT | PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0,
4296 /* fClass */
4297 PDM_DEVREG_CLASS_VMM_DEV,
4298 /* cMaxInstances */
4299 1,
4300 /* cbInstance */
4301 sizeof(VMMDevState),
4302 /* pfnConstruct */
4303 vmmdevConstruct,
4304 /* pfnDestruct */
4305 vmmdevDestruct,
4306 /* pfnRelocate */
4307 vmmdevRelocate,
4308 /* pfnMemSetup */
4309 NULL,
4310 /* pfnPowerOn */
4311 NULL,
4312 /* pfnReset */
4313 vmmdevReset,
4314 /* pfnSuspend */
4315 NULL,
4316 /* pfnResume */
4317 NULL,
4318 /* pfnAttach */
4319 NULL,
4320 /* pfnDetach */
4321 NULL,
4322 /* pfnQueryInterface. */
4323 NULL,
4324 /* pfnInitComplete */
4325 NULL,
4326 /* pfnPowerOff */
4327 NULL,
4328 /* pfnSoftReset */
4329 NULL,
4330 /* u32VersionEnd */
4331 PDM_DEVREG_VERSION
4332};
4333#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
4334
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