VirtualBox

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

Last change on this file since 44723 was 44723, checked in by vboxsync, 12 years ago

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