VirtualBox

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

最後變更 在這個檔案從28800是 28800,由 vboxsync 提交於 15 年 前

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette