VirtualBox

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

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

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

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