VirtualBox

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

Last change on this file since 64373 was 64373, checked in by vboxsync, 8 years ago

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