VirtualBox

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

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

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

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