VirtualBox

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

Last change on this file since 30242 was 30141, checked in by vboxsync, 15 years ago

VMMDev: typo when displaying the guest version information 2
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 114.9 KB
Line 
1/* $Id: VMMDev.cpp 30141 2010-06-10 08:12:25Z vboxsync $ */
2/** @file
3 * VMMDev - Guest <-> VMM/Host communication device.
4 */
5
6/*
7 * Copyright (C) 2006-2010 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/* #define LOG_ENABLED */
23/* Enable dev_vmm Log3 statements to get IRQ-related logging. */
24
25#define LOG_GROUP LOG_GROUP_DEV_VMM
26#include <VBox/VMMDev.h>
27#include <VBox/log.h>
28#include <VBox/param.h>
29#include <VBox/mm.h>
30#include <VBox/pgm.h>
31#include <VBox/err.h>
32#include <VBox/vm.h> /* for VM_IS_EMT */
33
34#include <iprt/asm.h>
35#include <iprt/assert.h>
36#include <iprt/buildconfig.h>
37#include <iprt/string.h>
38#include <iprt/time.h>
39#ifndef IN_RC
40# include <iprt/mem.h>
41#endif
42#ifdef IN_RING3
43# include <iprt/uuid.h>
44#endif
45
46#include "VMMDevState.h"
47#ifdef VBOX_WITH_HGCM
48# include "VMMDevHGCM.h"
49#endif
50
51
52/*******************************************************************************
53* Defined Constants And Macros *
54*******************************************************************************/
55#define PCIDEV_2_VMMDEVSTATE(pPciDev) ( (VMMDevState *)(pPciDev) )
56#define VMMDEVSTATE_2_DEVINS(pVMMDevState) ( (pVMMDevState)->pDevIns )
57
58#define VBOX_GUEST_ADDITIONS_VERSION_1_03(s) \
59 ( RT_HIWORD((s)->guestInfo.additionsVersion) == 1 \
60 && RT_LOWORD((s)->guestInfo.additionsVersion) == 3 )
61
62#define VBOX_GUEST_ADDITIONS_VERSION_OK(additionsVersion) \
63 ( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
64 && RT_LOWORD(additionsVersion) <= RT_LOWORD(VMMDEV_VERSION) )
65
66#define VBOX_GUEST_ADDITIONS_VERSION_OLD(additionsVersion) \
67 ( (RT_HIWORD(additionsVersion) < RT_HIWORD(VMMDEV_VERSION) \
68 || ( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
69 && RT_LOWORD(additionsVersion) <= RT_LOWORD(VMMDEV_VERSION) ) )
70
71#define VBOX_GUEST_ADDITIONS_VERSION_TOO_OLD(additionsVersion) \
72 ( RT_HIWORD(additionsVersion) < RT_HIWORD(VMMDEV_VERSION) )
73
74#define VBOX_GUEST_ADDITIONS_VERSION_NEW(additionsVersion) \
75 ( RT_HIWORD(additionsVersion) > RT_HIWORD(VMMDEV_VERSION) \
76 || ( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
77 && RT_LOWORD(additionsVersion) > RT_LOWORD(VMMDEV_VERSION) ) )
78
79/** The saved state version. */
80#define VMMDEV_SAVED_STATE_VERSION 13
81/** The saved state version used by VirtualBox 3.0.
82 * This doesn't have the config part. */
83#define VMMDEV_SAVED_STATE_VERSION_VBOX_30 11
84
85
86#ifndef VBOX_DEVICE_STRUCT_TESTCASE
87
88/* Whenever host wants to inform guest about something
89 * an IRQ notification will be raised.
90 *
91 * VMMDev PDM interface will contain the guest notification method.
92 *
93 * There is a 32 bit event mask which will be read
94 * by guest on an interrupt. A non zero bit in the mask
95 * means that the specific event occurred and requires
96 * processing on guest side.
97 *
98 * After reading the event mask guest must issue a
99 * generic request AcknowlegdeEvents.
100 *
101 * IRQ line is set to 1 (request) if there are unprocessed
102 * events, that is the event mask is not zero.
103 *
104 * After receiving an interrupt and checking event mask,
105 * the guest must process events using the event specific
106 * mechanism.
107 *
108 * That is if mouse capabilities were changed,
109 * guest will use VMMDev_GetMouseStatus generic request.
110 *
111 * Event mask is only a set of flags indicating that guest
112 * must proceed with a procedure.
113 *
114 * Unsupported events are therefore ignored.
115 * The guest additions must inform host which events they
116 * want to receive, to avoid unnecessary IRQ processing.
117 * By default no events are signalled to guest.
118 *
119 * This seems to be fast method. It requires
120 * only one context switch for an event processing.
121 *
122 */
123
124static void vmmdevSetIRQ_Legacy_EMT (VMMDevState *pVMMDevState)
125{
126 if (!pVMMDevState->fu32AdditionsOk)
127 {
128 Log(("vmmdevSetIRQ: IRQ is not generated, guest has not yet reported to us.\n"));
129 return;
130 }
131
132 uint32_t u32IRQLevel = 0;
133
134 /* Filter unsupported events */
135 uint32_t u32EventFlags =
136 pVMMDevState->u32HostEventFlags
137 & pVMMDevState->pVMMDevRAMR3->V.V1_03.u32GuestEventMask;
138
139 Log(("vmmdevSetIRQ: u32EventFlags = 0x%08X, "
140 "pVMMDevState->u32HostEventFlags = 0x%08X, "
141 "pVMMDevState->pVMMDevRAMR3->u32GuestEventMask = 0x%08X\n",
142 u32EventFlags,
143 pVMMDevState->u32HostEventFlags,
144 pVMMDevState->pVMMDevRAMR3->V.V1_03.u32GuestEventMask));
145
146 /* Move event flags to VMMDev RAM */
147 pVMMDevState->pVMMDevRAMR3->V.V1_03.u32HostEvents = u32EventFlags;
148
149 if (u32EventFlags)
150 {
151 /* Clear host flags which will be delivered to guest. */
152 pVMMDevState->u32HostEventFlags &= ~u32EventFlags;
153 Log(("vmmdevSetIRQ: pVMMDevState->u32HostEventFlags = 0x%08X\n",
154 pVMMDevState->u32HostEventFlags));
155 u32IRQLevel = 1;
156 }
157
158 /* Set IRQ level for pin 0 */
159 /** @todo make IRQ pin configurable, at least a symbolic constant */
160 PPDMDEVINS pDevIns = VMMDEVSTATE_2_DEVINS(pVMMDevState);
161 PDMDevHlpPCISetIrqNoWait(pDevIns, 0, u32IRQLevel);
162 Log(("vmmdevSetIRQ: IRQ set %d\n", u32IRQLevel));
163}
164
165static void vmmdevMaybeSetIRQ_EMT (VMMDevState *pVMMDevState)
166{
167 PPDMDEVINS pDevIns = VMMDEVSTATE_2_DEVINS (pVMMDevState);
168
169 Log3(("vmmdevMaybeSetIRQ_EMT: u32HostEventFlags = 0x%08X, u32GuestFilterMask = 0x%08X.\n",
170 pVMMDevState->u32HostEventFlags, pVMMDevState->u32GuestFilterMask));
171
172 if (pVMMDevState->u32HostEventFlags & pVMMDevState->u32GuestFilterMask)
173 {
174 pVMMDevState->pVMMDevRAMR3->V.V1_04.fHaveEvents = true;
175 PDMDevHlpPCISetIrqNoWait (pDevIns, 0, 1);
176 Log3(("vmmdevMaybeSetIRQ_EMT: IRQ set.\n"));
177 }
178}
179
180static void vmmdevNotifyGuest_EMT (VMMDevState *pVMMDevState, uint32_t u32EventMask)
181{
182 Log3(("VMMDevNotifyGuest_EMT: u32EventMask = 0x%08X.\n", u32EventMask));
183
184 if (VBOX_GUEST_ADDITIONS_VERSION_1_03 (pVMMDevState))
185 {
186 Log3(("VMMDevNotifyGuest_EMT: Old additions detected.\n"));
187
188 pVMMDevState->u32HostEventFlags |= u32EventMask;
189 vmmdevSetIRQ_Legacy_EMT (pVMMDevState);
190 }
191 else
192 {
193 Log3(("VMMDevNotifyGuest_EMT: New additions detected.\n"));
194
195 if (!pVMMDevState->fu32AdditionsOk)
196 {
197 pVMMDevState->u32HostEventFlags |= u32EventMask;
198 Log(("vmmdevNotifyGuest_EMT: IRQ is not generated, guest has not yet reported to us.\n"));
199 return;
200 }
201
202 const bool fHadEvents =
203 (pVMMDevState->u32HostEventFlags & pVMMDevState->u32GuestFilterMask) != 0;
204
205 Log3(("VMMDevNotifyGuest_EMT: fHadEvents = %d, u32HostEventFlags = 0x%08X, u32GuestFilterMask = 0x%08X.\n",
206 fHadEvents, pVMMDevState->u32HostEventFlags, pVMMDevState->u32GuestFilterMask));
207
208 pVMMDevState->u32HostEventFlags |= u32EventMask;
209
210 if (!fHadEvents)
211 vmmdevMaybeSetIRQ_EMT (pVMMDevState);
212 }
213}
214
215void VMMDevCtlSetGuestFilterMask (VMMDevState *pVMMDevState,
216 uint32_t u32OrMask,
217 uint32_t u32NotMask)
218{
219 PDMCritSectEnter(&pVMMDevState->CritSect, VERR_SEM_BUSY);
220
221 const bool fHadEvents =
222 (pVMMDevState->u32HostEventFlags & pVMMDevState->u32GuestFilterMask) != 0;
223
224 Log(("VMMDevCtlSetGuestFilterMask: u32OrMask = 0x%08X, u32NotMask = 0x%08X, fHadEvents = %d.\n", u32OrMask, u32NotMask, fHadEvents));
225 if (fHadEvents)
226 {
227 if (!pVMMDevState->fNewGuestFilterMask)
228 pVMMDevState->u32NewGuestFilterMask = pVMMDevState->u32GuestFilterMask;
229
230 pVMMDevState->u32NewGuestFilterMask |= u32OrMask;
231 pVMMDevState->u32NewGuestFilterMask &= ~u32NotMask;
232 pVMMDevState->fNewGuestFilterMask = true;
233 }
234 else
235 {
236 pVMMDevState->u32GuestFilterMask |= u32OrMask;
237 pVMMDevState->u32GuestFilterMask &= ~u32NotMask;
238 vmmdevMaybeSetIRQ_EMT (pVMMDevState);
239 }
240 PDMCritSectLeave(&pVMMDevState->CritSect);
241}
242
243void VMMDevNotifyGuest (VMMDevState *pVMMDevState, uint32_t u32EventMask)
244{
245 PPDMDEVINS pDevIns = VMMDEVSTATE_2_DEVINS(pVMMDevState);
246
247 Log3(("VMMDevNotifyGuest: u32EventMask = 0x%08X.\n", u32EventMask));
248
249 /*
250 * Drop notifications if the VM is not running yet/anymore.
251 */
252 VMSTATE enmVMState = PDMDevHlpVMState(pDevIns);
253 if ( enmVMState != VMSTATE_RUNNING
254 && enmVMState != VMSTATE_RUNNING_LS)
255 return;
256
257 PDMCritSectEnter(&pVMMDevState->CritSect, VERR_SEM_BUSY);
258 /* No need to wait for the completion of this request. It is a notification
259 * about something, which has already happened.
260 */
261 vmmdevNotifyGuest_EMT(pVMMDevState, u32EventMask);
262 PDMCritSectLeave(&pVMMDevState->CritSect);
263}
264
265/**
266 * Port I/O Handler for OUT operations.
267 *
268 * @returns VBox status code.
269 *
270 * @param pDevIns The device instance.
271 * @param pvUser User argument - ignored.
272 * @param uPort Port number used for the IN operation.
273 * @param u32 The value to output.
274 * @param cb The value size in bytes.
275 */
276static DECLCALLBACK(int) vmmdevBackdoorLog(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
277{
278 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
279
280 if (!pThis->fBackdoorLogDisabled && cb == 1 && Port == RTLOG_DEBUG_PORT)
281 {
282
283 /* The raw version. */
284 switch (u32)
285 {
286 case '\r': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <return>\n")); break;
287 case '\n': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <newline>\n")); break;
288 case '\t': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <tab>\n")); break;
289 default: LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: %c (%02x)\n", u32, u32)); break;
290 }
291
292 /* The readable, buffered version. */
293 if (u32 == '\n' || u32 == '\r')
294 {
295 pThis->szMsg[pThis->iMsg] = '\0';
296 if (pThis->iMsg)
297 LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("Guest Log: %s\n", pThis->szMsg));
298 pThis->iMsg = 0;
299 }
300 else
301 {
302 if (pThis->iMsg >= sizeof(pThis->szMsg)-1)
303 {
304 pThis->szMsg[pThis->iMsg] = '\0';
305 LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("Guest Log: %s\n", pThis->szMsg));
306 pThis->iMsg = 0;
307 }
308 pThis->szMsg[pThis->iMsg] = (char )u32;
309 pThis->szMsg[++pThis->iMsg] = '\0';
310 }
311 }
312 return VINF_SUCCESS;
313}
314
315#ifdef TIMESYNC_BACKDOOR
316/**
317 * Port I/O Handler for OUT operations.
318 *
319 * @returns VBox status code.
320 *
321 * @param pDevIns The device instance.
322 * @param pvUser User argument - ignored.
323 * @param uPort Port number used for the IN operation.
324 * @param u32 The value to output.
325 * @param cb The value size in bytes.
326 */
327static DECLCALLBACK(int) vmmdevTimesyncBackdoorWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
328{
329 NOREF(pvUser);
330 if (cb == 4)
331 {
332 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
333 switch (u32)
334 {
335 case 0:
336 pThis->fTimesyncBackdoorLo = false;
337 break;
338 case 1:
339 pThis->fTimesyncBackdoorLo = true;
340 }
341 return VINF_SUCCESS;
342
343 }
344 return VINF_SUCCESS;
345}
346
347/**
348 * Port I/O Handler for backdoor timesync IN operations.
349 *
350 * @returns VBox status code.
351 *
352 * @param pDevIns The device instance.
353 * @param pvUser User argument - ignored.
354 * @param uPort Port number used for the IN operation.
355 * @param pu32 Where to store the result.
356 * @param cb Number of bytes read.
357 */
358static DECLCALLBACK(int) vmmdevTimesyncBackdoorRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
359{
360 int rc;
361 NOREF(pvUser);
362 if (cb == 4)
363 {
364 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
365 RTTIMESPEC now;
366
367 if (pThis->fTimesyncBackdoorLo)
368 *pu32 = (uint32_t)pThis->hostTime;
369 else
370 {
371 pThis->hostTime = RTTimeSpecGetMilli(PDMDevHlpTMUtcNow(pDevIns, &now));
372 *pu32 = (uint32_t)(pThis->hostTime >> 32);
373 }
374 rc = VINF_SUCCESS;
375 }
376 else
377 rc = VERR_IOM_IOPORT_UNUSED;
378 return rc;
379}
380#endif /* TIMESYNC_BACKDOOR */
381
382/**
383 * Port I/O Handler for the generic request interface
384 * @see FNIOMIOPORTOUT for details.
385 *
386 * @todo Too long, suggest doing the request copying here and moving the
387 * switch into a different function (or better case -> functions), and
388 * looing the gotos.
389 */
390static DECLCALLBACK(int) vmmdevRequestHandler(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
391{
392 VMMDevState *pThis = (VMMDevState*)pvUser;
393 int rcRet = VINF_SUCCESS;
394 PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
395
396 /*
397 * The caller has passed the guest context physical address
398 * of the request structure. Copy the request packet.
399 */
400 VMMDevRequestHeader *pRequestHeader = NULL;
401 VMMDevRequestHeader requestHeader;
402 RT_ZERO(requestHeader);
403
404 PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
405
406 /* the structure size must be greater or equal to the header size */
407 if (requestHeader.size < sizeof(VMMDevRequestHeader))
408 {
409 Log(("VMMDev request header size too small! size = %d\n", requestHeader.size));
410 rcRet = VINF_SUCCESS;
411 goto end; /** @todo shouldn't (/ no need to) write back.*/
412 }
413
414 /* check the version of the header structure */
415 if (requestHeader.version != VMMDEV_REQUEST_HEADER_VERSION)
416 {
417 Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader.version, VMMDEV_REQUEST_HEADER_VERSION));
418 rcRet = VINF_SUCCESS;
419 goto end; /** @todo shouldn't (/ no need to) write back.*/
420 }
421
422 Log2(("VMMDev request issued: %d\n", requestHeader.requestType));
423
424 if ( requestHeader.requestType != VMMDevReq_ReportGuestInfo
425 && !pThis->fu32AdditionsOk)
426 {
427 Log(("VMMDev: guest has not yet reported to us. Refusing operation.\n"));
428 requestHeader.rc = VERR_NOT_SUPPORTED;
429 rcRet = VINF_SUCCESS;
430 goto end;
431 }
432
433 /* Check upper limit */
434 if (requestHeader.size > VMMDEV_MAX_VMMDEVREQ_SIZE)
435 {
436 LogRel(("VMMDev: request packet too big (%x). Refusing operation.\n", requestHeader.size));
437 requestHeader.rc = VERR_NOT_SUPPORTED;
438 rcRet = VINF_SUCCESS;
439 goto end;
440 }
441
442 /* Read the entire request packet */
443 pRequestHeader = (VMMDevRequestHeader *)RTMemAlloc(requestHeader.size);
444 if (!pRequestHeader)
445 {
446 Log(("VMMDev: RTMemAlloc failed!\n"));
447 rcRet = VINF_SUCCESS;
448 requestHeader.rc = VERR_NO_MEMORY;
449 goto end;
450 }
451 PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, pRequestHeader, requestHeader.size);
452
453 /* which request was sent? */
454 switch (pRequestHeader->requestType)
455 {
456 /*
457 * Guest wants to give up a timeslice
458 */
459 case VMMDevReq_Idle:
460 {
461 /* just return to EMT telling it that we want to halt */
462 rcRet = VINF_EM_HALT;
463 break;
464 }
465
466 /*
467 * Guest is reporting its information
468 */
469 case VMMDevReq_ReportGuestInfo:
470 {
471 if (pRequestHeader->size < sizeof(VMMDevReportGuestInfo))
472 {
473 AssertMsgFailed(("VMMDev guest information structure has an invalid size!\n"));
474 pRequestHeader->rc = VERR_INVALID_PARAMETER;
475 }
476 else
477 {
478 VBoxGuestInfo *guestInfo = &((VMMDevReportGuestInfo*)pRequestHeader)->guestInfo;
479
480 if (memcmp (&pThis->guestInfo, guestInfo, sizeof(*guestInfo)) != 0)
481 {
482 /* make a copy of supplied information */
483 pThis->guestInfo = *guestInfo;
484
485 /* Check additions version */
486 pThis->fu32AdditionsOk = VBOX_GUEST_ADDITIONS_VERSION_OK(pThis->guestInfo.additionsVersion);
487
488 LogRel(("Guest Additions information report: Interface = 0x%08X osType = 0x%08X\n",
489 pThis->guestInfo.additionsVersion,
490 pThis->guestInfo.osType));
491 pThis->pDrv->pfnUpdateGuestVersion(pThis->pDrv, &pThis->guestInfo);
492 }
493
494 if (pThis->fu32AdditionsOk)
495 {
496 pRequestHeader->rc = VINF_SUCCESS;
497 }
498 else
499 {
500 pRequestHeader->rc = VERR_VERSION_MISMATCH;
501 }
502 }
503 break;
504 }
505
506 case VMMDevReq_ReportGuestInfo2:
507 {
508 if (pRequestHeader->size < sizeof(VMMDevReportGuestInfo2))
509 {
510 AssertMsgFailed(("VMMDev guest information 2 structure has an invalid size!\n"));
511 pRequestHeader->rc = VERR_INVALID_PARAMETER;
512 }
513 else
514 {
515 VBoxGuestInfo2 *guestInfo2 = &((VMMDevReportGuestInfo2*)pRequestHeader)->guestInfo;
516 LogRel(("Guest Additions information report: Version %d.%d.%d r%d '%.*s'\n",
517 guestInfo2->additionsMajor, guestInfo2->additionsMinor, guestInfo2->additionsBuild,
518 guestInfo2->additionsRevision, sizeof(guestInfo2->szName), guestInfo2->szName));
519 pRequestHeader->rc = VINF_SUCCESS;
520 }
521 break;
522 }
523
524 /* Report guest capabilities */
525 case VMMDevReq_ReportGuestCapabilities:
526 {
527 if (pRequestHeader->size != sizeof(VMMDevReqGuestCapabilities))
528 {
529 AssertMsgFailed(("VMMDev guest caps structure has invalid size!\n"));
530 pRequestHeader->rc = VERR_INVALID_PARAMETER;
531 }
532 else
533 {
534 VMMDevReqGuestCapabilities *guestCaps = (VMMDevReqGuestCapabilities*)pRequestHeader;
535
536 /* Enable this automatically for guests using the old
537 request to report their capabilities. */
538 /** @todo change this when we next bump the interface version */
539 guestCaps->caps |= VMMDEV_GUEST_SUPPORTS_GRAPHICS;
540 if (pThis->guestCaps != guestCaps->caps)
541 {
542 /* make a copy of supplied information */
543 pThis->guestCaps = guestCaps->caps;
544
545 LogRel(("Guest Additions capability report: (0x%x) "
546 "seamless: %s, "
547 "hostWindowMapping: %s, "
548 "graphics: %s\n",
549 guestCaps->caps,
550 guestCaps->caps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
551 guestCaps->caps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no",
552 guestCaps->caps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? "yes" : "no"));
553
554 pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, guestCaps->caps);
555 }
556 pRequestHeader->rc = VINF_SUCCESS;
557 }
558 break;
559 }
560
561 /* Change guest capabilities */
562 case VMMDevReq_SetGuestCapabilities:
563 {
564 if (pRequestHeader->size != sizeof(VMMDevReqGuestCapabilities2))
565 {
566 AssertMsgFailed(("VMMDev guest caps structure has invalid size!\n"));
567 pRequestHeader->rc = VERR_INVALID_PARAMETER;
568 }
569 else
570 {
571 VMMDevReqGuestCapabilities2 *guestCaps = (VMMDevReqGuestCapabilities2*)pRequestHeader;
572
573 pThis->guestCaps |= guestCaps->u32OrMask;
574 pThis->guestCaps &= ~guestCaps->u32NotMask;
575
576 LogRel(("Guest Additions capability report: (0x%x) "
577 "seamless: %s, "
578 "hostWindowMapping: %s, "
579 "graphics: %s\n",
580 pThis->guestCaps,
581 pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
582 pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no",
583 pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? "yes" : "no"));
584
585 pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
586 pRequestHeader->rc = VINF_SUCCESS;
587 }
588 break;
589 }
590
591 /*
592 * Retrieve mouse information
593 */
594 case VMMDevReq_GetMouseStatus:
595 {
596 if (pRequestHeader->size != sizeof(VMMDevReqMouseStatus))
597 {
598 AssertMsgFailed(("VMMDev mouse status structure has invalid size!\n"));
599 pRequestHeader->rc = VERR_INVALID_PARAMETER;
600 }
601 else
602 {
603 VMMDevReqMouseStatus *mouseStatus = (VMMDevReqMouseStatus*)pRequestHeader;
604 mouseStatus->mouseFeatures = pThis->mouseCapabilities
605 & VMMDEV_MOUSE_MASK;
606 mouseStatus->pointerXPos = pThis->mouseXAbs;
607 mouseStatus->pointerYPos = pThis->mouseYAbs;
608 LogRel2(("%s: VMMDevReq_GetMouseStatus: features = 0x%x, absX = %d, absY = %d\n",
609 __PRETTY_FUNCTION__,
610 mouseStatus->mouseFeatures,
611 mouseStatus->pointerXPos,
612 mouseStatus->pointerYPos));
613 pRequestHeader->rc = VINF_SUCCESS;
614 }
615 break;
616 }
617
618 /*
619 * Set mouse information
620 */
621 case VMMDevReq_SetMouseStatus:
622 {
623 if (pRequestHeader->size != sizeof(VMMDevReqMouseStatus))
624 {
625 AssertMsgFailed(("VMMDev mouse status structure has invalid size %d (%#x) version=%d!\n",
626 pRequestHeader->size, pRequestHeader->size, pRequestHeader->size, pRequestHeader->version));
627 pRequestHeader->rc = VERR_INVALID_PARAMETER;
628 }
629 else
630 {
631 bool fNotify = false;
632
633 uint32_t fFeatures =
634 ((VMMDevReqMouseStatus*)pRequestHeader)->mouseFeatures;
635
636 LogRelFlowFunc(("VMMDevReqMouseStatus: mouseFeatures = 0x%x\n",
637 fFeatures));
638
639 if ( (fFeatures & VMMDEV_MOUSE_NOTIFY_HOST_MASK)
640 != ( pThis->mouseCapabilities
641 & VMMDEV_MOUSE_NOTIFY_HOST_MASK))
642 fNotify = true;
643 pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_MASK;
644 pThis->mouseCapabilities |=
645 (fFeatures & VMMDEV_MOUSE_GUEST_MASK);
646 LogRelFlowFunc(("VMMDevReq_SetMouseStatus: new host capabilities: 0x%x\n",
647 pThis->mouseCapabilities));
648
649 /*
650 * Notify connector if something has changed
651 */
652 if (fNotify)
653 {
654 LogRelFlowFunc(("VMMDevReq_SetMouseStatus: notifying connector\n"));
655 pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
656 }
657 pRequestHeader->rc = VINF_SUCCESS;
658 }
659
660 break;
661 }
662
663 /*
664 * Set a new mouse pointer shape
665 */
666 case VMMDevReq_SetPointerShape:
667 {
668 if (pRequestHeader->size < sizeof(VMMDevReqMousePointer))
669 {
670 AssertMsg(pRequestHeader->size == 0x10028 && pRequestHeader->version == 10000, /* don't bitch about legacy!!! */
671 ("VMMDev mouse shape structure has invalid size %d (%#x) version=%d!\n",
672 pRequestHeader->size, pRequestHeader->size, pRequestHeader->size, pRequestHeader->version));
673 pRequestHeader->rc = VERR_INVALID_PARAMETER;
674 }
675 else
676 {
677 VMMDevReqMousePointer *pointerShape = (VMMDevReqMousePointer*)pRequestHeader;
678
679 bool fVisible = (pointerShape->fFlags & VBOX_MOUSE_POINTER_VISIBLE) != 0;
680 bool fAlpha = (pointerShape->fFlags & VBOX_MOUSE_POINTER_ALPHA) != 0;
681 bool fShape = (pointerShape->fFlags & VBOX_MOUSE_POINTER_SHAPE) != 0;
682
683 Log(("VMMDevReq_SetPointerShape: visible: %d, alpha: %d, shape = %d, width: %d, height: %d\n",
684 fVisible, fAlpha, fShape, pointerShape->width, pointerShape->height));
685
686 if (pRequestHeader->size == sizeof(VMMDevReqMousePointer))
687 {
688 /* The guest did not provide the shape actually. */
689 fShape = false;
690 }
691
692 /* forward call to driver */
693 if (fShape)
694 {
695 pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
696 fVisible,
697 fAlpha,
698 pointerShape->xHot, pointerShape->yHot,
699 pointerShape->width, pointerShape->height,
700 pointerShape->pointerData);
701 }
702 else
703 {
704 pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
705 fVisible,
706 0,
707 0, 0,
708 0, 0,
709 NULL);
710 }
711 pThis->fHostCursorRequested = fVisible;
712 pRequestHeader->rc = VINF_SUCCESS;
713 }
714 break;
715 }
716
717 /*
718 * Query the system time from the host
719 */
720 case VMMDevReq_GetHostTime:
721 {
722 if (pRequestHeader->size != sizeof(VMMDevReqHostTime))
723 {
724 AssertMsgFailed(("VMMDev host time structure has invalid size!\n"));
725 pRequestHeader->rc = VERR_INVALID_PARAMETER;
726 }
727 else if (RT_UNLIKELY(pThis->fGetHostTimeDisabled))
728 pRequestHeader->rc = VERR_NOT_SUPPORTED;
729 else
730 {
731 VMMDevReqHostTime *hostTimeReq = (VMMDevReqHostTime*)pRequestHeader;
732 RTTIMESPEC now;
733 hostTimeReq->time = RTTimeSpecGetMilli(PDMDevHlpTMUtcNow(pDevIns, &now));
734 pRequestHeader->rc = VINF_SUCCESS;
735 }
736 break;
737 }
738
739 /*
740 * Query information about the hypervisor
741 */
742 case VMMDevReq_GetHypervisorInfo:
743 {
744 if (pRequestHeader->size != sizeof(VMMDevReqHypervisorInfo))
745 {
746 AssertMsgFailed(("VMMDev hypervisor info structure has invalid size!\n"));
747 pRequestHeader->rc = VERR_INVALID_PARAMETER;
748 }
749 else
750 {
751 VMMDevReqHypervisorInfo *hypervisorInfo = (VMMDevReqHypervisorInfo*)pRequestHeader;
752 PVM pVM = PDMDevHlpGetVM(pDevIns);
753 pRequestHeader->rc = PGMR3MappingsSize(pVM, &hypervisorInfo->hypervisorSize);
754 }
755 break;
756 }
757
758 /*
759 * Set hypervisor information
760 */
761 case VMMDevReq_SetHypervisorInfo:
762 {
763 if (pRequestHeader->size != sizeof(VMMDevReqHypervisorInfo))
764 {
765 AssertMsgFailed(("VMMDev hypervisor info structure has invalid size!\n"));
766 pRequestHeader->rc = VERR_INVALID_PARAMETER;
767 }
768 else
769 {
770 VMMDevReqHypervisorInfo *hypervisorInfo = (VMMDevReqHypervisorInfo*)pRequestHeader;
771 PVM pVM = PDMDevHlpGetVM(pDevIns);
772 if (hypervisorInfo->hypervisorStart == 0)
773 pRequestHeader->rc = PGMR3MappingsUnfix(pVM);
774 else
775 {
776 /* only if the client has queried the size before! */
777 uint32_t mappingsSize;
778 pRequestHeader->rc = PGMR3MappingsSize(pVM, &mappingsSize);
779 if (RT_SUCCESS(pRequestHeader->rc) && hypervisorInfo->hypervisorSize == mappingsSize)
780 {
781 /* new reservation */
782 pRequestHeader->rc = PGMR3MappingsFix(pVM, hypervisorInfo->hypervisorStart,
783 hypervisorInfo->hypervisorSize);
784 LogRel(("Guest reported fixed hypervisor window at 0x%p (size = 0x%x, rc = %Rrc)\n",
785 (uintptr_t)hypervisorInfo->hypervisorStart,
786 hypervisorInfo->hypervisorSize,
787 pRequestHeader->rc));
788 }
789 }
790 }
791 break;
792 }
793
794 case VMMDevReq_RegisterPatchMemory:
795 {
796 if (pRequestHeader->size != sizeof(VMMDevReqPatchMemory))
797 {
798 AssertMsgFailed(("VMMDevReq_RegisterPatchMemory structure has invalid size!\n"));
799 pRequestHeader->rc = VERR_INVALID_PARAMETER;
800 }
801 else
802 {
803 VMMDevReqPatchMemory *pPatchRequest = (VMMDevReqPatchMemory*)pRequestHeader;
804
805 pRequestHeader->rc = VMMR3RegisterPatchMemory(PDMDevHlpGetVM(pDevIns), pPatchRequest->pPatchMem, pPatchRequest->cbPatchMem);
806 }
807 break;
808 }
809
810 case VMMDevReq_DeregisterPatchMemory:
811 {
812 if (pRequestHeader->size != sizeof(VMMDevReqPatchMemory))
813 {
814 AssertMsgFailed(("VMMDevReq_DeregisterPatchMemory structure has invalid size!\n"));
815 pRequestHeader->rc = VERR_INVALID_PARAMETER;
816 }
817 else
818 {
819 VMMDevReqPatchMemory *pPatchRequest = (VMMDevReqPatchMemory*)pRequestHeader;
820
821 pRequestHeader->rc = VMMR3DeregisterPatchMemory(PDMDevHlpGetVM(pDevIns), pPatchRequest->pPatchMem, pPatchRequest->cbPatchMem);
822 }
823 break;
824 }
825
826 /*
827 * Set the system power status
828 */
829 case VMMDevReq_SetPowerStatus:
830 {
831 if (pRequestHeader->size != sizeof(VMMDevPowerStateRequest))
832 {
833 AssertMsgFailed(("VMMDev power state request structure has invalid size!\n"));
834 pRequestHeader->rc = VERR_INVALID_PARAMETER;
835 }
836 else
837 {
838 VMMDevPowerStateRequest *powerStateRequest = (VMMDevPowerStateRequest*)pRequestHeader;
839 switch(powerStateRequest->powerState)
840 {
841 case VMMDevPowerState_Pause:
842 {
843 LogRel(("Guest requests the VM to be suspended (paused)\n"));
844 pRequestHeader->rc = rcRet = PDMDevHlpVMSuspend(pDevIns);
845 break;
846 }
847
848 case VMMDevPowerState_PowerOff:
849 {
850 LogRel(("Guest requests the VM to be turned off\n"));
851 pRequestHeader->rc = rcRet = PDMDevHlpVMPowerOff(pDevIns);
852 break;
853 }
854
855 case VMMDevPowerState_SaveState:
856 {
857 /** @todo no API for that yet */
858 pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
859 break;
860 }
861
862 default:
863 AssertMsgFailed(("VMMDev invalid power state request: %d\n", powerStateRequest->powerState));
864 pRequestHeader->rc = VERR_INVALID_PARAMETER;
865 break;
866 }
867 }
868 break;
869 }
870
871 /*
872 * Get display change request
873 */
874 case VMMDevReq_GetDisplayChangeRequest:
875 {
876 if (pRequestHeader->size != sizeof(VMMDevDisplayChangeRequest))
877 {
878 /* Assert only if the size also not equal to a previous version size to prevent
879 * assertion with old additions.
880 */
881 AssertMsg(pRequestHeader->size == sizeof(VMMDevDisplayChangeRequest) - sizeof (uint32_t),
882 ("VMMDev display change request structure has invalid size!\n"));
883 pRequestHeader->rc = VERR_INVALID_PARAMETER;
884 }
885 else
886 {
887 VMMDevDisplayChangeRequest *displayChangeRequest = (VMMDevDisplayChangeRequest*)pRequestHeader;
888
889 DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[0];
890
891 if (displayChangeRequest->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
892 {
893 /* Current request has been read at least once. */
894 pRequest->fPending = false;
895
896 /* Check if there are more pending requests. */
897 for (unsigned i = 1; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
898 {
899 if (pThis->displayChangeData.aRequests[i].fPending)
900 {
901 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
902 break;
903 }
904 }
905
906 /* Remember which resolution the client has queried, subsequent reads
907 * will return the same values. */
908 pRequest->lastReadDisplayChangeRequest = pRequest->displayChangeRequest;
909 pThis->displayChangeData.fGuestSentChangeEventAck = true;
910 }
911
912 if (pThis->displayChangeData.fGuestSentChangeEventAck)
913 {
914 displayChangeRequest->xres = pRequest->lastReadDisplayChangeRequest.xres;
915 displayChangeRequest->yres = pRequest->lastReadDisplayChangeRequest.yres;
916 displayChangeRequest->bpp = pRequest->lastReadDisplayChangeRequest.bpp;
917 }
918 else
919 {
920 /* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
921 * read the last valid video mode hint. This happens when the guest X server
922 * determines the initial mode. */
923 displayChangeRequest->xres = pRequest->displayChangeRequest.xres;
924 displayChangeRequest->yres = pRequest->displayChangeRequest.yres;
925 displayChangeRequest->bpp = pRequest->displayChangeRequest.bpp;
926 }
927 Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d\n",
928 displayChangeRequest->xres, displayChangeRequest->yres, displayChangeRequest->bpp));
929
930 pRequestHeader->rc = VINF_SUCCESS;
931 }
932 break;
933 }
934
935 case VMMDevReq_GetDisplayChangeRequest2:
936 {
937 if (pRequestHeader->size != sizeof(VMMDevDisplayChangeRequest2))
938 {
939 pRequestHeader->rc = VERR_INVALID_PARAMETER;
940 }
941 else
942 {
943 VMMDevDisplayChangeRequest2 *displayChangeRequest = (VMMDevDisplayChangeRequest2*)pRequestHeader;
944
945 DISPLAYCHANGEREQUEST *pRequest = NULL;
946
947 if (displayChangeRequest->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
948 {
949 /* Select a pending request to report. */
950 unsigned i;
951 for (i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
952 {
953 if (pThis->displayChangeData.aRequests[i].fPending)
954 {
955 pRequest = &pThis->displayChangeData.aRequests[i];
956 /* Remember which request should be reported. */
957 pThis->displayChangeData.iCurrentMonitor = i;
958 Log3(("VMMDev: will report pending request for %d\n",
959 i));
960 break;
961 }
962 }
963
964 /* Check if there are more pending requests. */
965 i++;
966 for (; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
967 {
968 if (pThis->displayChangeData.aRequests[i].fPending)
969 {
970 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
971 Log3(("VMMDev: another pending at %d\n",
972 i));
973 break;
974 }
975 }
976
977 if (pRequest)
978 {
979 /* Current request has been read at least once. */
980 pRequest->fPending = false;
981
982 /* Remember which resolution the client has queried, subsequent reads
983 * will return the same values. */
984 pRequest->lastReadDisplayChangeRequest = pRequest->displayChangeRequest;
985 pThis->displayChangeData.fGuestSentChangeEventAck = true;
986 }
987 else
988 {
989 Log3(("VMMDev: no pending request!!!\n"));
990 }
991 }
992
993 if (!pRequest)
994 {
995 Log3(("VMMDev: default to %d\n",
996 pThis->displayChangeData.iCurrentMonitor));
997 pRequest = &pThis->displayChangeData.aRequests[pThis->displayChangeData.iCurrentMonitor];
998 }
999
1000 if (pThis->displayChangeData.fGuestSentChangeEventAck)
1001 {
1002 displayChangeRequest->xres = pRequest->lastReadDisplayChangeRequest.xres;
1003 displayChangeRequest->yres = pRequest->lastReadDisplayChangeRequest.yres;
1004 displayChangeRequest->bpp = pRequest->lastReadDisplayChangeRequest.bpp;
1005 displayChangeRequest->display = pRequest->lastReadDisplayChangeRequest.display;
1006 }
1007 else
1008 {
1009 /* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
1010 * read the last valid video mode hint. This happens when the guest X server
1011 * determines the initial video mode. */
1012 displayChangeRequest->xres = pRequest->displayChangeRequest.xres;
1013 displayChangeRequest->yres = pRequest->displayChangeRequest.yres;
1014 displayChangeRequest->bpp = pRequest->displayChangeRequest.bpp;
1015 displayChangeRequest->display = pRequest->displayChangeRequest.display;
1016 }
1017 Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d at %d\n",
1018 displayChangeRequest->xres, displayChangeRequest->yres, displayChangeRequest->bpp, displayChangeRequest->display));
1019
1020 pRequestHeader->rc = VINF_SUCCESS;
1021 }
1022 break;
1023 }
1024
1025 /*
1026 * Query whether the given video mode is supported
1027 */
1028 case VMMDevReq_VideoModeSupported:
1029 {
1030 if (pRequestHeader->size != sizeof(VMMDevVideoModeSupportedRequest))
1031 {
1032 AssertMsgFailed(("VMMDev video mode supported request structure has invalid size!\n"));
1033 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1034 }
1035 else
1036 {
1037 VMMDevVideoModeSupportedRequest *videoModeSupportedRequest = (VMMDevVideoModeSupportedRequest*)pRequestHeader;
1038 /* forward the call */
1039 pRequestHeader->rc = pThis->pDrv->pfnVideoModeSupported(pThis->pDrv,
1040 0, /* primary screen. */
1041 videoModeSupportedRequest->width,
1042 videoModeSupportedRequest->height,
1043 videoModeSupportedRequest->bpp,
1044 &videoModeSupportedRequest->fSupported);
1045 }
1046 break;
1047 }
1048
1049 /*
1050 * Query whether the given video mode is supported for a specific display
1051 */
1052 case VMMDevReq_VideoModeSupported2:
1053 {
1054 if (pRequestHeader->size != sizeof(VMMDevVideoModeSupportedRequest2))
1055 {
1056 AssertMsgFailed(("VMMDev video mode supported request 2 structure has invalid size!\n"));
1057 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1058 }
1059 else
1060 {
1061 VMMDevVideoModeSupportedRequest2 *videoModeSupportedRequest2 = (VMMDevVideoModeSupportedRequest2*)pRequestHeader;
1062 /* forward the call */
1063 pRequestHeader->rc = pThis->pDrv->pfnVideoModeSupported(pThis->pDrv,
1064 videoModeSupportedRequest2->display,
1065 videoModeSupportedRequest2->width,
1066 videoModeSupportedRequest2->height,
1067 videoModeSupportedRequest2->bpp,
1068 &videoModeSupportedRequest2->fSupported);
1069 }
1070 break;
1071 }
1072
1073 /*
1074 * Query the height reduction in pixels
1075 */
1076 case VMMDevReq_GetHeightReduction:
1077 {
1078 if (pRequestHeader->size != sizeof(VMMDevGetHeightReductionRequest))
1079 {
1080 AssertMsgFailed(("VMMDev height reduction request structure has invalid size!\n"));
1081 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1082 }
1083 else
1084 {
1085 VMMDevGetHeightReductionRequest *heightReductionRequest = (VMMDevGetHeightReductionRequest*)pRequestHeader;
1086 /* forward the call */
1087 pRequestHeader->rc = pThis->pDrv->pfnGetHeightReduction(pThis->pDrv,
1088 &heightReductionRequest->heightReduction);
1089 }
1090 break;
1091 }
1092
1093 /*
1094 * Acknowledge VMMDev events
1095 */
1096 case VMMDevReq_AcknowledgeEvents:
1097 {
1098 if (pRequestHeader->size != sizeof(VMMDevEvents))
1099 {
1100 AssertMsgFailed(("VMMDevReq_AcknowledgeEvents structure has invalid size!\n"));
1101 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1102 }
1103 else
1104 {
1105 if (VBOX_GUEST_ADDITIONS_VERSION_1_03 (pThis))
1106 {
1107 vmmdevSetIRQ_Legacy_EMT (pThis);
1108 }
1109 else
1110 {
1111 VMMDevEvents *pAckRequest;
1112
1113 if (pThis->fNewGuestFilterMask)
1114 {
1115 pThis->fNewGuestFilterMask = false;
1116 pThis->u32GuestFilterMask = pThis->u32NewGuestFilterMask;
1117 }
1118
1119 pAckRequest = (VMMDevEvents *)pRequestHeader;
1120 pAckRequest->events =
1121 pThis->u32HostEventFlags & pThis->u32GuestFilterMask;
1122
1123 pThis->u32HostEventFlags &= ~pThis->u32GuestFilterMask;
1124 pThis->pVMMDevRAMR3->V.V1_04.fHaveEvents = false;
1125 PDMDevHlpPCISetIrqNoWait (pThis->pDevIns, 0, 0);
1126 }
1127 pRequestHeader->rc = VINF_SUCCESS;
1128 }
1129 break;
1130 }
1131
1132 /*
1133 * Change guest filter mask
1134 */
1135 case VMMDevReq_CtlGuestFilterMask:
1136 {
1137 if (pRequestHeader->size != sizeof(VMMDevCtlGuestFilterMask))
1138 {
1139 AssertMsgFailed(("VMMDevReq_AcknowledgeEvents structure has invalid size!\n"));
1140 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1141 }
1142 else
1143 {
1144 VMMDevCtlGuestFilterMask *pCtlMaskRequest;
1145
1146 pCtlMaskRequest = (VMMDevCtlGuestFilterMask *)pRequestHeader;
1147 LogRelFlowFunc(("VMMDevCtlGuestFilterMask: or mask: 0x%x, not mask: 0x%x\n",
1148 pCtlMaskRequest->u32OrMask,
1149 pCtlMaskRequest->u32NotMask));
1150 /* HGCM event notification is enabled by the VMMDev device
1151 * automatically when any HGCM command is issued. The guest
1152 * cannot disable these notifications.
1153 */
1154 VMMDevCtlSetGuestFilterMask (pThis,
1155 pCtlMaskRequest->u32OrMask,
1156 pCtlMaskRequest->u32NotMask & ~VMMDEV_EVENT_HGCM);
1157 pRequestHeader->rc = VINF_SUCCESS;
1158
1159 }
1160 break;
1161 }
1162
1163#ifdef VBOX_WITH_HGCM
1164 /*
1165 * Process HGCM request
1166 */
1167 case VMMDevReq_HGCMConnect:
1168 {
1169 if (pRequestHeader->size < sizeof(VMMDevHGCMConnect))
1170 {
1171 AssertMsgFailed(("VMMDevReq_HGCMConnect structure has invalid size!\n"));
1172 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1173 }
1174 else if (!pThis->pHGCMDrv)
1175 {
1176 Log(("VMMDevReq_HGCMConnect HGCM Connector is NULL!\n"));
1177 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1178 }
1179 else
1180 {
1181 VMMDevHGCMConnect *pHGCMConnect = (VMMDevHGCMConnect *)pRequestHeader;
1182
1183 Log(("VMMDevReq_HGCMConnect\n"));
1184
1185 pRequestHeader->rc = vmmdevHGCMConnect (pThis, pHGCMConnect, (RTGCPHYS)u32);
1186 }
1187 break;
1188 }
1189
1190 case VMMDevReq_HGCMDisconnect:
1191 {
1192 if (pRequestHeader->size < sizeof(VMMDevHGCMDisconnect))
1193 {
1194 AssertMsgFailed(("VMMDevReq_HGCMDisconnect structure has invalid size!\n"));
1195 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1196 }
1197 else if (!pThis->pHGCMDrv)
1198 {
1199 Log(("VMMDevReq_HGCMDisconnect HGCM Connector is NULL!\n"));
1200 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1201 }
1202 else
1203 {
1204 VMMDevHGCMDisconnect *pHGCMDisconnect = (VMMDevHGCMDisconnect *)pRequestHeader;
1205
1206 Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
1207 pRequestHeader->rc = vmmdevHGCMDisconnect (pThis, pHGCMDisconnect, (RTGCPHYS)u32);
1208 }
1209 break;
1210 }
1211
1212#ifdef VBOX_WITH_64_BITS_GUESTS
1213 case VMMDevReq_HGCMCall32:
1214 case VMMDevReq_HGCMCall64:
1215#else
1216 case VMMDevReq_HGCMCall:
1217#endif /* VBOX_WITH_64_BITS_GUESTS */
1218 {
1219 if (pRequestHeader->size < sizeof(VMMDevHGCMCall))
1220 {
1221 AssertMsgFailed(("VMMDevReq_HGCMCall structure has invalid size!\n"));
1222 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1223 }
1224 else if (!pThis->pHGCMDrv)
1225 {
1226 Log(("VMMDevReq_HGCMCall HGCM Connector is NULL!\n"));
1227 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1228 }
1229 else
1230 {
1231 VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)pRequestHeader;
1232
1233 Log2(("VMMDevReq_HGCMCall: sizeof (VMMDevHGCMRequest) = %04X\n", sizeof (VMMDevHGCMCall)));
1234 Log2(("%.*Rhxd\n", pRequestHeader->size, pRequestHeader));
1235
1236#ifdef VBOX_WITH_64_BITS_GUESTS
1237 bool f64Bits = (pRequestHeader->requestType == VMMDevReq_HGCMCall64);
1238#else
1239 bool f64Bits = false;
1240#endif /* VBOX_WITH_64_BITS_GUESTS */
1241
1242 pRequestHeader->rc = vmmdevHGCMCall (pThis, pHGCMCall, requestHeader.size, (RTGCPHYS)u32, f64Bits);
1243 }
1244 break;
1245 }
1246#endif /* VBOX_WITH_HGCM */
1247
1248 case VMMDevReq_HGCMCancel:
1249 {
1250 if (pRequestHeader->size < sizeof(VMMDevHGCMCancel))
1251 {
1252 AssertMsgFailed(("VMMDevReq_HGCMCancel structure has invalid size!\n"));
1253 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1254 }
1255 else if (!pThis->pHGCMDrv)
1256 {
1257 Log(("VMMDevReq_HGCMCancel HGCM Connector is NULL!\n"));
1258 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1259 }
1260 else
1261 {
1262 VMMDevHGCMCancel *pHGCMCancel = (VMMDevHGCMCancel *)pRequestHeader;
1263
1264 Log(("VMMDevReq_VMMDevHGCMCancel\n"));
1265 pRequestHeader->rc = vmmdevHGCMCancel (pThis, pHGCMCancel, (RTGCPHYS)u32);
1266 }
1267 break;
1268 }
1269
1270 case VMMDevReq_HGCMCancel2:
1271 {
1272 if (pRequestHeader->size != sizeof(VMMDevHGCMCancel2))
1273 {
1274 AssertMsgFailed(("VMMDevReq_HGCMCancel structure has invalid size!\n"));
1275 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1276 }
1277 else if (!pThis->pHGCMDrv)
1278 {
1279 Log(("VMMDevReq_HGCMCancel HGCM Connector is NULL!\n"));
1280 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1281 }
1282 else
1283 {
1284 VMMDevHGCMCancel2 *pHGCMCancel2 = (VMMDevHGCMCancel2 *)pRequestHeader;
1285
1286 Log(("VMMDevReq_VMMDevHGCMCancel\n"));
1287 pRequestHeader->rc = vmmdevHGCMCancel2 (pThis, pHGCMCancel2->physReqToCancel);
1288 }
1289 break;
1290 }
1291
1292 case VMMDevReq_VideoAccelEnable:
1293 {
1294 if (pRequestHeader->size < sizeof(VMMDevVideoAccelEnable))
1295 {
1296 Log(("VMMDevReq_VideoAccelEnable request size too small!!!\n"));
1297 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1298 }
1299 else if (!pThis->pDrv)
1300 {
1301 Log(("VMMDevReq_VideoAccelEnable Connector is NULL!!!\n"));
1302 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1303 }
1304 else
1305 {
1306 VMMDevVideoAccelEnable *ptr = (VMMDevVideoAccelEnable *)pRequestHeader;
1307
1308 if (ptr->cbRingBuffer != VBVA_RING_BUFFER_SIZE)
1309 {
1310 /* The guest driver seems compiled with another headers. */
1311 Log(("VMMDevReq_VideoAccelEnable guest ring buffer size %d, should be %d!!!\n", ptr->cbRingBuffer, VBVA_RING_BUFFER_SIZE));
1312 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1313 }
1314 else
1315 {
1316 /* The request is correct. */
1317 ptr->fu32Status |= VBVA_F_STATUS_ACCEPTED;
1318
1319 LogFlow(("VMMDevReq_VideoAccelEnable ptr->u32Enable = %d\n", ptr->u32Enable));
1320
1321 pRequestHeader->rc = ptr->u32Enable?
1322 pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, true, &pThis->pVMMDevRAMR3->vbvaMemory):
1323 pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, false, NULL);
1324
1325 if ( ptr->u32Enable
1326 && RT_SUCCESS (pRequestHeader->rc))
1327 {
1328 ptr->fu32Status |= VBVA_F_STATUS_ENABLED;
1329
1330 /* Remember that guest successfully enabled acceleration.
1331 * We need to reestablish it on restoring the VM from saved state.
1332 */
1333 pThis->u32VideoAccelEnabled = 1;
1334 }
1335 else
1336 {
1337 /* The acceleration was not enabled. Remember that. */
1338 pThis->u32VideoAccelEnabled = 0;
1339 }
1340 }
1341 }
1342 break;
1343 }
1344
1345 case VMMDevReq_VideoAccelFlush:
1346 {
1347 if (pRequestHeader->size < sizeof(VMMDevVideoAccelFlush))
1348 {
1349 AssertMsgFailed(("VMMDevReq_VideoAccelFlush request size too small.\n"));
1350 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1351 }
1352 else if (!pThis->pDrv)
1353 {
1354 Log(("VMMDevReq_VideoAccelFlush Connector is NULL!\n"));
1355 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1356 }
1357 else
1358 {
1359 pThis->pDrv->pfnVideoAccelFlush (pThis->pDrv);
1360
1361 pRequestHeader->rc = VINF_SUCCESS;
1362 }
1363 break;
1364 }
1365
1366 case VMMDevReq_VideoSetVisibleRegion:
1367 {
1368 if (pRequestHeader->size < sizeof(VMMDevVideoSetVisibleRegion))
1369 {
1370 Log(("VMMDevReq_VideoSetVisibleRegion request size too small!!!\n"));
1371 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1372 }
1373 else if (!pThis->pDrv)
1374 {
1375 Log(("VMMDevReq_VideoSetVisibleRegion Connector is NULL!!!\n"));
1376 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1377 }
1378 else
1379 {
1380 VMMDevVideoSetVisibleRegion *ptr = (VMMDevVideoSetVisibleRegion *)pRequestHeader;
1381
1382 if (!ptr->cRect)
1383 {
1384 Log(("VMMDevReq_VideoSetVisibleRegion no rectangles!!!\n"));
1385 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1386 }
1387 else
1388 if (pRequestHeader->size != sizeof(VMMDevVideoSetVisibleRegion) + (ptr->cRect-1)*sizeof(RTRECT))
1389 {
1390 Log(("VMMDevReq_VideoSetVisibleRegion request size too small!!!\n"));
1391 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1392 }
1393 else
1394 {
1395 Log(("VMMDevReq_VideoSetVisibleRegion %d rectangles\n", ptr->cRect));
1396 /* forward the call */
1397 pRequestHeader->rc = pThis->pDrv->pfnSetVisibleRegion(pThis->pDrv, ptr->cRect, &ptr->Rect);
1398 }
1399 }
1400 break;
1401 }
1402
1403 case VMMDevReq_GetSeamlessChangeRequest:
1404 {
1405 if (pRequestHeader->size != sizeof(VMMDevSeamlessChangeRequest))
1406 {
1407 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1408 }
1409 else
1410 {
1411 VMMDevSeamlessChangeRequest *seamlessChangeRequest = (VMMDevSeamlessChangeRequest*)pRequestHeader;
1412 /* just pass on the information */
1413 Log(("VMMDev: returning seamless change request mode=%d\n", pThis->fSeamlessEnabled));
1414 if (pThis->fSeamlessEnabled)
1415 seamlessChangeRequest->mode = VMMDev_Seamless_Visible_Region;
1416 else
1417 seamlessChangeRequest->mode = VMMDev_Seamless_Disabled;
1418
1419 if (seamlessChangeRequest->eventAck == VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST)
1420 {
1421 /* Remember which mode the client has queried. */
1422 pThis->fLastSeamlessEnabled = pThis->fSeamlessEnabled;
1423 }
1424
1425 pRequestHeader->rc = VINF_SUCCESS;
1426 }
1427 break;
1428 }
1429
1430 case VMMDevReq_GetVRDPChangeRequest:
1431 {
1432 if (pRequestHeader->size != sizeof(VMMDevVRDPChangeRequest))
1433 {
1434 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1435 }
1436 else
1437 {
1438 VMMDevVRDPChangeRequest *vrdpChangeRequest = (VMMDevVRDPChangeRequest*)pRequestHeader;
1439 /* just pass on the information */
1440 Log(("VMMDev: returning VRDP status %d level %d\n", pThis->fVRDPEnabled, pThis->u32VRDPExperienceLevel));
1441
1442 vrdpChangeRequest->u8VRDPActive = pThis->fVRDPEnabled;
1443 vrdpChangeRequest->u32VRDPExperienceLevel = pThis->u32VRDPExperienceLevel;
1444
1445 pRequestHeader->rc = VINF_SUCCESS;
1446 }
1447 break;
1448 }
1449
1450 case VMMDevReq_GetMemBalloonChangeRequest:
1451 {
1452 Log(("VMMDevReq_GetMemBalloonChangeRequest\n"));
1453 if (pRequestHeader->size != sizeof(VMMDevGetMemBalloonChangeRequest))
1454 {
1455 AssertFailed();
1456 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1457 }
1458 else
1459 {
1460 VMMDevGetMemBalloonChangeRequest *memBalloonChangeRequest = (VMMDevGetMemBalloonChangeRequest*)pRequestHeader;
1461 /* just pass on the information */
1462 Log(("VMMDev: returning memory balloon size =%d\n", pThis->u32MemoryBalloonSize));
1463 memBalloonChangeRequest->cBalloonChunks = pThis->u32MemoryBalloonSize;
1464 memBalloonChangeRequest->cPhysMemChunks = pThis->cbGuestRAM / (uint64_t)_1M;
1465
1466 if (memBalloonChangeRequest->eventAck == VMMDEV_EVENT_BALLOON_CHANGE_REQUEST)
1467 {
1468 /* Remember which mode the client has queried. */
1469 pThis->u32LastMemoryBalloonSize = pThis->u32MemoryBalloonSize;
1470 }
1471
1472 pRequestHeader->rc = VINF_SUCCESS;
1473 }
1474 break;
1475 }
1476
1477 case VMMDevReq_ChangeMemBalloon:
1478 {
1479 VMMDevChangeMemBalloon *memBalloonChange = (VMMDevChangeMemBalloon*)pRequestHeader;
1480
1481 Log(("VMMDevReq_ChangeMemBalloon\n"));
1482 if ( pRequestHeader->size < sizeof(VMMDevChangeMemBalloon)
1483 || memBalloonChange->cPages != VMMDEV_MEMORY_BALLOON_CHUNK_PAGES
1484 || pRequestHeader->size != (uint32_t)RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[memBalloonChange->cPages]))
1485 {
1486 AssertFailed();
1487 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1488 }
1489 else
1490 {
1491 pRequestHeader->rc = PGMR3PhysChangeMemBalloon(PDMDevHlpGetVM(pDevIns), !!memBalloonChange->fInflate, memBalloonChange->cPages, memBalloonChange->aPhysPage);
1492 if (memBalloonChange->fInflate)
1493 STAM_REL_U32_INC(&pThis->StatMemBalloonChunks);
1494 else
1495 STAM_REL_U32_DEC(&pThis->StatMemBalloonChunks);
1496 }
1497 break;
1498 }
1499
1500 case VMMDevReq_GetStatisticsChangeRequest:
1501 {
1502 Log(("VMMDevReq_GetStatisticsChangeRequest\n"));
1503 if (pRequestHeader->size != sizeof(VMMDevGetStatisticsChangeRequest))
1504 {
1505 AssertFailed();
1506 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1507 }
1508 else
1509 {
1510 VMMDevGetStatisticsChangeRequest *statIntervalChangeRequest = (VMMDevGetStatisticsChangeRequest*)pRequestHeader;
1511 /* just pass on the information */
1512 Log(("VMMDev: returning statistics interval %d seconds\n", pThis->u32StatIntervalSize));
1513 statIntervalChangeRequest->u32StatInterval = pThis->u32StatIntervalSize;
1514
1515 if (statIntervalChangeRequest->eventAck == VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST)
1516 {
1517 /* Remember which mode the client has queried. */
1518 pThis->u32LastStatIntervalSize= pThis->u32StatIntervalSize;
1519 }
1520
1521 pRequestHeader->rc = VINF_SUCCESS;
1522 }
1523 break;
1524 }
1525
1526 case VMMDevReq_ReportGuestStats:
1527 {
1528 Log(("VMMDevReq_ReportGuestStats\n"));
1529 if (pRequestHeader->size != sizeof(VMMDevReportGuestStats))
1530 {
1531 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1532 }
1533 else
1534 {
1535 VMMDevReportGuestStats *stats = (VMMDevReportGuestStats*)pRequestHeader;
1536
1537#ifdef DEBUG
1538 VBoxGuestStatistics *pGuestStats = &stats->guestStats;
1539
1540 Log(("Current statistics:\n"));
1541 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_IDLE)
1542 Log(("CPU%d: CPU Load Idle %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Idle));
1543
1544 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_KERNEL)
1545 Log(("CPU%d: CPU Load Kernel %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Kernel));
1546
1547 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_USER)
1548 Log(("CPU%d: CPU Load User %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_User));
1549
1550 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_THREADS)
1551 Log(("CPU%d: Thread %d\n", pGuestStats->u32CpuId, pGuestStats->u32Threads));
1552
1553 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PROCESSES)
1554 Log(("CPU%d: Processes %d\n", pGuestStats->u32CpuId, pGuestStats->u32Processes));
1555
1556 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_HANDLES)
1557 Log(("CPU%d: Handles %d\n", pGuestStats->u32CpuId, pGuestStats->u32Handles));
1558
1559 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEMORY_LOAD)
1560 Log(("CPU%d: Memory Load %d%%\n", pGuestStats->u32CpuId, pGuestStats->u32MemoryLoad));
1561
1562 /* Note that reported values are in pages; upper layers expect them in megabytes */
1563 Log(("CPU%d: Page size %-4d bytes\n", pGuestStats->u32CpuId, pGuestStats->u32PageSize));
1564 Assert(pGuestStats->u32PageSize == 4096);
1565
1566 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_TOTAL)
1567 Log(("CPU%d: Total physical memory %-4d MB\n", pGuestStats->u32CpuId, (pGuestStats->u32PhysMemTotal + (_1M/_4K)-1) / (_1M/_4K)));
1568
1569 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_AVAIL)
1570 Log(("CPU%d: Free physical memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemAvail / (_1M/_4K)));
1571
1572 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_BALLOON)
1573 Log(("CPU%d: Memory balloon size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemBalloon / (_1M/_4K)));
1574
1575 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_COMMIT_TOTAL)
1576 Log(("CPU%d: Committed memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemCommitTotal / (_1M/_4K)));
1577
1578 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_TOTAL)
1579 Log(("CPU%d: Total kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelTotal / (_1M/_4K)));
1580
1581 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_PAGED)
1582 Log(("CPU%d: Paged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelPaged / (_1M/_4K)));
1583
1584 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_NONPAGED)
1585 Log(("CPU%d: Nonpaged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelNonPaged / (_1M/_4K)));
1586
1587 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_SYSTEM_CACHE)
1588 Log(("CPU%d: System cache size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemSystemCache / (_1M/_4K)));
1589
1590 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PAGE_FILE_SIZE)
1591 Log(("CPU%d: Page file size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PageFileSize / (_1M/_4K)));
1592 Log(("Statistics end *******************\n"));
1593#endif
1594
1595 /* forward the call */
1596 pRequestHeader->rc = pThis->pDrv->pfnReportStatistics(pThis->pDrv, &stats->guestStats);
1597 }
1598 break;
1599 }
1600
1601 case VMMDevReq_QueryCredentials:
1602 {
1603 if (pRequestHeader->size != sizeof(VMMDevCredentials))
1604 {
1605 AssertMsgFailed(("VMMDevReq_QueryCredentials request size too small.\n"));
1606 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1607 }
1608 else
1609 {
1610 VMMDevCredentials *credentials = (VMMDevCredentials*)pRequestHeader;
1611
1612 /* let's start by nulling out the data */
1613 memset(credentials->szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
1614 memset(credentials->szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
1615 memset(credentials->szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
1616
1617 /* should we return whether we got credentials for a logon? */
1618 if (credentials->u32Flags & VMMDEV_CREDENTIALS_QUERYPRESENCE)
1619 {
1620 if ( pThis->credentialsLogon.szUserName[0]
1621 || pThis->credentialsLogon.szPassword[0]
1622 || pThis->credentialsLogon.szDomain[0])
1623 {
1624 credentials->u32Flags |= VMMDEV_CREDENTIALS_PRESENT;
1625 }
1626 else
1627 {
1628 credentials->u32Flags &= ~VMMDEV_CREDENTIALS_PRESENT;
1629 }
1630 }
1631
1632 /* does the guest want to read logon credentials? */
1633 if (credentials->u32Flags & VMMDEV_CREDENTIALS_READ)
1634 {
1635 if (pThis->credentialsLogon.szUserName[0])
1636 strcpy(credentials->szUserName, pThis->credentialsLogon.szUserName);
1637 if (pThis->credentialsLogon.szPassword[0])
1638 strcpy(credentials->szPassword, pThis->credentialsLogon.szPassword);
1639 if (pThis->credentialsLogon.szDomain[0])
1640 strcpy(credentials->szDomain, pThis->credentialsLogon.szDomain);
1641 if (!pThis->credentialsLogon.fAllowInteractiveLogon)
1642 credentials->u32Flags |= VMMDEV_CREDENTIALS_NOLOCALLOGON;
1643 else
1644 credentials->u32Flags &= ~VMMDEV_CREDENTIALS_NOLOCALLOGON;
1645 }
1646
1647 if (!pThis->fKeepCredentials)
1648 {
1649 /* does the caller want us to destroy the logon credentials? */
1650 if (credentials->u32Flags & VMMDEV_CREDENTIALS_CLEAR)
1651 {
1652 memset(pThis->credentialsLogon.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
1653 memset(pThis->credentialsLogon.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
1654 memset(pThis->credentialsLogon.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
1655 }
1656 }
1657
1658 /* does the guest want to read credentials for verification? */
1659 if (credentials->u32Flags & VMMDEV_CREDENTIALS_READJUDGE)
1660 {
1661 if (pThis->credentialsJudge.szUserName[0])
1662 strcpy(credentials->szUserName, pThis->credentialsJudge.szUserName);
1663 if (pThis->credentialsJudge.szPassword[0])
1664 strcpy(credentials->szPassword, pThis->credentialsJudge.szPassword);
1665 if (pThis->credentialsJudge.szDomain[0])
1666 strcpy(credentials->szDomain, pThis->credentialsJudge.szDomain);
1667 }
1668
1669 /* does the caller want us to destroy the judgement credentials? */
1670 if (credentials->u32Flags & VMMDEV_CREDENTIALS_CLEARJUDGE)
1671 {
1672 memset(pThis->credentialsJudge.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
1673 memset(pThis->credentialsJudge.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
1674 memset(pThis->credentialsJudge.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
1675 }
1676
1677 pRequestHeader->rc = VINF_SUCCESS;
1678 }
1679 break;
1680 }
1681
1682 case VMMDevReq_ReportCredentialsJudgement:
1683 {
1684 if (pRequestHeader->size != sizeof(VMMDevCredentials))
1685 {
1686 AssertMsgFailed(("VMMDevReq_ReportCredentialsJudgement request size too small.\n"));
1687 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1688 }
1689 else
1690 {
1691 VMMDevCredentials *credentials = (VMMDevCredentials*)pRequestHeader;
1692
1693 /* what does the guest think about the credentials? (note: the order is important here!) */
1694 if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_DENY)
1695 {
1696 pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_DENY);
1697 }
1698 else if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT)
1699 {
1700 pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT);
1701 }
1702 else if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_OK)
1703 {
1704 pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_OK);
1705 }
1706 else
1707 Log(("VMMDevReq_ReportCredentialsJudgement: invalid flags: %d!!!\n", credentials->u32Flags));
1708
1709 pRequestHeader->rc = VINF_SUCCESS;
1710 }
1711 break;
1712 }
1713
1714 /*
1715 * Implemented in 3.1.0.
1716 *
1717 * Note! The ring-0 VBoxGuestLib uses this to check whether
1718 * VMMDevHGCMParmType_PageList is supported.
1719 */
1720 case VMMDevReq_GetHostVersion:
1721 {
1722 AssertMsgBreakStmt(pRequestHeader->size == sizeof(VMMDevReqHostVersion),
1723 ("%#x < %#x\n", pRequestHeader->size, sizeof(VMMDevReqLogString)),
1724 pRequestHeader->rc = VERR_INVALID_PARAMETER);
1725 VMMDevReqHostVersion *pReqHostVer = (VMMDevReqHostVersion*)pRequestHeader;
1726 pReqHostVer->major = RTBldCfgVersionMajor();
1727 pReqHostVer->minor = RTBldCfgVersionMinor();
1728 pReqHostVer->build = RTBldCfgVersionBuild();
1729 pReqHostVer->revision = RTBldCfgRevision();
1730 pReqHostVer->features = VMMDEV_HVF_HGCM_PHYS_PAGE_LIST;
1731 pReqHostVer->header.rc = VINF_SUCCESS;
1732 break;
1733 }
1734
1735 case VMMDevReq_GetCpuHotPlugRequest:
1736 {
1737 VMMDevGetCpuHotPlugRequest *pReqCpuHotPlug = (VMMDevGetCpuHotPlugRequest *)pRequestHeader;
1738
1739 if (pRequestHeader->size != sizeof(VMMDevGetCpuHotPlugRequest))
1740 {
1741 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1742 }
1743 else
1744 {
1745 pReqCpuHotPlug->enmEventType = pThis->enmCpuHotPlugEvent;
1746 pReqCpuHotPlug->idCpuCore = pThis->idCpuCore;
1747 pReqCpuHotPlug->idCpuPackage = pThis->idCpuPackage;
1748 pReqCpuHotPlug->header.rc = VINF_SUCCESS;
1749
1750 /* Clear the event */
1751 pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_None;
1752 pThis->idCpuCore = UINT32_MAX;
1753 pThis->idCpuPackage = UINT32_MAX;
1754 }
1755 break;
1756 }
1757
1758 case VMMDevReq_SetCpuHotPlugStatus:
1759 {
1760 VMMDevCpuHotPlugStatusRequest *pReqCpuHotPlugStatus = (VMMDevCpuHotPlugStatusRequest *)pRequestHeader;
1761
1762 if (pRequestHeader->size != sizeof(VMMDevCpuHotPlugStatusRequest))
1763 {
1764 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1765 }
1766 else
1767 {
1768 pRequestHeader->rc = VINF_SUCCESS;
1769
1770 if (pReqCpuHotPlugStatus->enmStatusType == VMMDevCpuStatusType_Disable)
1771 pThis->fCpuHotPlugEventsEnabled = false;
1772 else if (pReqCpuHotPlugStatus->enmStatusType == VMMDevCpuStatusType_Enable)
1773 pThis->fCpuHotPlugEventsEnabled = true;
1774 else
1775 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1776 }
1777 break;
1778 }
1779
1780#ifdef VBOX_WITH_PAGE_SHARING
1781 case VMMDevReq_RegisterSharedModule:
1782 {
1783 VMMDevSharedModuleRegistrationRequest *pReqModule = (VMMDevSharedModuleRegistrationRequest *)pRequestHeader;
1784
1785 if ( pRequestHeader->size < sizeof(VMMDevSharedModuleRegistrationRequest)
1786 || pRequestHeader->size != RT_UOFFSETOF(VMMDevSharedModuleRegistrationRequest, aRegions[pReqModule->cRegions]))
1787 {
1788 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1789 }
1790 else
1791 {
1792 pRequestHeader->rc = PGMR3SharedModuleRegister(PDMDevHlpGetVM(pDevIns), pReqModule->enmGuestOS, pReqModule->szName, pReqModule->szVersion,
1793 pReqModule->GCBaseAddr, pReqModule->cbModule,
1794 pReqModule->cRegions, pReqModule->aRegions);
1795 }
1796 break;
1797 }
1798
1799 case VMMDevReq_UnregisterSharedModule:
1800 {
1801 VMMDevSharedModuleUnregistrationRequest *pReqModule = (VMMDevSharedModuleUnregistrationRequest *)pRequestHeader;
1802
1803 if (pRequestHeader->size != sizeof(VMMDevSharedModuleUnregistrationRequest))
1804 {
1805 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1806 }
1807 else
1808 {
1809 pRequestHeader->rc = PGMR3SharedModuleUnregister(PDMDevHlpGetVM(pDevIns), pReqModule->szName, pReqModule->szVersion,
1810 pReqModule->GCBaseAddr, pReqModule->cbModule);
1811 }
1812 break;
1813 }
1814
1815 case VMMDevReq_CheckSharedModules:
1816 {
1817 VMMDevSharedModuleCheckRequest *pReqModule = (VMMDevSharedModuleCheckRequest *)pRequestHeader;
1818
1819 if (pRequestHeader->size != sizeof(VMMDevSharedModuleCheckRequest))
1820 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1821 else
1822 pRequestHeader->rc = PGMR3SharedModuleCheckAll(PDMDevHlpGetVM(pDevIns));
1823 break;
1824 }
1825
1826 case VMMDevReq_GetPageSharingStatus:
1827 {
1828 VMMDevPageSharingStatusRequest *pReqStatus = (VMMDevPageSharingStatusRequest *)pRequestHeader;
1829
1830 if (pRequestHeader->size != sizeof(VMMDevPageSharingStatusRequest))
1831 {
1832 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1833 }
1834 else
1835 {
1836 pReqStatus->fEnabled = false;
1837 pThis->pDrv->pfnIsPageFusionEnabled(pThis->pDrv, &pReqStatus->fEnabled);
1838 pRequestHeader->rc = VINF_SUCCESS;
1839 }
1840 break;
1841 }
1842
1843 case VMMDevReq_DebugIsPageShared:
1844 {
1845# ifdef DEBUG
1846 VMMDevPageIsSharedRequest *pReq = (VMMDevPageIsSharedRequest *)pRequestHeader;
1847
1848 if (pRequestHeader->size != sizeof(VMMDevPageIsSharedRequest))
1849 {
1850 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1851 }
1852 else
1853 {
1854 pRequestHeader->rc = PGMR3SharedModuleGetPageState(PDMDevHlpGetVM(pDevIns), pReq->GCPtrPage, &pReq->fShared, &pReq->uPageFlags);
1855 }
1856# else
1857 pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
1858# endif
1859 break;
1860 }
1861
1862#endif
1863
1864#ifdef DEBUG
1865 case VMMDevReq_LogString:
1866 {
1867 if (pRequestHeader->size < sizeof(VMMDevReqLogString))
1868 {
1869 AssertMsgFailed(("VMMDevReq_LogString request size too small.\n"));
1870 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1871 }
1872 else
1873 {
1874 VMMDevReqLogString *pReqLogString = (VMMDevReqLogString *)pRequestHeader;
1875 LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR,
1876 ("DEBUG LOG: %s", pReqLogString->szString));
1877 pRequestHeader->rc = VINF_SUCCESS;
1878 }
1879 break;
1880 }
1881#endif
1882 default:
1883 {
1884 pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
1885
1886 Log(("VMMDev unknown request type %d\n", pRequestHeader->requestType));
1887
1888 break;
1889 }
1890 }
1891
1892end:
1893 /* Write the result back to guest memory */
1894 if (pRequestHeader)
1895 {
1896 PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, pRequestHeader, pRequestHeader->size);
1897 RTMemFree(pRequestHeader);
1898 }
1899 else
1900 {
1901 /* early error case; write back header only */
1902 PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
1903 }
1904
1905 PDMCritSectLeave(&pThis->CritSect);
1906 return rcRet;
1907}
1908
1909/**
1910 * Callback function for mapping an PCI I/O region.
1911 *
1912 * @return VBox status code.
1913 * @param pPciDev Pointer to PCI device. Use pPciDev->pDevIns to get the device instance.
1914 * @param iRegion The region number.
1915 * @param GCPhysAddress Physical address of the region. If iType is PCI_ADDRESS_SPACE_IO, this is an
1916 * I/O port, else it's a physical address.
1917 * This address is *NOT* relative to pci_mem_base like earlier!
1918 * @param enmType One of the PCI_ADDRESS_SPACE_* values.
1919 */
1920static DECLCALLBACK(int) vmmdevIORAMRegionMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
1921{
1922 LogFlow(("vmmdevR3IORAMRegionMap: iRegion=%d GCPhysAddress=%RGp cb=%#x enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
1923 VMMDevState *pThis = PCIDEV_2_VMMDEVSTATE(pPciDev);
1924 int rc;
1925
1926 if (iRegion == 1)
1927 {
1928 AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM, VERR_INTERNAL_ERROR);
1929 Assert(pThis->pVMMDevRAMR3 != NULL);
1930 if (GCPhysAddress != NIL_RTGCPHYS)
1931 {
1932 /*
1933 * Map the MMIO2 memory.
1934 */
1935 pThis->GCPhysVMMDevRAM = GCPhysAddress;
1936 Assert(pThis->GCPhysVMMDevRAM == GCPhysAddress);
1937 rc = PDMDevHlpMMIO2Map(pPciDev->pDevIns, iRegion, GCPhysAddress);
1938 }
1939 else
1940 {
1941 /*
1942 * It is about to be unmapped, just clean up.
1943 */
1944 pThis->GCPhysVMMDevRAM = NIL_RTGCPHYS32;
1945 rc = VINF_SUCCESS;
1946 }
1947 }
1948 else if (iRegion == 2)
1949 {
1950 AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM_PREFETCH, VERR_INTERNAL_ERROR);
1951 Assert(pThis->pVMMDevHeapR3 != NULL);
1952 if (GCPhysAddress != NIL_RTGCPHYS)
1953 {
1954 /*
1955 * Map the MMIO2 memory.
1956 */
1957 pThis->GCPhysVMMDevHeap = GCPhysAddress;
1958 Assert(pThis->GCPhysVMMDevHeap == GCPhysAddress);
1959 rc = PDMDevHlpMMIO2Map(pPciDev->pDevIns, iRegion, GCPhysAddress);
1960 if (RT_SUCCESS(rc))
1961 rc = PDMDevHlpRegisterVMMDevHeap(pPciDev->pDevIns, GCPhysAddress, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
1962 }
1963 else
1964 {
1965 /*
1966 * It is about to be unmapped, just clean up.
1967 */
1968 PDMDevHlpUnregisterVMMDevHeap(pPciDev->pDevIns, pThis->GCPhysVMMDevHeap);
1969 pThis->GCPhysVMMDevHeap = NIL_RTGCPHYS32;
1970 rc = VINF_SUCCESS;
1971 }
1972 }
1973 else
1974 {
1975 AssertMsgFailed(("%d\n", iRegion));
1976 rc = VERR_INVALID_PARAMETER;
1977 }
1978
1979 return rc;
1980}
1981
1982
1983/**
1984 * Callback function for mapping a PCI I/O region.
1985 *
1986 * @return VBox status code.
1987 * @param pPciDev Pointer to PCI device. Use pPciDev->pDevIns to get the device instance.
1988 * @param iRegion The region number.
1989 * @param GCPhysAddress Physical address of the region. If iType is PCI_ADDRESS_SPACE_IO, this is an
1990 * I/O port, else it's a physical address.
1991 * This address is *NOT* relative to pci_mem_base like earlier!
1992 * @param enmType One of the PCI_ADDRESS_SPACE_* values.
1993 */
1994static DECLCALLBACK(int) vmmdevIOPortRegionMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
1995{
1996 VMMDevState *pThis = PCIDEV_2_VMMDEVSTATE(pPciDev);
1997 int rc = VINF_SUCCESS;
1998
1999 Assert(enmType == PCI_ADDRESS_SPACE_IO);
2000 Assert(iRegion == 0);
2001 AssertMsg(RT_ALIGN(GCPhysAddress, 8) == GCPhysAddress, ("Expected 8 byte alignment. GCPhysAddress=%#x\n", GCPhysAddress));
2002
2003 /*
2004 * Save the base port address to simplify Port offset calculations.
2005 */
2006 pThis->PortBase = (RTIOPORT)GCPhysAddress;
2007
2008 /*
2009 * Register our port IO handlers.
2010 */
2011 rc = PDMDevHlpIOPortRegister(pPciDev->pDevIns,
2012 (RTIOPORT)GCPhysAddress + VMMDEV_PORT_OFF_REQUEST, 1,
2013 (void*)pThis, vmmdevRequestHandler,
2014 NULL, NULL, NULL, "VMMDev Request Handler");
2015 AssertRC(rc);
2016 return rc;
2017}
2018
2019/**
2020 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
2021 */
2022static DECLCALLBACK(void *) vmmdevPortQueryInterface(PPDMIBASE pInterface, const char *pszIID)
2023{
2024 VMMDevState *pThis = RT_FROM_MEMBER(pInterface, VMMDevState, IBase);
2025
2026 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
2027 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIVMMDEVPORT, &pThis->IPort);
2028#ifdef VBOX_WITH_HGCM
2029 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHGCMPORT, &pThis->IHGCMPort);
2030#endif
2031 /* Currently only for shared folders. */
2032 PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->SharedFolders.ILeds);
2033 return NULL;
2034}
2035
2036/**
2037 * Gets the pointer to the status LED of a unit.
2038 *
2039 * @returns VBox status code.
2040 * @param pInterface Pointer to the interface structure containing the called function pointer.
2041 * @param iLUN The unit which status LED we desire.
2042 * @param ppLed Where to store the LED pointer.
2043 */
2044static DECLCALLBACK(int) vmmdevQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
2045{
2046 VMMDevState *pThis = (VMMDevState *)( (uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, SharedFolders.ILeds) );
2047 if (iLUN == 0) /* LUN 0 is shared folders */
2048 {
2049 *ppLed = &pThis->SharedFolders.Led;
2050 return VINF_SUCCESS;
2051 }
2052 return VERR_PDM_LUN_NOT_FOUND;
2053}
2054
2055/* -=-=-=-=-=- IVMMDevPort -=-=-=-=-=- */
2056
2057/** Converts a VMMDev port interface pointer to a VMMDev state pointer. */
2058#define IVMMDEVPORT_2_VMMDEVSTATE(pInterface) ( (VMMDevState*)((uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, IPort)) )
2059
2060
2061/**
2062 * Return the current absolute mouse position in pixels
2063 *
2064 * @returns VBox status code
2065 * @param pAbsX Pointer of result value, can be NULL
2066 * @param pAbsY Pointer of result value, can be NULL
2067 */
2068static DECLCALLBACK(int) vmmdevQueryAbsoluteMouse(PPDMIVMMDEVPORT pInterface, uint32_t *pAbsX, uint32_t *pAbsY)
2069{
2070 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2071 AssertCompile(sizeof(pThis->mouseXAbs) == sizeof(*pAbsX));
2072 AssertCompile(sizeof(pThis->mouseYAbs) == sizeof(*pAbsY));
2073 if (pAbsX)
2074 ASMAtomicReadSize(&pThis->mouseXAbs, pAbsX);
2075 if (pAbsY)
2076 ASMAtomicReadSize(&pThis->mouseYAbs, pAbsY);
2077 return VINF_SUCCESS;
2078}
2079
2080/**
2081 * Set the new absolute mouse position in pixels
2082 *
2083 * @returns VBox status code
2084 * @param absX New absolute X position
2085 * @param absY New absolute Y position
2086 */
2087static DECLCALLBACK(int) vmmdevSetAbsoluteMouse(PPDMIVMMDEVPORT pInterface, uint32_t absX, uint32_t absY)
2088{
2089 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2090 PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2091
2092 if ((pThis->mouseXAbs == absX) && (pThis->mouseYAbs == absY))
2093 {
2094 PDMCritSectLeave(&pThis->CritSect);
2095 return VINF_SUCCESS;
2096 }
2097 Log2(("vmmdevSetAbsoluteMouse: settings absolute position to x = %d, y = %d\n", absX, absY));
2098 pThis->mouseXAbs = absX;
2099 pThis->mouseYAbs = absY;
2100 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
2101 PDMCritSectLeave(&pThis->CritSect);
2102 return VINF_SUCCESS;
2103}
2104
2105/**
2106 * Return the current mouse capability flags
2107 *
2108 * @returns VBox status code
2109 * @param pCapabilities Pointer of result value
2110 */
2111static DECLCALLBACK(int) vmmdevQueryMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t *pCapabilities)
2112{
2113 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2114 if (!pCapabilities)
2115 return VERR_INVALID_PARAMETER;
2116 *pCapabilities = pThis->mouseCapabilities;
2117 return VINF_SUCCESS;
2118}
2119
2120/**
2121 * Set the current mouse capability flag (host side)
2122 *
2123 * @returns VBox status code
2124 * @param capabilities Capability mask
2125 */
2126static DECLCALLBACK(int) vmmdevSetMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t capabilities)
2127{
2128 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2129 PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2130
2131 bool bNotify = ( (capabilities & VMMDEV_MOUSE_NOTIFY_GUEST_MASK)
2132 != (pThis->mouseCapabilities & VMMDEV_MOUSE_NOTIFY_GUEST_MASK));
2133
2134 Log(("vmmdevSetMouseCapabilities: bNotify %d\n", bNotify));
2135
2136 pThis->mouseCapabilities &= ~VMMDEV_MOUSE_HOST_MASK
2137 | VMMDEV_MOUSE_HOST_RECHECKS_NEEDS_HOST_CURSOR;
2138 pThis->mouseCapabilities |= (capabilities & VMMDEV_MOUSE_HOST_MASK);
2139 if (bNotify)
2140 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
2141
2142 PDMCritSectLeave(&pThis->CritSect);
2143 return VINF_SUCCESS;
2144}
2145
2146
2147static DECLCALLBACK(int) vmmdevRequestDisplayChange(PPDMIVMMDEVPORT pInterface, uint32_t xres, uint32_t yres, uint32_t bpp, uint32_t display)
2148{
2149 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2150
2151 if (display >= RT_ELEMENTS(pThis->displayChangeData.aRequests))
2152 {
2153 return VERR_INVALID_PARAMETER;
2154 }
2155
2156 PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2157
2158 DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[display];
2159
2160 /* Verify that the new resolution is different and that guest does not yet know about it. */
2161 bool fSameResolution = (!xres || (pRequest->lastReadDisplayChangeRequest.xres == xres)) &&
2162 (!yres || (pRequest->lastReadDisplayChangeRequest.yres == yres)) &&
2163 (!bpp || (pRequest->lastReadDisplayChangeRequest.bpp == bpp)) &&
2164 pRequest->lastReadDisplayChangeRequest.display == display;
2165
2166 if (!xres && !yres && !bpp)
2167 {
2168 /* Special case of reset video mode. */
2169 fSameResolution = false;
2170 }
2171
2172 Log3(("vmmdevRequestDisplayChange: same=%d. new: xres=%d, yres=%d, bpp=%d, display=%d. old: xres=%d, yres=%d, bpp=%d, display=%d.\n",
2173 fSameResolution, xres, yres, bpp, display, pRequest->lastReadDisplayChangeRequest.xres, pRequest->lastReadDisplayChangeRequest.yres, pRequest->lastReadDisplayChangeRequest.bpp, pRequest->lastReadDisplayChangeRequest.display));
2174
2175 if (!fSameResolution)
2176 {
2177 LogRel(("VMMDev::SetVideoModeHint: got a video mode hint (%dx%dx%d) at %d\n",
2178 xres, yres, bpp, display));
2179
2180 /* we could validate the information here but hey, the guest can do that as well! */
2181 pRequest->displayChangeRequest.xres = xres;
2182 pRequest->displayChangeRequest.yres = yres;
2183 pRequest->displayChangeRequest.bpp = bpp;
2184 pRequest->displayChangeRequest.display = display;
2185 pRequest->fPending = true;
2186
2187 /* IRQ so the guest knows what's going on */
2188 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
2189 }
2190
2191 PDMCritSectLeave(&pThis->CritSect);
2192 return VINF_SUCCESS;
2193}
2194
2195static DECLCALLBACK(int) vmmdevRequestSeamlessChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
2196{
2197 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2198 PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2199
2200 /* Verify that the new resolution is different and that guest does not yet know about it. */
2201 bool fSameMode = (pThis->fLastSeamlessEnabled == fEnabled);
2202
2203 Log(("vmmdevRequestSeamlessChange: same=%d. new=%d\n", fSameMode, fEnabled));
2204
2205 if (!fSameMode)
2206 {
2207 /* we could validate the information here but hey, the guest can do that as well! */
2208 pThis->fSeamlessEnabled = fEnabled;
2209
2210 /* IRQ so the guest knows what's going on */
2211 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST);
2212 }
2213
2214 PDMCritSectLeave(&pThis->CritSect);
2215 return VINF_SUCCESS;
2216}
2217
2218static DECLCALLBACK(int) vmmdevSetMemoryBalloon(PPDMIVMMDEVPORT pInterface, uint32_t ulBalloonSize)
2219{
2220 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2221 PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2222
2223 /* Verify that the new resolution is different and that guest does not yet know about it. */
2224 bool fSame = (pThis->u32LastMemoryBalloonSize == ulBalloonSize);
2225
2226 Log(("vmmdevSetMemoryBalloon: old=%d. new=%d\n", pThis->u32LastMemoryBalloonSize, ulBalloonSize));
2227
2228 if (!fSame)
2229 {
2230 /* we could validate the information here but hey, the guest can do that as well! */
2231 pThis->u32MemoryBalloonSize = ulBalloonSize;
2232
2233 /* IRQ so the guest knows what's going on */
2234 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_BALLOON_CHANGE_REQUEST);
2235 }
2236
2237 PDMCritSectLeave(&pThis->CritSect);
2238 return VINF_SUCCESS;
2239}
2240
2241static DECLCALLBACK(int) vmmdevVRDPChange(PPDMIVMMDEVPORT pInterface, bool fVRDPEnabled, uint32_t u32VRDPExperienceLevel)
2242{
2243 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2244 PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2245
2246 bool fSame = (pThis->fVRDPEnabled == fVRDPEnabled);
2247
2248 Log(("vmmdevVRDPChange: old=%d. new=%d\n", pThis->fVRDPEnabled, fVRDPEnabled));
2249
2250 if (!fSame)
2251 {
2252 pThis->fVRDPEnabled = fVRDPEnabled;
2253 pThis->u32VRDPExperienceLevel = u32VRDPExperienceLevel;
2254
2255 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_VRDP);
2256 }
2257
2258 PDMCritSectLeave(&pThis->CritSect);
2259 return VINF_SUCCESS;
2260}
2261
2262static DECLCALLBACK(int) vmmdevSetStatisticsInterval(PPDMIVMMDEVPORT pInterface, uint32_t ulStatInterval)
2263{
2264 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2265 PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2266
2267 /* Verify that the new resolution is different and that guest does not yet know about it. */
2268 bool fSame = (pThis->u32LastStatIntervalSize == ulStatInterval);
2269
2270 Log(("vmmdevSetStatisticsInterval: old=%d. new=%d\n", pThis->u32LastStatIntervalSize, ulStatInterval));
2271
2272 if (!fSame)
2273 {
2274 /* we could validate the information here but hey, the guest can do that as well! */
2275 pThis->u32StatIntervalSize = ulStatInterval;
2276
2277 /* IRQ so the guest knows what's going on */
2278 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST);
2279 }
2280
2281 PDMCritSectLeave(&pThis->CritSect);
2282 return VINF_SUCCESS;
2283}
2284
2285
2286static DECLCALLBACK(int) vmmdevSetCredentials(PPDMIVMMDEVPORT pInterface, const char *pszUsername,
2287 const char *pszPassword, const char *pszDomain,
2288 uint32_t u32Flags)
2289{
2290 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2291 int rc = VINF_SUCCESS;
2292
2293 PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2294
2295 /* logon mode? */
2296 if (u32Flags & VMMDEV_SETCREDENTIALS_GUESTLOGON)
2297 {
2298 /* memorize the data */
2299 strcpy(pThis->credentialsLogon.szUserName, pszUsername);
2300 strcpy(pThis->credentialsLogon.szPassword, pszPassword);
2301 strcpy(pThis->credentialsLogon.szDomain, pszDomain);
2302 pThis->credentialsLogon.fAllowInteractiveLogon = !(u32Flags & VMMDEV_SETCREDENTIALS_NOLOCALLOGON);
2303 }
2304 /* credentials verification mode? */
2305 else if (u32Flags & VMMDEV_SETCREDENTIALS_JUDGE)
2306 {
2307 /* memorize the data */
2308 strcpy(pThis->credentialsJudge.szUserName, pszUsername);
2309 strcpy(pThis->credentialsJudge.szPassword, pszPassword);
2310 strcpy(pThis->credentialsJudge.szDomain, pszDomain);
2311
2312 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_JUDGE_CREDENTIALS);
2313 }
2314 else
2315 rc = VERR_INVALID_PARAMETER;
2316
2317 PDMCritSectLeave(&pThis->CritSect);
2318 return rc;
2319}
2320
2321/**
2322 * Notification from the Display. Especially useful when
2323 * acceleration is disabled after a video mode change.
2324 *
2325 * @param fEnable Current acceleration status.
2326 */
2327static DECLCALLBACK(void) vmmdevVBVAChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
2328{
2329 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2330
2331 Log(("vmmdevVBVAChange: fEnabled = %d\n", fEnabled));
2332
2333 if (pThis)
2334 {
2335 pThis->u32VideoAccelEnabled = fEnabled;
2336 }
2337 return;
2338}
2339
2340/**
2341 * Notification that a CPU is about to be unplugged from the VM.
2342 * The guest has to eject the CPU.
2343 *
2344 * @returns VBox status code.
2345 * @param idCpu The id of the CPU.
2346 * @param idCpuCore The core id of the CPU to remove.
2347 * @param idCpuPackage The package id of the CPU to remove.
2348 */
2349static DECLCALLBACK(int) vmmdevCpuHotUnplug(PPDMIVMMDEVPORT pInterface, uint32_t idCpuCore, uint32_t idCpuPackage)
2350{
2351 int rc = VINF_SUCCESS;
2352 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2353
2354 Log(("vmmdevCpuHotUnplug: idCpuCore=%u idCpuPackage=%u\n", idCpuCore, idCpuPackage));
2355
2356 PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2357
2358 if (pThis->fCpuHotPlugEventsEnabled)
2359 {
2360 pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_Unplug;
2361 pThis->idCpuCore = idCpuCore;
2362 pThis->idCpuPackage = idCpuPackage;
2363 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_CPU_HOTPLUG);
2364 }
2365 else
2366 rc = VERR_CPU_HOTPLUG_NOT_MONITORED_BY_GUEST;
2367
2368 PDMCritSectLeave(&pThis->CritSect);
2369 return rc;
2370}
2371
2372/**
2373 * Notification that a CPU was attached to the VM
2374 * The guest may use it now.
2375 *
2376 * @returns VBox status code.
2377 * @param idCpuCore The core id of the CPU to add.
2378 * @param idCpuPackage The package id of the CPU to add.
2379 */
2380static DECLCALLBACK(int) vmmdevCpuHotPlug(PPDMIVMMDEVPORT pInterface, uint32_t idCpuCore, uint32_t idCpuPackage)
2381{
2382 int rc = VINF_SUCCESS;
2383 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2384
2385 Log(("vmmdevCpuPlug: idCpuCore=%u idCpuPackage=%u\n", idCpuCore, idCpuPackage));
2386
2387 PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2388
2389 if (pThis->fCpuHotPlugEventsEnabled)
2390 {
2391 pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_Plug;
2392 pThis->idCpuCore = idCpuCore;
2393 pThis->idCpuPackage = idCpuPackage;
2394 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_CPU_HOTPLUG);
2395 }
2396 else
2397 rc = VERR_CPU_HOTPLUG_NOT_MONITORED_BY_GUEST;
2398
2399 PDMCritSectLeave(&pThis->CritSect);
2400 return rc;
2401}
2402
2403/* -=-=-=-=-=- Saved State -=-=-=-=-=- */
2404
2405/**
2406 * @copydoc FNSSMDEVLIVEEXEC
2407 */
2408static DECLCALLBACK(int) vmmdevLiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
2409{
2410 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
2411
2412 SSMR3PutBool(pSSM, pThis->fGetHostTimeDisabled);
2413 SSMR3PutBool(pSSM, pThis->fBackdoorLogDisabled);
2414 SSMR3PutBool(pSSM, pThis->fKeepCredentials);
2415 SSMR3PutBool(pSSM, pThis->fHeapEnabled);
2416
2417 return VINF_SSM_DONT_CALL_AGAIN;
2418}
2419
2420
2421/**
2422 * @copydoc FNSSMDEVSAVEEXEC
2423 *
2424 */
2425static DECLCALLBACK(int) vmmdevSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
2426{
2427 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
2428
2429 vmmdevLiveExec(pDevIns, pSSM, SSM_PASS_FINAL);
2430
2431 SSMR3PutU32(pSSM, pThis->hypervisorSize);
2432 SSMR3PutU32(pSSM, pThis->mouseCapabilities);
2433 SSMR3PutU32(pSSM, pThis->mouseXAbs);
2434 SSMR3PutU32(pSSM, pThis->mouseYAbs);
2435
2436 SSMR3PutBool(pSSM, pThis->fNewGuestFilterMask);
2437 SSMR3PutU32(pSSM, pThis->u32NewGuestFilterMask);
2438 SSMR3PutU32(pSSM, pThis->u32GuestFilterMask);
2439 SSMR3PutU32(pSSM, pThis->u32HostEventFlags);
2440 /* The following is not strictly necessary as PGM restors MMIO2, keeping it for historical reasons. */
2441 SSMR3PutMem(pSSM, &pThis->pVMMDevRAMR3->V, sizeof(pThis->pVMMDevRAMR3->V));
2442
2443 SSMR3PutMem(pSSM, &pThis->guestInfo, sizeof (pThis->guestInfo));
2444 SSMR3PutU32(pSSM, pThis->fu32AdditionsOk);
2445 SSMR3PutU32(pSSM, pThis->u32VideoAccelEnabled);
2446 SSMR3PutBool(pSSM, pThis->displayChangeData.fGuestSentChangeEventAck);
2447
2448 SSMR3PutU32(pSSM, pThis->guestCaps);
2449
2450#ifdef VBOX_WITH_HGCM
2451 vmmdevHGCMSaveState(pThis, pSSM);
2452#endif /* VBOX_WITH_HGCM */
2453
2454 SSMR3PutU32(pSSM, pThis->fHostCursorRequested);
2455
2456 return VINF_SUCCESS;
2457}
2458
2459/**
2460 * @copydoc FNSSMDEVLOADEXEC
2461 */
2462static DECLCALLBACK(int) vmmdevLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
2463{
2464 /** @todo The code load code is assuming we're always loaded into a freshly
2465 * constructed VM. */
2466 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
2467 int rc;
2468
2469 if ( uVersion > VMMDEV_SAVED_STATE_VERSION
2470 || uVersion < 6)
2471 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
2472
2473 /* config */
2474 if (uVersion > VMMDEV_SAVED_STATE_VERSION_VBOX_30)
2475 {
2476 bool f;
2477 rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
2478 if (pThis->fGetHostTimeDisabled != f)
2479 LogRel(("VMMDev: Config mismatch - fGetHostTimeDisabled: config=%RTbool saved=%RTbool\n", pThis->fGetHostTimeDisabled, f));
2480
2481 rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
2482 if (pThis->fBackdoorLogDisabled != f)
2483 LogRel(("VMMDev: Config mismatch - fBackdoorLogDisabled: config=%RTbool saved=%RTbool\n", pThis->fBackdoorLogDisabled, f));
2484
2485 rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
2486 if (pThis->fKeepCredentials != f)
2487 return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fKeepCredentials: config=%RTbool saved=%RTbool"),
2488 pThis->fKeepCredentials, f);
2489 rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
2490 if (pThis->fHeapEnabled != f)
2491 return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fHeapEnabled: config=%RTbool saved=%RTbool"),
2492 pThis->fHeapEnabled, f);
2493 }
2494
2495 if (uPass != SSM_PASS_FINAL)
2496 return VINF_SUCCESS;
2497
2498 /* state */
2499 SSMR3GetU32(pSSM, &pThis->hypervisorSize);
2500 SSMR3GetU32(pSSM, &pThis->mouseCapabilities);
2501 SSMR3GetU32(pSSM, &pThis->mouseXAbs);
2502 SSMR3GetU32(pSSM, &pThis->mouseYAbs);
2503
2504 SSMR3GetBool(pSSM, &pThis->fNewGuestFilterMask);
2505 SSMR3GetU32(pSSM, &pThis->u32NewGuestFilterMask);
2506 SSMR3GetU32(pSSM, &pThis->u32GuestFilterMask);
2507 SSMR3GetU32(pSSM, &pThis->u32HostEventFlags);
2508
2509// SSMR3GetBool(pSSM, &pThis->pVMMDevRAMR3->fHaveEvents);
2510 // here be dragons (probably)
2511 SSMR3GetMem(pSSM, &pThis->pVMMDevRAMR3->V, sizeof (pThis->pVMMDevRAMR3->V));
2512
2513 SSMR3GetMem(pSSM, &pThis->guestInfo, sizeof (pThis->guestInfo));
2514 SSMR3GetU32(pSSM, &pThis->fu32AdditionsOk);
2515 SSMR3GetU32(pSSM, &pThis->u32VideoAccelEnabled);
2516 if (uVersion > 10)
2517 SSMR3GetBool(pSSM, &pThis->displayChangeData.fGuestSentChangeEventAck);
2518
2519 rc = SSMR3GetU32(pSSM, &pThis->guestCaps);
2520
2521 /* Attributes which were temporarily introduced in r30072 */
2522 if (uVersion == 7)
2523 {
2524 uint32_t temp;
2525 SSMR3GetU32(pSSM, &temp);
2526 rc = SSMR3GetU32(pSSM, &temp);
2527 }
2528 AssertRCReturn(rc, rc);
2529
2530#ifdef VBOX_WITH_HGCM
2531 rc = vmmdevHGCMLoadState(pThis, pSSM, uVersion);
2532 AssertRCReturn(rc, rc);
2533#endif /* VBOX_WITH_HGCM */
2534
2535 if (uVersion >= 10)
2536 rc = SSMR3GetU32(pSSM, &pThis->fHostCursorRequested);
2537 AssertRCReturn(rc, rc);
2538
2539 /*
2540 * On a resume, we send the capabilities changed message so
2541 * that listeners can sync their state again
2542 */
2543 Log(("vmmdevLoadState: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
2544 if (pThis->pDrv)
2545 {
2546 pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
2547 if (uVersion >= 10)
2548 pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
2549 /*fVisible=*/!!pThis->fHostCursorRequested,
2550 /*fAlpha=*/false,
2551 /*xHot=*/0, /*yHot=*/0,
2552 /*cx=*/0, /*cy=*/0,
2553 /*pvShape=*/NULL);
2554 }
2555
2556 /* Reestablish the acceleration status. */
2557 if ( pThis->u32VideoAccelEnabled
2558 && pThis->pDrv)
2559 {
2560 pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, !!pThis->u32VideoAccelEnabled, &pThis->pVMMDevRAMR3->vbvaMemory);
2561 }
2562
2563 if (pThis->fu32AdditionsOk)
2564 {
2565 LogRel(("Guest Additions information report: additionsVersion = 0x%08X, osType = 0x%08X\n",
2566 pThis->guestInfo.additionsVersion,
2567 pThis->guestInfo.osType));
2568 if (pThis->pDrv)
2569 pThis->pDrv->pfnUpdateGuestVersion(pThis->pDrv, &pThis->guestInfo);
2570 }
2571 if (pThis->pDrv)
2572 pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
2573
2574 return VINF_SUCCESS;
2575}
2576
2577/**
2578 * Load state done callback. Notify guest of restore event.
2579 *
2580 * @returns VBox status code.
2581 * @param pDevIns The device instance.
2582 * @param pSSM The handle to the saved state.
2583 */
2584static DECLCALLBACK(int) vmmdevLoadStateDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
2585{
2586 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
2587
2588#ifdef VBOX_WITH_HGCM
2589 int rc = vmmdevHGCMLoadStateDone(pThis, pSSM);
2590 AssertLogRelRCReturn(rc, rc);
2591#endif /* VBOX_WITH_HGCM */
2592
2593 VMMDevNotifyGuest(pThis, VMMDEV_EVENT_RESTORED);
2594
2595 return VINF_SUCCESS;
2596}
2597
2598/* -=-=-=-=- PDMDEVREG -=-=-=-=- */
2599
2600/**
2601 * (Re-)initializes the MMIO2 data.
2602 *
2603 * @param pThis Pointer to the VMMDev instance data.
2604 */
2605static void vmmdevInitRam(VMMDevState *pThis)
2606{
2607 memset(pThis->pVMMDevRAMR3, 0, sizeof(VMMDevMemory));
2608 pThis->pVMMDevRAMR3->u32Size = sizeof(VMMDevMemory);
2609 pThis->pVMMDevRAMR3->u32Version = VMMDEV_MEMORY_VERSION;
2610}
2611
2612/**
2613 * Reset notification.
2614 *
2615 * @returns VBox status.
2616 * @param pDrvIns The driver instance data.
2617 */
2618static DECLCALLBACK(void) vmmdevReset(PPDMDEVINS pDevIns)
2619{
2620 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
2621
2622 /*
2623 * Reset the mouse integration feature bits
2624 */
2625 if (pThis->mouseCapabilities & VMMDEV_MOUSE_GUEST_MASK)
2626 {
2627 pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_MASK;
2628 /* notify the connector */
2629 Log(("vmmdevReset: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
2630 pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
2631 }
2632 pThis->fHostCursorRequested = false;
2633
2634 pThis->hypervisorSize = 0;
2635
2636 pThis->u32HostEventFlags = 0;
2637
2638 /* re-initialize the VMMDev memory */
2639 if (pThis->pVMMDevRAMR3)
2640 vmmdevInitRam(pThis);
2641
2642 /* credentials have to go away (by default) */
2643 if (!pThis->fKeepCredentials)
2644 {
2645 memset(pThis->credentialsLogon.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
2646 memset(pThis->credentialsLogon.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
2647 memset(pThis->credentialsLogon.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
2648 }
2649 memset(pThis->credentialsJudge.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
2650 memset(pThis->credentialsJudge.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
2651 memset(pThis->credentialsJudge.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
2652
2653 /* Reset means that additions will report again. */
2654 const bool fVersionChanged = pThis->fu32AdditionsOk
2655 || pThis->guestInfo.additionsVersion
2656 || pThis->guestInfo.osType != VBOXOSTYPE_Unknown;
2657 if (fVersionChanged)
2658 Log(("vmmdevReset: fu32AdditionsOk=%d additionsVersion=%x osType=%#x\n",
2659 pThis->fu32AdditionsOk, pThis->guestInfo.additionsVersion, pThis->guestInfo.osType));
2660 pThis->fu32AdditionsOk = false;
2661 memset (&pThis->guestInfo, 0, sizeof (pThis->guestInfo));
2662
2663 /* clear pending display change request. */
2664 for (unsigned i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
2665 {
2666 DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[i];
2667 memset (&pRequest->lastReadDisplayChangeRequest, 0, sizeof (pRequest->lastReadDisplayChangeRequest));
2668 }
2669 pThis->displayChangeData.iCurrentMonitor = 0;
2670 pThis->displayChangeData.fGuestSentChangeEventAck = false;
2671
2672 /* disable seamless mode */
2673 pThis->fLastSeamlessEnabled = false;
2674
2675 /* disabled memory ballooning */
2676 pThis->u32LastMemoryBalloonSize = 0;
2677
2678 /* disabled statistics updating */
2679 pThis->u32LastStatIntervalSize = 0;
2680
2681 /* Clear the "HGCM event enabled" flag so the event can be automatically reenabled. */
2682 pThis->u32HGCMEnabled = 0;
2683
2684 /*
2685 * Clear the event variables.
2686 *
2687 * Note: The pThis->u32HostEventFlags is not cleared.
2688 * It is designed that way so host events do not
2689 * depend on guest resets.
2690 */
2691 pThis->u32GuestFilterMask = 0;
2692 pThis->u32NewGuestFilterMask = 0;
2693 pThis->fNewGuestFilterMask = 0;
2694
2695 /* This is the default, as Windows and OS/2 guests take this for granted. (Actually, neither does...) */
2696 /** @todo change this when we next bump the interface version */
2697 const bool fCapsChanged = pThis->guestCaps != VMMDEV_GUEST_SUPPORTS_GRAPHICS;
2698 if (fCapsChanged)
2699 Log(("vmmdevReset: fCapsChanged=%#x -> %#x\n", pThis->guestCaps, VMMDEV_GUEST_SUPPORTS_GRAPHICS));
2700 pThis->guestCaps = VMMDEV_GUEST_SUPPORTS_GRAPHICS; /** @todo r=bird: why? I cannot see this being done at construction?*/
2701
2702 /*
2703 * Call the update functions as required.
2704 */
2705 if (fVersionChanged)
2706 pThis->pDrv->pfnUpdateGuestVersion(pThis->pDrv, &pThis->guestInfo);
2707 if (fCapsChanged)
2708 pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
2709}
2710
2711
2712/**
2713 * @interface_method_impl{PDMDEVREG,pfnConstruct}
2714 */
2715static DECLCALLBACK(int) vmmdevConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
2716{
2717 int rc;
2718 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
2719
2720 Assert(iInstance == 0);
2721 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
2722
2723 /*
2724 * Validate and read the configuration.
2725 */
2726 if (!CFGMR3AreValuesValid(pCfg,
2727 "GetHostTimeDisabled\0"
2728 "BackdoorLogDisabled\0"
2729 "KeepCredentials\0"
2730 "HeapEnabled\0"
2731 ))
2732 return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
2733
2734 rc = CFGMR3QueryBoolDef(pCfg, "GetHostTimeDisabled", &pThis->fGetHostTimeDisabled, false);
2735 if (RT_FAILURE(rc))
2736 return PDMDEV_SET_ERROR(pDevIns, rc,
2737 N_("Configuration error: Failed querying \"GetHostTimeDisabled\" as a boolean"));
2738
2739 rc = CFGMR3QueryBoolDef(pCfg, "BackdoorLogDisabled", &pThis->fBackdoorLogDisabled, false);
2740 if (RT_FAILURE(rc))
2741 return PDMDEV_SET_ERROR(pDevIns, rc,
2742 N_("Configuration error: Failed querying \"BackdoorLogDisabled\" as a boolean"));
2743
2744 rc = CFGMR3QueryBoolDef(pCfg, "KeepCredentials", &pThis->fKeepCredentials, false);
2745 if (RT_FAILURE(rc))
2746 return PDMDEV_SET_ERROR(pDevIns, rc,
2747 N_("Configuration error: Failed querying \"KeepCredentials\" as a boolean"));
2748
2749 rc = CFGMR3QueryBoolDef(pCfg, "HeapEnabled", &pThis->fHeapEnabled, true);
2750 if (RT_FAILURE(rc))
2751 return PDMDEV_SET_ERROR(pDevIns, rc,
2752 N_("Configuration error: Failed querying \"HeapEnabled\" as a boolean"));
2753
2754 /*
2755 * Initialize data (most of it anyway).
2756 */
2757 /* Save PDM device instance data for future reference. */
2758 pThis->pDevIns = pDevIns;
2759
2760 /* PCI vendor, just a free bogus value */
2761 pThis->dev.config[0x00] = 0xee;
2762 pThis->dev.config[0x01] = 0x80;
2763 /* device ID */
2764 pThis->dev.config[0x02] = 0xfe;
2765 pThis->dev.config[0x03] = 0xca;
2766 /* class sub code (other type of system peripheral) */
2767 pThis->dev.config[0x0a] = 0x80;
2768 /* class base code (base system peripheral) */
2769 pThis->dev.config[0x0b] = 0x08;
2770 /* header type */
2771 pThis->dev.config[0x0e] = 0x00;
2772 /* interrupt on pin 0 */
2773 pThis->dev.config[0x3d] = 0x01;
2774
2775 /*
2776 * Interfaces
2777 */
2778 /* IBase */
2779 pThis->IBase.pfnQueryInterface = vmmdevPortQueryInterface;
2780
2781 /* VMMDev port */
2782 pThis->IPort.pfnQueryAbsoluteMouse = vmmdevQueryAbsoluteMouse;
2783 pThis->IPort.pfnSetAbsoluteMouse = vmmdevSetAbsoluteMouse;
2784 pThis->IPort.pfnQueryMouseCapabilities = vmmdevQueryMouseCapabilities;
2785 pThis->IPort.pfnSetMouseCapabilities = vmmdevSetMouseCapabilities;
2786 pThis->IPort.pfnRequestDisplayChange = vmmdevRequestDisplayChange;
2787 pThis->IPort.pfnSetCredentials = vmmdevSetCredentials;
2788 pThis->IPort.pfnVBVAChange = vmmdevVBVAChange;
2789 pThis->IPort.pfnRequestSeamlessChange = vmmdevRequestSeamlessChange;
2790 pThis->IPort.pfnSetMemoryBalloon = vmmdevSetMemoryBalloon;
2791 pThis->IPort.pfnSetStatisticsInterval = vmmdevSetStatisticsInterval;
2792 pThis->IPort.pfnVRDPChange = vmmdevVRDPChange;
2793 pThis->IPort.pfnCpuHotUnplug = vmmdevCpuHotUnplug;
2794 pThis->IPort.pfnCpuHotPlug = vmmdevCpuHotPlug;
2795
2796 /* Shared folder LED */
2797 pThis->SharedFolders.Led.u32Magic = PDMLED_MAGIC;
2798 pThis->SharedFolders.ILeds.pfnQueryStatusLed = vmmdevQueryStatusLed;
2799
2800#ifdef VBOX_WITH_HGCM
2801 /* HGCM port */
2802 pThis->IHGCMPort.pfnCompleted = hgcmCompleted;
2803#endif
2804
2805 /** @todo convert this into a config parameter like we do everywhere else! */
2806 pThis->cbGuestRAM = MMR3PhysGetRamSize(PDMDevHlpGetVM(pDevIns));
2807
2808 /*
2809 * Create the critical section for the device.
2810 */
2811 rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, RT_SRC_POS, "VMMDev");
2812 AssertRCReturn(rc, rc);
2813 /* Later: pDevIns->pCritSectR3 = &pThis->CritSect; */
2814
2815 /*
2816 * Register the backdoor logging port
2817 */
2818 rc = PDMDevHlpIOPortRegister(pDevIns, RTLOG_DEBUG_PORT, 1, NULL, vmmdevBackdoorLog, NULL, NULL, NULL, "VMMDev backdoor logging");
2819 AssertRCReturn(rc, rc);
2820
2821#ifdef TIMESYNC_BACKDOOR
2822 /*
2823 * Alternative timesync source (temporary!)
2824 */
2825 rc = PDMDevHlpIOPortRegister(pDevIns, 0x505, 1, NULL, vmmdevTimesyncBackdoorWrite, vmmdevTimesyncBackdoorRead, NULL, NULL, "VMMDev timesync backdoor");
2826 AssertRCReturn(rc, rc);
2827#endif
2828
2829 /*
2830 * Allocate and initialize the MMIO2 memory.
2831 */
2832 rc = PDMDevHlpMMIO2Register(pDevIns, 1 /*iRegion*/, VMMDEV_RAM_SIZE, 0 /*fFlags*/, (void **)&pThis->pVMMDevRAMR3, "VMMDev");
2833 if (RT_FAILURE(rc))
2834 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
2835 N_("Failed to allocate %u bytes of memory for the VMM device"), VMMDEV_RAM_SIZE);
2836 vmmdevInitRam(pThis);
2837
2838 if (pThis->fHeapEnabled)
2839 {
2840 rc = PDMDevHlpMMIO2Register(pDevIns, 2 /*iRegion*/, VMMDEV_HEAP_SIZE, 0 /*fFlags*/, (void **)&pThis->pVMMDevHeapR3, "VMMDev Heap");
2841 if (RT_FAILURE(rc))
2842 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
2843 N_("Failed to allocate %u bytes of memory for the VMM device heap"), PAGE_SIZE);
2844 }
2845
2846 /*
2847 * Register the PCI device.
2848 */
2849 rc = PDMDevHlpPCIRegister(pDevIns, &pThis->dev);
2850 if (RT_FAILURE(rc))
2851 return rc;
2852 if (pThis->dev.devfn == 32 || iInstance != 0)
2853 Log(("!!WARNING!!: pThis->dev.devfn=%d (ignore if testcase or no started by Main)\n", pThis->dev.devfn));
2854 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 0x20, PCI_ADDRESS_SPACE_IO, vmmdevIOPortRegionMap);
2855 if (RT_FAILURE(rc))
2856 return rc;
2857 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 1, VMMDEV_RAM_SIZE, PCI_ADDRESS_SPACE_MEM, vmmdevIORAMRegionMap);
2858 if (RT_FAILURE(rc))
2859 return rc;
2860 if (pThis->fHeapEnabled)
2861 {
2862 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2, VMMDEV_HEAP_SIZE, PCI_ADDRESS_SPACE_MEM_PREFETCH, vmmdevIORAMRegionMap);
2863 if (RT_FAILURE(rc))
2864 return rc;
2865 }
2866
2867 /*
2868 * Get the corresponding connector interface
2869 */
2870 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "VMM Driver Port");
2871 if (RT_SUCCESS(rc))
2872 {
2873 pThis->pDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIVMMDEVCONNECTOR);
2874 AssertMsgReturn(pThis->pDrv, ("LUN #0 doesn't have a VMMDev connector interface!\n"), VERR_PDM_MISSING_INTERFACE);
2875#ifdef VBOX_WITH_HGCM
2876 pThis->pHGCMDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIHGCMCONNECTOR);
2877 if (!pThis->pHGCMDrv)
2878 {
2879 Log(("LUN #0 doesn't have a HGCM connector interface, HGCM is not supported. rc=%Rrc\n", rc));
2880 /* this is not actually an error, just means that there is no support for HGCM */
2881 }
2882#endif
2883 /* Query the initial balloon size. */
2884 rc = pThis->pDrv->pfnQueryBalloonSize(pThis->pDrv, &pThis->u32MemoryBalloonSize);
2885 AssertRC(rc);
2886 Log(("Initial balloon size %x\n", pThis->u32MemoryBalloonSize));
2887 }
2888 else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
2889 {
2890 Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
2891 rc = VINF_SUCCESS;
2892 }
2893 else
2894 AssertMsgFailedReturn(("Failed to attach LUN #0! rc=%Rrc\n", rc), rc);
2895
2896 /*
2897 * Attach status driver for shared folders (optional).
2898 */
2899 PPDMIBASE pBase;
2900 rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
2901 if (RT_SUCCESS(rc))
2902 pThis->SharedFolders.pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
2903 else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
2904 {
2905 AssertMsgFailed(("Failed to attach to status driver. rc=%Rrc\n", rc));
2906 return rc;
2907 }
2908
2909 /*
2910 * Register saved state and init the HGCM CmdList critsect.
2911 */
2912 rc = PDMDevHlpSSMRegisterEx(pDevIns, VMMDEV_SAVED_STATE_VERSION, sizeof(*pThis), NULL,
2913 NULL, vmmdevLiveExec, NULL,
2914 NULL, vmmdevSaveExec, NULL,
2915 NULL, vmmdevLoadExec, vmmdevLoadStateDone);
2916 AssertRCReturn(rc, rc);
2917
2918#ifdef VBOX_WITH_HGCM
2919 pThis->pHGCMCmdList = NULL;
2920 rc = RTCritSectInit(&pThis->critsectHGCMCmdList);
2921 AssertRCReturn(rc, rc);
2922 pThis->u32HGCMEnabled = 0;
2923#endif /* VBOX_WITH_HGCM */
2924 /* In this version of VirtualBox the GUI checks whether "needs host cursor"
2925 * changes. */
2926 pThis->mouseCapabilities |= VMMDEV_MOUSE_HOST_RECHECKS_NEEDS_HOST_CURSOR;
2927
2928 PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatMemBalloonChunks, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT, "Memory balloon size", "/Devices/VMMDev/BalloonChunks");
2929
2930 return rc;
2931}
2932
2933/**
2934 * The device registration structure.
2935 */
2936extern "C" const PDMDEVREG g_DeviceVMMDev =
2937{
2938 /* u32Version */
2939 PDM_DEVREG_VERSION,
2940 /* szName */
2941 "VMMDev",
2942 /* szRCMod */
2943 "",
2944 /* szR0Mod */
2945 "",
2946 /* pszDescription */
2947 "VirtualBox VMM Device\n",
2948 /* fFlags */
2949 PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT | PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT,
2950 /* fClass */
2951 PDM_DEVREG_CLASS_VMM_DEV,
2952 /* cMaxInstances */
2953 1,
2954 /* cbInstance */
2955 sizeof(VMMDevState),
2956 /* pfnConstruct */
2957 vmmdevConstruct,
2958 /* pfnDestruct */
2959 NULL,
2960 /* pfnRelocate */
2961 NULL,
2962 /* pfnIOCtl */
2963 NULL,
2964 /* pfnPowerOn */
2965 NULL,
2966 /* pfnReset */
2967 vmmdevReset,
2968 /* pfnSuspend */
2969 NULL,
2970 /* pfnResume */
2971 NULL,
2972 /* pfnAttach */
2973 NULL,
2974 /* pfnDetach */
2975 NULL,
2976 /* pfnQueryInterface. */
2977 NULL,
2978 /* pfnInitComplete */
2979 NULL,
2980 /* pfnPowerOff */
2981 NULL,
2982 /* pfnSoftReset */
2983 NULL,
2984 /* u32VersionEnd */
2985 PDM_DEVREG_VERSION
2986};
2987#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
2988
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