VirtualBox

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

Last change on this file since 28739 was 28434, checked in by vboxsync, 15 years ago

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