VirtualBox

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

Last change on this file since 21457 was 21457, checked in by vboxsync, 16 years ago

VMMDev: Adjusted and implemented GetHostVersion.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 98.6 KB
Line 
1/* $Id: VMMDev.cpp 21457 2009-07-09 20:40:08Z 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 = 0;
603 if (pThis->mouseCapabilities & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE)
604 {
605 mouseStatus->mouseFeatures |= VMMDEV_MOUSE_HOST_CAN_ABSOLUTE;
606 }
607 if (pThis->mouseCapabilities & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE)
608 {
609 mouseStatus->mouseFeatures |= VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE;
610 }
611 if (pThis->mouseCapabilities & VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER)
612 {
613 mouseStatus->mouseFeatures |= VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER;
614 }
615 mouseStatus->pointerXPos = pThis->mouseXAbs;
616 mouseStatus->pointerYPos = pThis->mouseYAbs;
617 Log2(("returning mouse status: features = %d, absX = %d, absY = %d\n", mouseStatus->mouseFeatures,
618 mouseStatus->pointerXPos, mouseStatus->pointerYPos));
619 pRequestHeader->rc = VINF_SUCCESS;
620 }
621 break;
622 }
623
624 /*
625 * Set mouse information
626 */
627 case VMMDevReq_SetMouseStatus:
628 {
629 if (pRequestHeader->size != sizeof(VMMDevReqMouseStatus))
630 {
631 AssertMsgFailed(("VMMDev mouse status structure has invalid size %d (%#x) version=%d!\n",
632 pRequestHeader->size, pRequestHeader->size, pRequestHeader->size, pRequestHeader->version));
633 pRequestHeader->rc = VERR_INVALID_PARAMETER;
634 }
635 else
636 {
637 bool bCapsChanged = false;
638
639 VMMDevReqMouseStatus *mouseStatus = (VMMDevReqMouseStatus*)pRequestHeader;
640
641 /* check if the guest wants absolute coordinates */
642 if (mouseStatus->mouseFeatures & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE)
643 {
644 /* set the capability flag and the changed flag if it's actually a change */
645 if (!(pThis->mouseCapabilities & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE))
646 {
647 pThis->mouseCapabilities |= VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE;
648 bCapsChanged = true;
649 LogRel(("Guest requests mouse pointer integration\n"));
650 }
651 } else
652 {
653 if (pThis->mouseCapabilities & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE)
654 {
655 pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE;
656 bCapsChanged = true;
657 LogRel(("Guest disables mouse pointer integration\n"));
658 }
659 }
660 if (mouseStatus->mouseFeatures & VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR)
661 pThis->mouseCapabilities |= VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR;
662 else
663 pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR;
664 if (mouseStatus->mouseFeatures & VMMDEV_MOUSE_GUEST_USES_VMMDEV)
665 pThis->mouseCapabilities |= VMMDEV_MOUSE_GUEST_USES_VMMDEV;
666 else
667 pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_USES_VMMDEV;
668
669 /*
670 * Notify connector if something has changed
671 */
672 if (bCapsChanged)
673 {
674 Log(("VMMDevReq_SetMouseStatus: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
675 pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
676 }
677 pRequestHeader->rc = VINF_SUCCESS;
678 }
679
680 break;
681 }
682
683 /*
684 * Set a new mouse pointer shape
685 */
686 case VMMDevReq_SetPointerShape:
687 {
688 if (pRequestHeader->size < sizeof(VMMDevReqMousePointer))
689 {
690 AssertMsg(pRequestHeader->size == 0x10028 && pRequestHeader->version == 10000, /* don't bitch about legacy!!! */
691 ("VMMDev mouse shape structure has invalid size %d (%#x) version=%d!\n",
692 pRequestHeader->size, pRequestHeader->size, pRequestHeader->size, pRequestHeader->version));
693 pRequestHeader->rc = VERR_INVALID_PARAMETER;
694 }
695 else
696 {
697 VMMDevReqMousePointer *pointerShape = (VMMDevReqMousePointer*)pRequestHeader;
698
699 bool fVisible = (pointerShape->fFlags & VBOX_MOUSE_POINTER_VISIBLE) != 0;
700 bool fAlpha = (pointerShape->fFlags & VBOX_MOUSE_POINTER_ALPHA) != 0;
701 bool fShape = (pointerShape->fFlags & VBOX_MOUSE_POINTER_SHAPE) != 0;
702
703 Log(("VMMDevReq_SetPointerShape: visible: %d, alpha: %d, shape = %d, width: %d, height: %d\n",
704 fVisible, fAlpha, fShape, pointerShape->width, pointerShape->height));
705
706 if (pRequestHeader->size == sizeof(VMMDevReqMousePointer))
707 {
708 /* The guest did not provide the shape actually. */
709 fShape = false;
710 }
711
712 /* forward call to driver */
713 if (fShape)
714 {
715 pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
716 fVisible,
717 fAlpha,
718 pointerShape->xHot, pointerShape->yHot,
719 pointerShape->width, pointerShape->height,
720 pointerShape->pointerData);
721 }
722 else
723 {
724 pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
725 fVisible,
726 0,
727 0, 0,
728 0, 0,
729 NULL);
730 }
731 pRequestHeader->rc = VINF_SUCCESS;
732 }
733 break;
734 }
735
736 /*
737 * Query the system time from the host
738 */
739 case VMMDevReq_GetHostTime:
740 {
741 if (pRequestHeader->size != sizeof(VMMDevReqHostTime))
742 {
743 AssertMsgFailed(("VMMDev host time structure has invalid size!\n"));
744 pRequestHeader->rc = VERR_INVALID_PARAMETER;
745 }
746 else if (RT_UNLIKELY(pThis->fGetHostTimeDisabled))
747 pRequestHeader->rc = VERR_NOT_SUPPORTED;
748 else
749 {
750 VMMDevReqHostTime *hostTimeReq = (VMMDevReqHostTime*)pRequestHeader;
751 RTTIMESPEC now;
752 hostTimeReq->time = RTTimeSpecGetMilli(PDMDevHlpUTCNow(pDevIns, &now));
753 pRequestHeader->rc = VINF_SUCCESS;
754 }
755 break;
756 }
757
758 /*
759 * Query information about the hypervisor
760 */
761 case VMMDevReq_GetHypervisorInfo:
762 {
763 if (pRequestHeader->size != sizeof(VMMDevReqHypervisorInfo))
764 {
765 AssertMsgFailed(("VMMDev hypervisor info structure has invalid size!\n"));
766 pRequestHeader->rc = VERR_INVALID_PARAMETER;
767 }
768 else
769 {
770 VMMDevReqHypervisorInfo *hypervisorInfo = (VMMDevReqHypervisorInfo*)pRequestHeader;
771 PVM pVM = PDMDevHlpGetVM(pDevIns);
772 pRequestHeader->rc = PGMR3MappingsSize(pVM, &hypervisorInfo->hypervisorSize);
773 }
774 break;
775 }
776
777 /*
778 * Set hypervisor information
779 */
780 case VMMDevReq_SetHypervisorInfo:
781 {
782 if (pRequestHeader->size != sizeof(VMMDevReqHypervisorInfo))
783 {
784 AssertMsgFailed(("VMMDev hypervisor info structure has invalid size!\n"));
785 pRequestHeader->rc = VERR_INVALID_PARAMETER;
786 }
787 else
788 {
789 VMMDevReqHypervisorInfo *hypervisorInfo = (VMMDevReqHypervisorInfo*)pRequestHeader;
790 PVM pVM = PDMDevHlpGetVM(pDevIns);
791 if (hypervisorInfo->hypervisorStart == 0)
792 pRequestHeader->rc = PGMR3MappingsUnfix(pVM);
793 else
794 {
795 /* only if the client has queried the size before! */
796 uint32_t mappingsSize;
797 pRequestHeader->rc = PGMR3MappingsSize(pVM, &mappingsSize);
798 if (RT_SUCCESS(pRequestHeader->rc) && hypervisorInfo->hypervisorSize == mappingsSize)
799 {
800 /* new reservation */
801 pRequestHeader->rc = PGMR3MappingsFix(pVM, hypervisorInfo->hypervisorStart,
802 hypervisorInfo->hypervisorSize);
803 LogRel(("Guest reported fixed hypervisor window at 0x%p (size = 0x%x, rc = %Rrc)\n",
804 (uintptr_t)hypervisorInfo->hypervisorStart,
805 hypervisorInfo->hypervisorSize,
806 pRequestHeader->rc));
807 }
808 }
809 }
810 break;
811 }
812
813 /*
814 * Set the system power status
815 */
816 case VMMDevReq_SetPowerStatus:
817 {
818 if (pRequestHeader->size != sizeof(VMMDevPowerStateRequest))
819 {
820 AssertMsgFailed(("VMMDev power state request structure has invalid size!\n"));
821 pRequestHeader->rc = VERR_INVALID_PARAMETER;
822 }
823 else
824 {
825 VMMDevPowerStateRequest *powerStateRequest = (VMMDevPowerStateRequest*)pRequestHeader;
826 switch(powerStateRequest->powerState)
827 {
828 case VMMDevPowerState_Pause:
829 {
830 LogRel(("Guest requests the VM to be suspended (paused)\n"));
831 pRequestHeader->rc = rcRet = PDMDevHlpVMSuspend(pDevIns);
832 break;
833 }
834
835 case VMMDevPowerState_PowerOff:
836 {
837 LogRel(("Guest requests the VM to be turned off\n"));
838 pRequestHeader->rc = rcRet = PDMDevHlpVMPowerOff(pDevIns);
839 break;
840 }
841
842 case VMMDevPowerState_SaveState:
843 {
844 /** @todo no API for that yet */
845 pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
846 break;
847 }
848
849 default:
850 AssertMsgFailed(("VMMDev invalid power state request: %d\n", powerStateRequest->powerState));
851 pRequestHeader->rc = VERR_INVALID_PARAMETER;
852 break;
853 }
854 }
855 break;
856 }
857
858 /*
859 * Get display change request
860 */
861 case VMMDevReq_GetDisplayChangeRequest:
862 {
863 if (pRequestHeader->size != sizeof(VMMDevDisplayChangeRequest))
864 {
865 /* Assert only if the size also not equal to a previous version size to prevent
866 * assertion with old additions.
867 */
868 AssertMsg(pRequestHeader->size == sizeof(VMMDevDisplayChangeRequest) - sizeof (uint32_t),
869 ("VMMDev display change request structure has invalid size!\n"));
870 pRequestHeader->rc = VERR_INVALID_PARAMETER;
871 }
872 else
873 {
874 VMMDevDisplayChangeRequest *displayChangeRequest = (VMMDevDisplayChangeRequest*)pRequestHeader;
875
876 if (displayChangeRequest->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
877 {
878 /* Remember which resolution the client has queried, subsequent reads will return the same values. */
879 pThis->lastReadDisplayChangeRequest = pThis->displayChangeRequest;
880 }
881
882 /* just pass on the information */
883 Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d\n",
884 pThis->displayChangeRequest.xres, pThis->displayChangeRequest.yres, pThis->displayChangeRequest.bpp));
885 displayChangeRequest->xres = pThis->lastReadDisplayChangeRequest.xres;
886 displayChangeRequest->yres = pThis->lastReadDisplayChangeRequest.yres;
887 displayChangeRequest->bpp = pThis->lastReadDisplayChangeRequest.bpp;
888
889 pRequestHeader->rc = VINF_SUCCESS;
890 }
891 break;
892 }
893
894 case VMMDevReq_GetDisplayChangeRequest2:
895 {
896 if (pRequestHeader->size != sizeof(VMMDevDisplayChangeRequest2))
897 {
898 pRequestHeader->rc = VERR_INVALID_PARAMETER;
899 }
900 else
901 {
902 VMMDevDisplayChangeRequest2 *displayChangeRequest = (VMMDevDisplayChangeRequest2*)pRequestHeader;
903
904 if (displayChangeRequest->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
905 {
906 /* Remember which resolution the client has queried, subsequent reads will return the same values. */
907 pThis->lastReadDisplayChangeRequest = pThis->displayChangeRequest;
908 }
909
910 /* just pass on the information */
911 Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d at %d\n",
912 pThis->displayChangeRequest.xres, pThis->displayChangeRequest.yres, pThis->displayChangeRequest.bpp, pThis->displayChangeRequest.display));
913 displayChangeRequest->xres = pThis->lastReadDisplayChangeRequest.xres;
914 displayChangeRequest->yres = pThis->lastReadDisplayChangeRequest.yres;
915 displayChangeRequest->bpp = pThis->lastReadDisplayChangeRequest.bpp;
916 displayChangeRequest->display = pThis->lastReadDisplayChangeRequest.display;
917
918 pRequestHeader->rc = VINF_SUCCESS;
919 }
920 break;
921 }
922
923 /*
924 * Query whether the given video mode is supported
925 */
926 case VMMDevReq_VideoModeSupported:
927 {
928 if (pRequestHeader->size != sizeof(VMMDevVideoModeSupportedRequest))
929 {
930 AssertMsgFailed(("VMMDev video mode supported request structure has invalid size!\n"));
931 pRequestHeader->rc = VERR_INVALID_PARAMETER;
932 }
933 else
934 {
935 VMMDevVideoModeSupportedRequest *videoModeSupportedRequest = (VMMDevVideoModeSupportedRequest*)pRequestHeader;
936 /* forward the call */
937 pRequestHeader->rc = pThis->pDrv->pfnVideoModeSupported(pThis->pDrv,
938 videoModeSupportedRequest->width,
939 videoModeSupportedRequest->height,
940 videoModeSupportedRequest->bpp,
941 &videoModeSupportedRequest->fSupported);
942 }
943 break;
944 }
945
946 /*
947 * Query the height reduction in pixels
948 */
949 case VMMDevReq_GetHeightReduction:
950 {
951 if (pRequestHeader->size != sizeof(VMMDevGetHeightReductionRequest))
952 {
953 AssertMsgFailed(("VMMDev height reduction request structure has invalid size!\n"));
954 pRequestHeader->rc = VERR_INVALID_PARAMETER;
955 }
956 else
957 {
958 VMMDevGetHeightReductionRequest *heightReductionRequest = (VMMDevGetHeightReductionRequest*)pRequestHeader;
959 /* forward the call */
960 pRequestHeader->rc = pThis->pDrv->pfnGetHeightReduction(pThis->pDrv,
961 &heightReductionRequest->heightReduction);
962 }
963 break;
964 }
965
966 /*
967 * Acknowledge VMMDev events
968 */
969 case VMMDevReq_AcknowledgeEvents:
970 {
971 if (pRequestHeader->size != sizeof(VMMDevEvents))
972 {
973 AssertMsgFailed(("VMMDevReq_AcknowledgeEvents structure has invalid size!\n"));
974 pRequestHeader->rc = VERR_INVALID_PARAMETER;
975 }
976 else
977 {
978 if (VBOX_GUEST_ADDITIONS_VERSION_1_03 (pThis))
979 {
980 vmmdevSetIRQ_Legacy_EMT (pThis);
981 }
982 else
983 {
984 VMMDevEvents *pAckRequest;
985
986 if (pThis->fNewGuestFilterMask)
987 {
988 pThis->fNewGuestFilterMask = false;
989 pThis->u32GuestFilterMask = pThis->u32NewGuestFilterMask;
990 }
991
992 pAckRequest = (VMMDevEvents *)pRequestHeader;
993 pAckRequest->events =
994 pThis->u32HostEventFlags & pThis->u32GuestFilterMask;
995
996 pThis->u32HostEventFlags &= ~pThis->u32GuestFilterMask;
997 pThis->pVMMDevRAMR3->V.V1_04.fHaveEvents = false;
998 PDMDevHlpPCISetIrqNoWait (pThis->pDevIns, 0, 0);
999 }
1000 pRequestHeader->rc = VINF_SUCCESS;
1001 }
1002 break;
1003 }
1004
1005 /*
1006 * Change guest filter mask
1007 */
1008 case VMMDevReq_CtlGuestFilterMask:
1009 {
1010 if (pRequestHeader->size != sizeof(VMMDevCtlGuestFilterMask))
1011 {
1012 AssertMsgFailed(("VMMDevReq_AcknowledgeEvents structure has invalid size!\n"));
1013 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1014 }
1015 else
1016 {
1017 VMMDevCtlGuestFilterMask *pCtlMaskRequest;
1018
1019 pCtlMaskRequest = (VMMDevCtlGuestFilterMask *)pRequestHeader;
1020 /* The HGCM events are enabled by the VMMDev device automatically when any
1021 * HGCM command is issued. The guest then can not disable these events.
1022 */
1023 vmmdevCtlGuestFilterMask_EMT (pThis,
1024 pCtlMaskRequest->u32OrMask,
1025 pCtlMaskRequest->u32NotMask & ~VMMDEV_EVENT_HGCM);
1026 pRequestHeader->rc = VINF_SUCCESS;
1027
1028 }
1029 break;
1030 }
1031
1032#ifdef VBOX_WITH_HGCM
1033 /*
1034 * Process HGCM request
1035 */
1036 case VMMDevReq_HGCMConnect:
1037 {
1038 if (pRequestHeader->size < sizeof(VMMDevHGCMConnect))
1039 {
1040 AssertMsgFailed(("VMMDevReq_HGCMConnect structure has invalid size!\n"));
1041 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1042 }
1043 else if (!pThis->pHGCMDrv)
1044 {
1045 Log(("VMMDevReq_HGCMConnect HGCM Connector is NULL!\n"));
1046 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1047 }
1048 else
1049 {
1050 VMMDevHGCMConnect *pHGCMConnect = (VMMDevHGCMConnect *)pRequestHeader;
1051
1052 Log(("VMMDevReq_HGCMConnect\n"));
1053
1054 pRequestHeader->rc = vmmdevHGCMConnect (pThis, pHGCMConnect, (RTGCPHYS)u32);
1055 }
1056 break;
1057 }
1058
1059 case VMMDevReq_HGCMDisconnect:
1060 {
1061 if (pRequestHeader->size < sizeof(VMMDevHGCMDisconnect))
1062 {
1063 AssertMsgFailed(("VMMDevReq_HGCMDisconnect structure has invalid size!\n"));
1064 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1065 }
1066 else if (!pThis->pHGCMDrv)
1067 {
1068 Log(("VMMDevReq_HGCMDisconnect HGCM Connector is NULL!\n"));
1069 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1070 }
1071 else
1072 {
1073 VMMDevHGCMDisconnect *pHGCMDisconnect = (VMMDevHGCMDisconnect *)pRequestHeader;
1074
1075 Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
1076 pRequestHeader->rc = vmmdevHGCMDisconnect (pThis, pHGCMDisconnect, (RTGCPHYS)u32);
1077 }
1078 break;
1079 }
1080
1081#ifdef VBOX_WITH_64_BITS_GUESTS
1082 case VMMDevReq_HGCMCall32:
1083 case VMMDevReq_HGCMCall64:
1084#else
1085 case VMMDevReq_HGCMCall:
1086#endif /* VBOX_WITH_64_BITS_GUESTS */
1087 {
1088 if (pRequestHeader->size < sizeof(VMMDevHGCMCall))
1089 {
1090 AssertMsgFailed(("VMMDevReq_HGCMCall structure has invalid size!\n"));
1091 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1092 }
1093 else if (!pThis->pHGCMDrv)
1094 {
1095 Log(("VMMDevReq_HGCMCall HGCM Connector is NULL!\n"));
1096 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1097 }
1098 else
1099 {
1100 VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)pRequestHeader;
1101
1102 Log2(("VMMDevReq_HGCMCall: sizeof (VMMDevHGCMRequest) = %04X\n", sizeof (VMMDevHGCMCall)));
1103 Log2(("%.*Rhxd\n", pRequestHeader->size, pRequestHeader));
1104
1105#ifdef VBOX_WITH_64_BITS_GUESTS
1106 bool f64Bits = (pRequestHeader->requestType == VMMDevReq_HGCMCall64);
1107#else
1108 bool f64Bits = false;
1109#endif /* VBOX_WITH_64_BITS_GUESTS */
1110
1111 pRequestHeader->rc = vmmdevHGCMCall (pThis, pHGCMCall, requestHeader.size, (RTGCPHYS)u32, f64Bits);
1112 }
1113 break;
1114 }
1115#endif /* VBOX_WITH_HGCM */
1116
1117 case VMMDevReq_HGCMCancel:
1118 {
1119 if (pRequestHeader->size < sizeof(VMMDevHGCMCancel))
1120 {
1121 AssertMsgFailed(("VMMDevReq_HGCMCancel structure has invalid size!\n"));
1122 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1123 }
1124 else if (!pThis->pHGCMDrv)
1125 {
1126 Log(("VMMDevReq_HGCMCancel HGCM Connector is NULL!\n"));
1127 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1128 }
1129 else
1130 {
1131 VMMDevHGCMCancel *pHGCMCancel = (VMMDevHGCMCancel *)pRequestHeader;
1132
1133 Log(("VMMDevReq_VMMDevHGCMCancel\n"));
1134 pRequestHeader->rc = vmmdevHGCMCancel (pThis, pHGCMCancel, (RTGCPHYS)u32);
1135 }
1136 break;
1137 }
1138
1139 case VMMDevReq_VideoAccelEnable:
1140 {
1141 if (pRequestHeader->size < sizeof(VMMDevVideoAccelEnable))
1142 {
1143 Log(("VMMDevReq_VideoAccelEnable request size too small!!!\n"));
1144 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1145 }
1146 else if (!pThis->pDrv)
1147 {
1148 Log(("VMMDevReq_VideoAccelEnable Connector is NULL!!!\n"));
1149 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1150 }
1151 else
1152 {
1153 VMMDevVideoAccelEnable *ptr = (VMMDevVideoAccelEnable *)pRequestHeader;
1154
1155 if (ptr->cbRingBuffer != VBVA_RING_BUFFER_SIZE)
1156 {
1157 /* The guest driver seems compiled with another headers. */
1158 Log(("VMMDevReq_VideoAccelEnable guest ring buffer size %d, should be %d!!!\n", ptr->cbRingBuffer, VBVA_RING_BUFFER_SIZE));
1159 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1160 }
1161 else
1162 {
1163 /* The request is correct. */
1164 ptr->fu32Status |= VBVA_F_STATUS_ACCEPTED;
1165
1166 LogFlow(("VMMDevReq_VideoAccelEnable ptr->u32Enable = %d\n", ptr->u32Enable));
1167
1168 pRequestHeader->rc = ptr->u32Enable?
1169 pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, true, &pThis->pVMMDevRAMR3->vbvaMemory):
1170 pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, false, NULL);
1171
1172 if ( ptr->u32Enable
1173 && RT_SUCCESS (pRequestHeader->rc))
1174 {
1175 ptr->fu32Status |= VBVA_F_STATUS_ENABLED;
1176
1177 /* Remember that guest successfully enabled acceleration.
1178 * We need to reestablish it on restoring the VM from saved state.
1179 */
1180 pThis->u32VideoAccelEnabled = 1;
1181 }
1182 else
1183 {
1184 /* The acceleration was not enabled. Remember that. */
1185 pThis->u32VideoAccelEnabled = 0;
1186 }
1187 }
1188 }
1189 break;
1190 }
1191
1192 case VMMDevReq_VideoAccelFlush:
1193 {
1194 if (pRequestHeader->size < sizeof(VMMDevVideoAccelFlush))
1195 {
1196 AssertMsgFailed(("VMMDevReq_VideoAccelFlush request size too small.\n"));
1197 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1198 }
1199 else if (!pThis->pDrv)
1200 {
1201 Log(("VMMDevReq_VideoAccelFlush Connector is NULL!\n"));
1202 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1203 }
1204 else
1205 {
1206 pThis->pDrv->pfnVideoAccelFlush (pThis->pDrv);
1207
1208 pRequestHeader->rc = VINF_SUCCESS;
1209 }
1210 break;
1211 }
1212
1213 case VMMDevReq_VideoSetVisibleRegion:
1214 {
1215 if (pRequestHeader->size < sizeof(VMMDevVideoSetVisibleRegion))
1216 {
1217 Log(("VMMDevReq_VideoSetVisibleRegion request size too small!!!\n"));
1218 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1219 }
1220 else if (!pThis->pDrv)
1221 {
1222 Log(("VMMDevReq_VideoSetVisibleRegion Connector is NULL!!!\n"));
1223 pRequestHeader->rc = VERR_NOT_SUPPORTED;
1224 }
1225 else
1226 {
1227 VMMDevVideoSetVisibleRegion *ptr = (VMMDevVideoSetVisibleRegion *)pRequestHeader;
1228
1229 if (!ptr->cRect)
1230 {
1231 Log(("VMMDevReq_VideoSetVisibleRegion no rectangles!!!\n"));
1232 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1233 }
1234 else
1235 if (pRequestHeader->size != sizeof(VMMDevVideoSetVisibleRegion) + (ptr->cRect-1)*sizeof(RTRECT))
1236 {
1237 Log(("VMMDevReq_VideoSetVisibleRegion request size too small!!!\n"));
1238 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1239 }
1240 else
1241 {
1242 Log(("VMMDevReq_VideoSetVisibleRegion %d rectangles\n", ptr->cRect));
1243 /* forward the call */
1244 pRequestHeader->rc = pThis->pDrv->pfnSetVisibleRegion(pThis->pDrv, ptr->cRect, &ptr->Rect);
1245 }
1246 }
1247 break;
1248 }
1249
1250 case VMMDevReq_GetSeamlessChangeRequest:
1251 {
1252 if (pRequestHeader->size != sizeof(VMMDevSeamlessChangeRequest))
1253 {
1254 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1255 }
1256 else
1257 {
1258 VMMDevSeamlessChangeRequest *seamlessChangeRequest = (VMMDevSeamlessChangeRequest*)pRequestHeader;
1259 /* just pass on the information */
1260 Log(("VMMDev: returning seamless change request mode=%d\n", pThis->fSeamlessEnabled));
1261 if (pThis->fSeamlessEnabled)
1262 seamlessChangeRequest->mode = VMMDev_Seamless_Visible_Region;
1263 else
1264 seamlessChangeRequest->mode = VMMDev_Seamless_Disabled;
1265
1266 if (seamlessChangeRequest->eventAck == VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST)
1267 {
1268 /* Remember which mode the client has queried. */
1269 pThis->fLastSeamlessEnabled = pThis->fSeamlessEnabled;
1270 }
1271
1272 pRequestHeader->rc = VINF_SUCCESS;
1273 }
1274 break;
1275 }
1276
1277 case VMMDevReq_GetVRDPChangeRequest:
1278 {
1279 if (pRequestHeader->size != sizeof(VMMDevVRDPChangeRequest))
1280 {
1281 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1282 }
1283 else
1284 {
1285 VMMDevVRDPChangeRequest *vrdpChangeRequest = (VMMDevVRDPChangeRequest*)pRequestHeader;
1286 /* just pass on the information */
1287 Log(("VMMDev: returning VRDP status %d level %d\n", pThis->fVRDPEnabled, pThis->u32VRDPExperienceLevel));
1288
1289 vrdpChangeRequest->u8VRDPActive = pThis->fVRDPEnabled;
1290 vrdpChangeRequest->u32VRDPExperienceLevel = pThis->u32VRDPExperienceLevel;
1291
1292 pRequestHeader->rc = VINF_SUCCESS;
1293 }
1294 break;
1295 }
1296
1297 case VMMDevReq_GetMemBalloonChangeRequest:
1298 {
1299 Log(("VMMDevReq_GetMemBalloonChangeRequest\n"));
1300 if (pRequestHeader->size != sizeof(VMMDevGetMemBalloonChangeRequest))
1301 {
1302 AssertFailed();
1303 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1304 }
1305 else
1306 {
1307 VMMDevGetMemBalloonChangeRequest *memBalloonChangeRequest = (VMMDevGetMemBalloonChangeRequest*)pRequestHeader;
1308 /* just pass on the information */
1309 Log(("VMMDev: returning memory balloon size =%d\n", pThis->u32MemoryBalloonSize));
1310 memBalloonChangeRequest->u32BalloonSize = pThis->u32MemoryBalloonSize;
1311 memBalloonChangeRequest->u32PhysMemSize = pThis->cbGuestRAM / (uint64_t)_1M;
1312
1313 if (memBalloonChangeRequest->eventAck == VMMDEV_EVENT_BALLOON_CHANGE_REQUEST)
1314 {
1315 /* Remember which mode the client has queried. */
1316 pThis->u32LastMemoryBalloonSize = pThis->u32MemoryBalloonSize;
1317 }
1318
1319 pRequestHeader->rc = VINF_SUCCESS;
1320 }
1321 break;
1322 }
1323
1324 case VMMDevReq_ChangeMemBalloon:
1325 {
1326 VMMDevChangeMemBalloon *memBalloonChange = (VMMDevChangeMemBalloon*)pRequestHeader;
1327
1328 Log(("VMMDevReq_ChangeMemBalloon\n"));
1329 if ( pRequestHeader->size < sizeof(VMMDevChangeMemBalloon)
1330 || memBalloonChange->cPages != VMMDEV_MEMORY_BALLOON_CHUNK_PAGES
1331 || pRequestHeader->size != (uint32_t)RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[memBalloonChange->cPages]))
1332 {
1333 AssertFailed();
1334 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1335 }
1336 else
1337 {
1338 pRequestHeader->rc = pThis->pDrv->pfnChangeMemoryBalloon(pThis->pDrv, !!memBalloonChange->fInflate, memBalloonChange->cPages, memBalloonChange->aPhysPage);
1339 }
1340 break;
1341 }
1342
1343 case VMMDevReq_GetStatisticsChangeRequest:
1344 {
1345 Log(("VMMDevReq_GetStatisticsChangeRequest\n"));
1346 if (pRequestHeader->size != sizeof(VMMDevGetStatisticsChangeRequest))
1347 {
1348 AssertFailed();
1349 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1350 }
1351 else
1352 {
1353 VMMDevGetStatisticsChangeRequest *statIntervalChangeRequest = (VMMDevGetStatisticsChangeRequest*)pRequestHeader;
1354 /* just pass on the information */
1355 Log(("VMMDev: returning statistics interval %d seconds\n", pThis->u32StatIntervalSize));
1356 statIntervalChangeRequest->u32StatInterval = pThis->u32StatIntervalSize;
1357
1358 if (statIntervalChangeRequest->eventAck == VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST)
1359 {
1360 /* Remember which mode the client has queried. */
1361 pThis->u32LastStatIntervalSize= pThis->u32StatIntervalSize;
1362 }
1363
1364 pRequestHeader->rc = VINF_SUCCESS;
1365 }
1366 break;
1367 }
1368
1369 case VMMDevReq_ReportGuestStats:
1370 {
1371 Log(("VMMDevReq_ReportGuestStats\n"));
1372 if (pRequestHeader->size != sizeof(VMMDevReportGuestStats))
1373 {
1374 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1375 }
1376 else
1377 {
1378 VMMDevReportGuestStats *stats = (VMMDevReportGuestStats*)pRequestHeader;
1379
1380#ifdef DEBUG
1381 VBoxGuestStatistics *pGuestStats = &stats->guestStats;
1382
1383 Log(("Current statistics:\n"));
1384 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_IDLE)
1385 Log(("CPU%d: CPU Load Idle %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Idle));
1386
1387 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_KERNEL)
1388 Log(("CPU%d: CPU Load Kernel %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Kernel));
1389
1390 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_USER)
1391 Log(("CPU%d: CPU Load User %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_User));
1392
1393 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_THREADS)
1394 Log(("CPU%d: Thread %d\n", pGuestStats->u32CpuId, pGuestStats->u32Threads));
1395
1396 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PROCESSES)
1397 Log(("CPU%d: Processes %d\n", pGuestStats->u32CpuId, pGuestStats->u32Processes));
1398
1399 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_HANDLES)
1400 Log(("CPU%d: Handles %d\n", pGuestStats->u32CpuId, pGuestStats->u32Handles));
1401
1402 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEMORY_LOAD)
1403 Log(("CPU%d: Memory Load %d%%\n", pGuestStats->u32CpuId, pGuestStats->u32MemoryLoad));
1404
1405 /* Note that reported values are in pages; upper layers expect them in megabytes */
1406 Assert(pGuestStats->u32PageSize == 4096);
1407 if (pGuestStats->u32PageSize != 4096)
1408 pGuestStats->u32PageSize = 4096;
1409
1410 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_TOTAL)
1411 Log(("CPU%d: Total physical memory %-4d MB\n", pGuestStats->u32CpuId, (pGuestStats->u32PhysMemTotal + (_1M/pGuestStats->u32PageSize)-1)/ (_1M/pGuestStats->u32PageSize)));
1412
1413 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_AVAIL)
1414 Log(("CPU%d: Free physical memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemAvail / (_1M/pGuestStats->u32PageSize)));
1415
1416 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_BALLOON)
1417 Log(("CPU%d: Memory balloon size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemBalloon / (_1M/pGuestStats->u32PageSize)));
1418
1419 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_COMMIT_TOTAL)
1420 Log(("CPU%d: Committed memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemCommitTotal / (_1M/pGuestStats->u32PageSize)));
1421
1422 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_TOTAL)
1423 Log(("CPU%d: Total kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelTotal / (_1M/pGuestStats->u32PageSize)));
1424
1425 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_PAGED)
1426 Log(("CPU%d: Paged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelPaged / (_1M/pGuestStats->u32PageSize)));
1427
1428 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_NONPAGED)
1429 Log(("CPU%d: Nonpaged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelNonPaged / (_1M/pGuestStats->u32PageSize)));
1430
1431 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_SYSTEM_CACHE)
1432 Log(("CPU%d: System cache size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemSystemCache / (_1M/pGuestStats->u32PageSize)));
1433
1434 if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PAGE_FILE_SIZE)
1435 Log(("CPU%d: Page file size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PageFileSize / (_1M/pGuestStats->u32PageSize)));
1436 Log(("Statistics end *******************\n"));
1437#endif
1438
1439 /* forward the call */
1440 pRequestHeader->rc = pThis->pDrv->pfnReportStatistics(pThis->pDrv, &stats->guestStats);
1441 }
1442 break;
1443 }
1444
1445 case VMMDevReq_QueryCredentials:
1446 {
1447 if (pRequestHeader->size != sizeof(VMMDevCredentials))
1448 {
1449 AssertMsgFailed(("VMMDevReq_QueryCredentials request size too small.\n"));
1450 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1451 }
1452 else
1453 {
1454 VMMDevCredentials *credentials = (VMMDevCredentials*)pRequestHeader;
1455
1456 /* let's start by nulling out the data */
1457 memset(credentials->szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
1458 memset(credentials->szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
1459 memset(credentials->szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
1460
1461 /* should we return whether we got credentials for a logon? */
1462 if (credentials->u32Flags & VMMDEV_CREDENTIALS_QUERYPRESENCE)
1463 {
1464 if ( pThis->credentialsLogon.szUserName[0]
1465 || pThis->credentialsLogon.szPassword[0]
1466 || pThis->credentialsLogon.szDomain[0])
1467 {
1468 credentials->u32Flags |= VMMDEV_CREDENTIALS_PRESENT;
1469 }
1470 else
1471 {
1472 credentials->u32Flags &= ~VMMDEV_CREDENTIALS_PRESENT;
1473 }
1474 }
1475
1476 /* does the guest want to read logon credentials? */
1477 if (credentials->u32Flags & VMMDEV_CREDENTIALS_READ)
1478 {
1479 if (pThis->credentialsLogon.szUserName[0])
1480 strcpy(credentials->szUserName, pThis->credentialsLogon.szUserName);
1481 if (pThis->credentialsLogon.szPassword[0])
1482 strcpy(credentials->szPassword, pThis->credentialsLogon.szPassword);
1483 if (pThis->credentialsLogon.szDomain[0])
1484 strcpy(credentials->szDomain, pThis->credentialsLogon.szDomain);
1485 if (!pThis->credentialsLogon.fAllowInteractiveLogon)
1486 credentials->u32Flags |= VMMDEV_CREDENTIALS_NOLOCALLOGON;
1487 else
1488 credentials->u32Flags &= ~VMMDEV_CREDENTIALS_NOLOCALLOGON;
1489 }
1490
1491 if (!pThis->fKeepCredentials)
1492 {
1493 /* does the caller want us to destroy the logon credentials? */
1494 if (credentials->u32Flags & VMMDEV_CREDENTIALS_CLEAR)
1495 {
1496 memset(pThis->credentialsLogon.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
1497 memset(pThis->credentialsLogon.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
1498 memset(pThis->credentialsLogon.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
1499 }
1500 }
1501
1502 /* does the guest want to read credentials for verification? */
1503 if (credentials->u32Flags & VMMDEV_CREDENTIALS_READJUDGE)
1504 {
1505 if (pThis->credentialsJudge.szUserName[0])
1506 strcpy(credentials->szUserName, pThis->credentialsJudge.szUserName);
1507 if (pThis->credentialsJudge.szPassword[0])
1508 strcpy(credentials->szPassword, pThis->credentialsJudge.szPassword);
1509 if (pThis->credentialsJudge.szDomain[0])
1510 strcpy(credentials->szDomain, pThis->credentialsJudge.szDomain);
1511 }
1512
1513 /* does the caller want us to destroy the judgement credentials? */
1514 if (credentials->u32Flags & VMMDEV_CREDENTIALS_CLEARJUDGE)
1515 {
1516 memset(pThis->credentialsJudge.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
1517 memset(pThis->credentialsJudge.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
1518 memset(pThis->credentialsJudge.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
1519 }
1520
1521 pRequestHeader->rc = VINF_SUCCESS;
1522 }
1523 break;
1524 }
1525
1526 case VMMDevReq_ReportCredentialsJudgement:
1527 {
1528 if (pRequestHeader->size != sizeof(VMMDevCredentials))
1529 {
1530 AssertMsgFailed(("VMMDevReq_ReportCredentialsJudgement request size too small.\n"));
1531 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1532 }
1533 else
1534 {
1535 VMMDevCredentials *credentials = (VMMDevCredentials*)pRequestHeader;
1536
1537 /* what does the guest think about the credentials? (note: the order is important here!) */
1538 if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_DENY)
1539 {
1540 pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_DENY);
1541 }
1542 else if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT)
1543 {
1544 pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT);
1545 }
1546 else if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_OK)
1547 {
1548 pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_OK);
1549 }
1550 else
1551 Log(("VMMDevReq_ReportCredentialsJudgement: invalid flags: %d!!!\n", credentials->u32Flags));
1552
1553 pRequestHeader->rc = VINF_SUCCESS;
1554 }
1555 break;
1556 }
1557
1558 /*
1559 * Implemented in 3.1.0. The ring-0 VBoxGuestLib uses this to check
1560 * whether VMMDevHGCMParmType_PhysAddr and VMMDevHGCMParmType_PageList
1561 * are known to work.
1562 */
1563 case VMMDevReq_GetHostVersion:
1564 {
1565 AssertMsgBreakStmt(pRequestHeader->size == sizeof(VMMDevReqLogString),
1566 ("%#x < %#x\n", pRequestHeader->size, sizeof(VMMDevReqLogString)),
1567 pRequestHeader->rc = VERR_INVALID_PARAMETER);
1568 VMMDevReqHostVersion *pReqHostVer = (VMMDevReqHostVersion*)pRequestHeader;
1569 pReqHostVer->major = VBOX_VERSION_MAJOR;
1570 pReqHostVer->minor = VBOX_VERSION_MINOR;
1571 pReqHostVer->build = VBOX_VERSION_BUILD;
1572 pReqHostVer->revision = VBOX_SVN_REV;
1573 pReqHostVer->features = VMMDEV_HVF_PHYS_HGCM_PARAM;
1574 pReqHostVer->header.rc = VINF_SUCCESS;
1575 break;
1576 }
1577
1578#ifdef DEBUG
1579 case VMMDevReq_LogString:
1580 {
1581 if (pRequestHeader->size < sizeof(VMMDevReqLogString))
1582 {
1583 AssertMsgFailed(("VMMDevReq_LogString request size too small.\n"));
1584 pRequestHeader->rc = VERR_INVALID_PARAMETER;
1585 }
1586 else
1587 {
1588 VMMDevReqLogString *pReqLogString = (VMMDevReqLogString*)pRequestHeader;
1589#undef LOG_GROUP
1590#define LOG_GROUP LOG_GROUP_DEV_VMM_BACKDOOR
1591// Log(("Guest Log: %s", pReqLogString->szString));
1592 Log(("DEBUG LOG: %s", pReqLogString->szString));
1593
1594#undef LOG_GROUP
1595#define LOG_GROUP LOG_GROUP_DEV_VMM
1596 pRequestHeader->rc = VINF_SUCCESS;
1597 }
1598 break;
1599 }
1600#endif
1601 default:
1602 {
1603 pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
1604
1605 Log(("VMMDev unknown request type %d\n", pRequestHeader->requestType));
1606
1607 break;
1608 }
1609 }
1610
1611end:
1612 /* Write the result back to guest memory */
1613 if (pRequestHeader)
1614 {
1615 PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, pRequestHeader, pRequestHeader->size);
1616 RTMemFree(pRequestHeader);
1617 }
1618 else
1619 {
1620 /* early error case; write back header only */
1621 PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
1622 }
1623
1624 PDMCritSectLeave(&pThis->CritSect);
1625 return rcRet;
1626}
1627
1628/**
1629 * Callback function for mapping an PCI I/O region.
1630 *
1631 * @return VBox status code.
1632 * @param pPciDev Pointer to PCI device. Use pPciDev->pDevIns to get the device instance.
1633 * @param iRegion The region number.
1634 * @param GCPhysAddress Physical address of the region. If iType is PCI_ADDRESS_SPACE_IO, this is an
1635 * I/O port, else it's a physical address.
1636 * This address is *NOT* relative to pci_mem_base like earlier!
1637 * @param enmType One of the PCI_ADDRESS_SPACE_* values.
1638 */
1639static DECLCALLBACK(int) vmmdevIORAMRegionMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
1640{
1641 LogFlow(("vmmdevR3IORAMRegionMap: iRegion=%d GCPhysAddress=%RGp cb=%#x enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
1642 VMMDevState *pThis = PCIDEV_2_VMMDEVSTATE(pPciDev);
1643 int rc;
1644
1645 if (iRegion == 1)
1646 {
1647 AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM, VERR_INTERNAL_ERROR);
1648 Assert(pThis->pVMMDevRAMR3 != NULL);
1649 if (GCPhysAddress != NIL_RTGCPHYS)
1650 {
1651 /*
1652 * Map the MMIO2 memory.
1653 */
1654 pThis->GCPhysVMMDevRAM = GCPhysAddress;
1655 Assert(pThis->GCPhysVMMDevRAM == GCPhysAddress);
1656 rc = PDMDevHlpMMIO2Map(pPciDev->pDevIns, iRegion, GCPhysAddress);
1657 }
1658 else
1659 {
1660 /*
1661 * It is about to be unmapped, just clean up.
1662 */
1663 pThis->GCPhysVMMDevRAM = NIL_RTGCPHYS32;
1664 rc = VINF_SUCCESS;
1665 }
1666 }
1667 else if (iRegion == 2)
1668 {
1669 AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM_PREFETCH, VERR_INTERNAL_ERROR);
1670 Assert(pThis->pVMMDevHeapR3 != NULL);
1671 if (GCPhysAddress != NIL_RTGCPHYS)
1672 {
1673 /*
1674 * Map the MMIO2 memory.
1675 */
1676 pThis->GCPhysVMMDevHeap = GCPhysAddress;
1677 Assert(pThis->GCPhysVMMDevHeap == GCPhysAddress);
1678 rc = PDMDevHlpMMIO2Map(pPciDev->pDevIns, iRegion, GCPhysAddress);
1679 if (RT_SUCCESS(rc))
1680 rc = PDMDevHlpRegisterVMMDevHeap(pPciDev->pDevIns, GCPhysAddress, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
1681 }
1682 else
1683 {
1684 /*
1685 * It is about to be unmapped, just clean up.
1686 */
1687 PDMDevHlpUnregisterVMMDevHeap(pPciDev->pDevIns, pThis->GCPhysVMMDevHeap);
1688 pThis->GCPhysVMMDevHeap = NIL_RTGCPHYS32;
1689 rc = VINF_SUCCESS;
1690 }
1691 }
1692 else
1693 {
1694 AssertMsgFailed(("%d\n", iRegion));
1695 rc = VERR_INVALID_PARAMETER;
1696 }
1697
1698 return rc;
1699}
1700
1701
1702/**
1703 * Callback function for mapping a PCI I/O region.
1704 *
1705 * @return VBox status code.
1706 * @param pPciDev Pointer to PCI device. Use pPciDev->pDevIns to get the device instance.
1707 * @param iRegion The region number.
1708 * @param GCPhysAddress Physical address of the region. If iType is PCI_ADDRESS_SPACE_IO, this is an
1709 * I/O port, else it's a physical address.
1710 * This address is *NOT* relative to pci_mem_base like earlier!
1711 * @param enmType One of the PCI_ADDRESS_SPACE_* values.
1712 */
1713static DECLCALLBACK(int) vmmdevIOPortRegionMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
1714{
1715 VMMDevState *pThis = PCIDEV_2_VMMDEVSTATE(pPciDev);
1716 int rc = VINF_SUCCESS;
1717
1718 Assert(enmType == PCI_ADDRESS_SPACE_IO);
1719 Assert(iRegion == 0);
1720 AssertMsg(RT_ALIGN(GCPhysAddress, 8) == GCPhysAddress, ("Expected 8 byte alignment. GCPhysAddress=%#x\n", GCPhysAddress));
1721
1722 /*
1723 * Save the base port address to simplify Port offset calculations.
1724 */
1725 pThis->PortBase = (RTIOPORT)GCPhysAddress;
1726
1727 /*
1728 * Register our port IO handlers.
1729 */
1730 rc = PDMDevHlpIOPortRegister(pPciDev->pDevIns,
1731 (RTIOPORT)GCPhysAddress + VMMDEV_PORT_OFF_REQUEST, 1,
1732 (void*)pThis, vmmdevRequestHandler,
1733 NULL, NULL, NULL, "VMMDev Request Handler");
1734 AssertRC(rc);
1735 return rc;
1736}
1737
1738/**
1739 * Queries an interface to the driver.
1740 *
1741 * @returns Pointer to interface.
1742 * @returns NULL if the interface was not supported by the driver.
1743 * @param pInterface Pointer to this interface structure.
1744 * @param enmInterface The requested interface identification.
1745 * @thread Any thread.
1746 */
1747static DECLCALLBACK(void *) vmmdevPortQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
1748{
1749 VMMDevState *pThis = (VMMDevState*)((uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, Base));
1750 switch (enmInterface)
1751 {
1752 case PDMINTERFACE_BASE:
1753 return &pThis->Base;
1754 case PDMINTERFACE_VMMDEV_PORT:
1755 return &pThis->Port;
1756#ifdef VBOX_WITH_HGCM
1757 case PDMINTERFACE_HGCM_PORT:
1758 return &pThis->HGCMPort;
1759#endif
1760 case PDMINTERFACE_LED_PORTS:
1761 /* Currently only for shared folders */
1762 return &pThis->SharedFolders.ILeds;
1763 default:
1764 return NULL;
1765 }
1766}
1767
1768/**
1769 * Gets the pointer to the status LED of a unit.
1770 *
1771 * @returns VBox status code.
1772 * @param pInterface Pointer to the interface structure containing the called function pointer.
1773 * @param iLUN The unit which status LED we desire.
1774 * @param ppLed Where to store the LED pointer.
1775 */
1776static DECLCALLBACK(int) vmmdevQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
1777{
1778 VMMDevState *pThis = (VMMDevState *)( (uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, SharedFolders.ILeds) );
1779 if (iLUN == 0) /* LUN 0 is shared folders */
1780 {
1781 *ppLed = &pThis->SharedFolders.Led;
1782 return VINF_SUCCESS;
1783 }
1784 return VERR_PDM_LUN_NOT_FOUND;
1785}
1786
1787/* -=-=-=-=-=- IVMMDevPort -=-=-=-=-=- */
1788
1789/** Converts a VMMDev port interface pointer to a VMMDev state pointer. */
1790#define IVMMDEVPORT_2_VMMDEVSTATE(pInterface) ( (VMMDevState*)((uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, Port)) )
1791
1792
1793/**
1794 * Return the current absolute mouse position in pixels
1795 *
1796 * @returns VBox status code
1797 * @param pAbsX Pointer of result value, can be NULL
1798 * @param pAbsY Pointer of result value, can be NULL
1799 */
1800static DECLCALLBACK(int) vmmdevQueryAbsoluteMouse(PPDMIVMMDEVPORT pInterface, uint32_t *pAbsX, uint32_t *pAbsY)
1801{
1802 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1803 if (pAbsX)
1804 *pAbsX = pThis->mouseXAbs;
1805 if (pAbsY)
1806 *pAbsY = pThis->mouseYAbs;
1807 return VINF_SUCCESS;
1808}
1809
1810/**
1811 * Set the new absolute mouse position in pixels
1812 *
1813 * @returns VBox status code
1814 * @param absX New absolute X position
1815 * @param absY New absolute Y position
1816 */
1817static DECLCALLBACK(int) vmmdevSetAbsoluteMouse(PPDMIVMMDEVPORT pInterface, uint32_t absX, uint32_t absY)
1818{
1819 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1820 if ((pThis->mouseXAbs == absX) && (pThis->mouseYAbs == absY))
1821 return VINF_SUCCESS;
1822 Log2(("vmmdevSetAbsoluteMouse: settings absolute position to x = %d, y = %d\n", absX, absY));
1823 pThis->mouseXAbs = absX;
1824 pThis->mouseYAbs = absY;
1825 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
1826 return VINF_SUCCESS;
1827}
1828
1829/**
1830 * Return the current mouse capability flags
1831 *
1832 * @returns VBox status code
1833 * @param pCapabilities Pointer of result value
1834 */
1835static DECLCALLBACK(int) vmmdevQueryMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t *pCapabilities)
1836{
1837 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1838 if (!pCapabilities)
1839 return VERR_INVALID_PARAMETER;
1840 *pCapabilities = pThis->mouseCapabilities;
1841 return VINF_SUCCESS;
1842}
1843
1844/**
1845 * Set the current mouse capability flag (host side)
1846 *
1847 * @returns VBox status code
1848 * @param capabilities Capability mask
1849 */
1850static DECLCALLBACK(int) vmmdevSetMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t capabilities)
1851{
1852 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1853
1854 bool bCapsChanged = ((capabilities & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE)
1855 != (pThis->mouseCapabilities & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE));
1856
1857 Log(("vmmdevSetMouseCapabilities: bCapsChanged %d\n", bCapsChanged));
1858
1859 if (capabilities & VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER)
1860 pThis->mouseCapabilities |= VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER;
1861 else
1862 pThis->mouseCapabilities &= ~VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER;
1863
1864 if (capabilities & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE)
1865 pThis->mouseCapabilities |= VMMDEV_MOUSE_HOST_CAN_ABSOLUTE;
1866 else
1867 pThis->mouseCapabilities &= ~VMMDEV_MOUSE_HOST_CAN_ABSOLUTE;
1868
1869 if (bCapsChanged)
1870 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
1871
1872 return VINF_SUCCESS;
1873}
1874
1875
1876static DECLCALLBACK(int) vmmdevRequestDisplayChange(PPDMIVMMDEVPORT pInterface, uint32_t xres, uint32_t yres, uint32_t bpp, uint32_t display)
1877{
1878 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1879
1880 /* Verify that the new resolution is different and that guest does not yet know about it. */
1881 bool fSameResolution = (!xres || (pThis->lastReadDisplayChangeRequest.xres == xres)) &&
1882 (!yres || (pThis->lastReadDisplayChangeRequest.yres == yres)) &&
1883 (!bpp || (pThis->lastReadDisplayChangeRequest.bpp == bpp)) &&
1884 pThis->lastReadDisplayChangeRequest.display == display;
1885
1886 if (!xres && !yres && !bpp)
1887 {
1888 /* Special case of reset video mode. */
1889 fSameResolution = false;
1890 }
1891
1892 Log3(("vmmdevRequestDisplayChange: same=%d. new: xres=%d, yres=%d, bpp=%d, display=%d. old: xres=%d, yres=%d, bpp=%d, display=%d.\n",
1893 fSameResolution, xres, yres, bpp, display, pThis->lastReadDisplayChangeRequest.xres, pThis->lastReadDisplayChangeRequest.yres, pThis->lastReadDisplayChangeRequest.bpp, pThis->lastReadDisplayChangeRequest.display));
1894
1895 if (!fSameResolution)
1896 {
1897 LogRel(("VMMDev::SetVideoModeHint: got a video mode hint (%dx%dx%d) at %d\n",
1898 xres, yres, bpp, display));
1899
1900 /* we could validate the information here but hey, the guest can do that as well! */
1901 pThis->displayChangeRequest.xres = xres;
1902 pThis->displayChangeRequest.yres = yres;
1903 pThis->displayChangeRequest.bpp = bpp;
1904 pThis->displayChangeRequest.display = display;
1905
1906 /* IRQ so the guest knows what's going on */
1907 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
1908 }
1909
1910 return VINF_SUCCESS;
1911}
1912
1913static DECLCALLBACK(int) vmmdevRequestSeamlessChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
1914{
1915 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1916
1917 /* Verify that the new resolution is different and that guest does not yet know about it. */
1918 bool fSameMode = (pThis->fLastSeamlessEnabled == fEnabled);
1919
1920 Log(("vmmdevRequestSeamlessChange: same=%d. new=%d\n", fSameMode, fEnabled));
1921
1922 if (!fSameMode)
1923 {
1924 /* we could validate the information here but hey, the guest can do that as well! */
1925 pThis->fSeamlessEnabled = fEnabled;
1926
1927 /* IRQ so the guest knows what's going on */
1928 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST);
1929 }
1930
1931 return VINF_SUCCESS;
1932}
1933
1934static DECLCALLBACK(int) vmmdevSetMemoryBalloon(PPDMIVMMDEVPORT pInterface, uint32_t ulBalloonSize)
1935{
1936 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1937
1938 /* Verify that the new resolution is different and that guest does not yet know about it. */
1939 bool fSame = (pThis->u32LastMemoryBalloonSize == ulBalloonSize);
1940
1941 Log(("vmmdevSetMemoryBalloon: old=%d. new=%d\n", pThis->u32LastMemoryBalloonSize, ulBalloonSize));
1942
1943 if (!fSame)
1944 {
1945 /* we could validate the information here but hey, the guest can do that as well! */
1946 pThis->u32MemoryBalloonSize = ulBalloonSize;
1947
1948 /* IRQ so the guest knows what's going on */
1949 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_BALLOON_CHANGE_REQUEST);
1950 }
1951
1952 return VINF_SUCCESS;
1953}
1954
1955static DECLCALLBACK(int) vmmdevVRDPChange(PPDMIVMMDEVPORT pInterface, bool fVRDPEnabled, uint32_t u32VRDPExperienceLevel)
1956{
1957 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1958
1959 bool fSame = (pThis->fVRDPEnabled == fVRDPEnabled);
1960
1961 Log(("vmmdevVRDPChange: old=%d. new=%d\n", pThis->fVRDPEnabled, fVRDPEnabled));
1962
1963 if (!fSame)
1964 {
1965 pThis->fVRDPEnabled = fVRDPEnabled;
1966 pThis->u32VRDPExperienceLevel = u32VRDPExperienceLevel;
1967
1968 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_VRDP);
1969 }
1970
1971 return VINF_SUCCESS;
1972}
1973
1974static DECLCALLBACK(int) vmmdevSetStatisticsInterval(PPDMIVMMDEVPORT pInterface, uint32_t ulStatInterval)
1975{
1976 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1977
1978 /* Verify that the new resolution is different and that guest does not yet know about it. */
1979 bool fSame = (pThis->u32LastStatIntervalSize == ulStatInterval);
1980
1981 Log(("vmmdevSetStatisticsInterval: old=%d. new=%d\n", pThis->u32LastStatIntervalSize, ulStatInterval));
1982
1983 if (!fSame)
1984 {
1985 /* we could validate the information here but hey, the guest can do that as well! */
1986 pThis->u32StatIntervalSize = ulStatInterval;
1987
1988 /* IRQ so the guest knows what's going on */
1989 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST);
1990 }
1991
1992 return VINF_SUCCESS;
1993}
1994
1995
1996static DECLCALLBACK(int) vmmdevSetCredentials(PPDMIVMMDEVPORT pInterface, const char *pszUsername,
1997 const char *pszPassword, const char *pszDomain,
1998 uint32_t u32Flags)
1999{
2000 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2001
2002 /* logon mode? */
2003 if (u32Flags & VMMDEV_SETCREDENTIALS_GUESTLOGON)
2004 {
2005 /* memorize the data */
2006 strcpy(pThis->credentialsLogon.szUserName, pszUsername);
2007 strcpy(pThis->credentialsLogon.szPassword, pszPassword);
2008 strcpy(pThis->credentialsLogon.szDomain, pszDomain);
2009 pThis->credentialsLogon.fAllowInteractiveLogon = !(u32Flags & VMMDEV_SETCREDENTIALS_NOLOCALLOGON);
2010 }
2011 /* credentials verification mode? */
2012 else if (u32Flags & VMMDEV_SETCREDENTIALS_JUDGE)
2013 {
2014 /* memorize the data */
2015 strcpy(pThis->credentialsJudge.szUserName, pszUsername);
2016 strcpy(pThis->credentialsJudge.szPassword, pszPassword);
2017 strcpy(pThis->credentialsJudge.szDomain, pszDomain);
2018
2019 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_JUDGE_CREDENTIALS);
2020 }
2021 else
2022 return VERR_INVALID_PARAMETER;
2023
2024 return VINF_SUCCESS;
2025}
2026
2027/**
2028 * Notification from the Display. Especially useful when
2029 * acceleration is disabled after a video mode change.
2030 *
2031 * @param fEnable Current acceleration status.
2032 */
2033static DECLCALLBACK(void) vmmdevVBVAChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
2034{
2035 VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2036
2037 Log(("vmmdevVBVAChange: fEnabled = %d\n", fEnabled));
2038
2039 if (pThis)
2040 {
2041 pThis->u32VideoAccelEnabled = fEnabled;
2042 }
2043
2044 return;
2045}
2046
2047
2048/* -=-=-=-=-=- IHGCMPort -=-=-=-=-=- */
2049
2050/** Converts a VMMDev port interface pointer to a VMMDev state pointer. */
2051#define IHGCMPORT_2_VMMDEVSTATE(pInterface) ( (VMMDevState*)((uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, HGCMPort)) )
2052
2053
2054
2055#define VMMDEV_SSM_VERSION 9
2056
2057/**
2058 * Saves a state of the VMM device.
2059 *
2060 * @returns VBox status code.
2061 * @param pDevIns The device instance.
2062 * @param pSSMHandle The handle to save the state to.
2063 */
2064static DECLCALLBACK(int) vmmdevSaveState(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
2065{
2066 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
2067 SSMR3PutU32(pSSMHandle, pThis->hypervisorSize);
2068 SSMR3PutU32(pSSMHandle, pThis->mouseCapabilities);
2069 SSMR3PutU32(pSSMHandle, pThis->mouseXAbs);
2070 SSMR3PutU32(pSSMHandle, pThis->mouseYAbs);
2071
2072 SSMR3PutBool(pSSMHandle, pThis->fNewGuestFilterMask);
2073 SSMR3PutU32(pSSMHandle, pThis->u32NewGuestFilterMask);
2074 SSMR3PutU32(pSSMHandle, pThis->u32GuestFilterMask);
2075 SSMR3PutU32(pSSMHandle, pThis->u32HostEventFlags);
2076 // here be dragons (probably)
2077// SSMR3PutBool(pSSMHandle, pThis->pVMMDevRAMR3->V.V1_04.fHaveEvents);
2078 SSMR3PutMem(pSSMHandle, &pThis->pVMMDevRAMR3->V, sizeof (pThis->pVMMDevRAMR3->V));
2079
2080 SSMR3PutMem(pSSMHandle, &pThis->guestInfo, sizeof (pThis->guestInfo));
2081 SSMR3PutU32(pSSMHandle, pThis->fu32AdditionsOk);
2082 SSMR3PutU32(pSSMHandle, pThis->u32VideoAccelEnabled);
2083
2084 SSMR3PutU32(pSSMHandle, pThis->guestCaps);
2085
2086#ifdef VBOX_WITH_HGCM
2087 vmmdevHGCMSaveState (pThis, pSSMHandle);
2088#endif /* VBOX_WITH_HGCM */
2089
2090 return VINF_SUCCESS;
2091}
2092
2093/**
2094 * Loads the saved VMM device state.
2095 *
2096 * @returns VBox status code.
2097 * @param pDevIns The device instance.
2098 * @param pSSMHandle The handle to the saved state.
2099 * @param u32Version The data unit version number.
2100 */
2101static DECLCALLBACK(int) vmmdevLoadState(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t u32Version)
2102{
2103 /** @todo The code load code is assuming we're always loaded into a fresh VM. */
2104 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
2105 if ( SSM_VERSION_MAJOR_CHANGED(u32Version, VMMDEV_SSM_VERSION)
2106 || (SSM_VERSION_MINOR(u32Version) < 6))
2107 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
2108
2109 SSMR3GetU32(pSSMHandle, &pThis->hypervisorSize);
2110 SSMR3GetU32(pSSMHandle, &pThis->mouseCapabilities);
2111 SSMR3GetU32(pSSMHandle, &pThis->mouseXAbs);
2112 SSMR3GetU32(pSSMHandle, &pThis->mouseYAbs);
2113
2114 SSMR3GetBool(pSSMHandle, &pThis->fNewGuestFilterMask);
2115 SSMR3GetU32(pSSMHandle, &pThis->u32NewGuestFilterMask);
2116 SSMR3GetU32(pSSMHandle, &pThis->u32GuestFilterMask);
2117 SSMR3GetU32(pSSMHandle, &pThis->u32HostEventFlags);
2118// SSMR3GetBool(pSSMHandle, &pThis->pVMMDevRAMR3->fHaveEvents);
2119 // here be dragons (probably)
2120 SSMR3GetMem(pSSMHandle, &pThis->pVMMDevRAMR3->V, sizeof (pThis->pVMMDevRAMR3->V));
2121
2122 SSMR3GetMem(pSSMHandle, &pThis->guestInfo, sizeof (pThis->guestInfo));
2123 SSMR3GetU32(pSSMHandle, &pThis->fu32AdditionsOk);
2124 SSMR3GetU32(pSSMHandle, &pThis->u32VideoAccelEnabled);
2125
2126 SSMR3GetU32(pSSMHandle, &pThis->guestCaps);
2127
2128 /* Attributes which were temporarily introduced in r30072 */
2129 if ( SSM_VERSION_MAJOR(u32Version) == 0
2130 && SSM_VERSION_MINOR(u32Version) == 7)
2131 {
2132 uint32_t temp;
2133 SSMR3GetU32(pSSMHandle, &temp);
2134 SSMR3GetU32(pSSMHandle, &temp);
2135 }
2136
2137#ifdef VBOX_WITH_HGCM
2138 vmmdevHGCMLoadState (pThis, pSSMHandle, u32Version);
2139#endif /* VBOX_WITH_HGCM */
2140
2141 /*
2142 * On a resume, we send the capabilities changed message so
2143 * that listeners can sync their state again
2144 */
2145 Log(("vmmdevLoadState: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
2146 if (pThis->pDrv)
2147 pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
2148
2149 /* Reestablish the acceleration status. */
2150 if ( pThis->u32VideoAccelEnabled
2151 && pThis->pDrv)
2152 {
2153 pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, !!pThis->u32VideoAccelEnabled, &pThis->pVMMDevRAMR3->vbvaMemory);
2154 }
2155
2156 if (pThis->fu32AdditionsOk)
2157 {
2158 LogRel(("Guest Additions information report: additionsVersion = 0x%08X, osType = 0x%08X\n",
2159 pThis->guestInfo.additionsVersion,
2160 pThis->guestInfo.osType));
2161 if (pThis->pDrv)
2162 pThis->pDrv->pfnUpdateGuestVersion(pThis->pDrv, &pThis->guestInfo);
2163 }
2164 if (pThis->pDrv)
2165 pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
2166
2167 return VINF_SUCCESS;
2168}
2169
2170/**
2171 * Load state done callback. Notify guest of restore event.
2172 *
2173 * @returns VBox status code.
2174 * @param pDevIns The device instance.
2175 * @param pSSMHandle The handle to the saved state.
2176 */
2177static DECLCALLBACK(int) vmmdevLoadStateDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
2178{
2179 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
2180
2181#ifdef VBOX_WITH_HGCM
2182 vmmdevHGCMLoadStateDone (pThis, pSSMHandle);
2183#endif /* VBOX_WITH_HGCM */
2184
2185 VMMDevNotifyGuest (pThis, VMMDEV_EVENT_RESTORED);
2186
2187 return VINF_SUCCESS;
2188}
2189
2190/**
2191 * (Re-)initializes the MMIO2 data.
2192 *
2193 * @param pThis Pointer to the VMMDev instance data.
2194 */
2195static void vmmdevInitRam(VMMDevState *pThis)
2196{
2197 memset(pThis->pVMMDevRAMR3, 0, sizeof(VMMDevMemory));
2198 pThis->pVMMDevRAMR3->u32Size = sizeof(VMMDevMemory);
2199 pThis->pVMMDevRAMR3->u32Version = VMMDEV_MEMORY_VERSION;
2200}
2201
2202/**
2203 * Construct a device instance for a VM.
2204 *
2205 * @returns VBox status.
2206 * @param pDevIns The device instance data.
2207 * If the registration structure is needed, pDevIns->pDevReg points to it.
2208 * @param iInstance Instance number. Use this to figure out which registers and such to use.
2209 * The device number is also found in pDevIns->iInstance, but since it's
2210 * likely to be freqently used PDM passes it as parameter.
2211 * @param pCfgHandle Configuration node handle for the device. Use this to obtain the configuration
2212 * of the device instance. It's also found in pDevIns->pCfgHandle, but like
2213 * iInstance it's expected to be used a bit in this function.
2214 */
2215static DECLCALLBACK(int) vmmdevConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
2216{
2217 int rc;
2218 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
2219
2220 Assert(iInstance == 0);
2221
2222 /*
2223 * Validate and read the configuration.
2224 */
2225 if (!CFGMR3AreValuesValid(pCfgHandle,
2226 "GetHostTimeDisabled\0"
2227 "BackdoorLogDisabled\0"
2228 "KeepCredentials\0"
2229 "HeapEnabled\0"
2230 ))
2231 return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
2232
2233 rc = CFGMR3QueryBoolDef(pCfgHandle, "GetHostTimeDisabled", &pThis->fGetHostTimeDisabled, false);
2234 if (RT_FAILURE(rc))
2235 return PDMDEV_SET_ERROR(pDevIns, rc,
2236 N_("Configuration error: Failed querying \"GetHostTimeDisabled\" as a boolean"));
2237
2238 rc = CFGMR3QueryBoolDef(pCfgHandle, "BackdoorLogDisabled", &pThis->fBackdoorLogDisabled, false);
2239 if (RT_FAILURE(rc))
2240 return PDMDEV_SET_ERROR(pDevIns, rc,
2241 N_("Configuration error: Failed querying \"BackdoorLogDisabled\" as a boolean"));
2242
2243 rc = CFGMR3QueryBoolDef(pCfgHandle, "KeepCredentials", &pThis->fKeepCredentials, false);
2244 if (RT_FAILURE(rc))
2245 return PDMDEV_SET_ERROR(pDevIns, rc,
2246 N_("Configuration error: Failed querying \"KeepCredentials\" as a boolean"));
2247
2248 bool fHeapEnabled;
2249 rc = CFGMR3QueryBoolDef(pCfgHandle, "HeapEnabled", &fHeapEnabled, true);
2250 if (RT_FAILURE(rc))
2251 return PDMDEV_SET_ERROR(pDevIns, rc,
2252 N_("Configuration error: Failed querying \"HeapEnabled\" as a boolean"));
2253
2254 /*
2255 * Initialize data (most of it anyway).
2256 */
2257 /* Save PDM device instance data for future reference. */
2258 pThis->pDevIns = pDevIns;
2259
2260 /* PCI vendor, just a free bogus value */
2261 pThis->dev.config[0x00] = 0xee;
2262 pThis->dev.config[0x01] = 0x80;
2263 /* device ID */
2264 pThis->dev.config[0x02] = 0xfe;
2265 pThis->dev.config[0x03] = 0xca;
2266 /* class sub code (other type of system peripheral) */
2267 pThis->dev.config[0x0a] = 0x80;
2268 /* class base code (base system peripheral) */
2269 pThis->dev.config[0x0b] = 0x08;
2270 /* header type */
2271 pThis->dev.config[0x0e] = 0x00;
2272 /* interrupt on pin 0 */
2273 pThis->dev.config[0x3d] = 0x01;
2274
2275 /*
2276 * Interfaces
2277 */
2278 /* Base */
2279 pThis->Base.pfnQueryInterface = vmmdevPortQueryInterface;
2280
2281 /* VMMDev port */
2282 pThis->Port.pfnQueryAbsoluteMouse = vmmdevQueryAbsoluteMouse;
2283 pThis->Port.pfnSetAbsoluteMouse = vmmdevSetAbsoluteMouse;
2284 pThis->Port.pfnQueryMouseCapabilities = vmmdevQueryMouseCapabilities;
2285 pThis->Port.pfnSetMouseCapabilities = vmmdevSetMouseCapabilities;
2286 pThis->Port.pfnRequestDisplayChange = vmmdevRequestDisplayChange;
2287 pThis->Port.pfnSetCredentials = vmmdevSetCredentials;
2288 pThis->Port.pfnVBVAChange = vmmdevVBVAChange;
2289 pThis->Port.pfnRequestSeamlessChange = vmmdevRequestSeamlessChange;
2290 pThis->Port.pfnSetMemoryBalloon = vmmdevSetMemoryBalloon;
2291 pThis->Port.pfnSetStatisticsInterval = vmmdevSetStatisticsInterval;
2292 pThis->Port.pfnVRDPChange = vmmdevVRDPChange;
2293
2294 /* Shared folder LED */
2295 pThis->SharedFolders.Led.u32Magic = PDMLED_MAGIC;
2296 pThis->SharedFolders.ILeds.pfnQueryStatusLed = vmmdevQueryStatusLed;
2297
2298#ifdef VBOX_WITH_HGCM
2299 /* HGCM port */
2300 pThis->HGCMPort.pfnCompleted = hgcmCompleted;
2301#endif
2302
2303 /** @todo convert this into a config parameter like we do everywhere else! */
2304 pThis->cbGuestRAM = MMR3PhysGetRamSize(PDMDevHlpGetVM(pDevIns));
2305
2306 /*
2307 * Create the critical section for the device.
2308 */
2309 rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, "VMMDev");
2310 AssertRCReturn(rc, rc);
2311 /* Later: pDevIns->pCritSectR3 = &pThis->CritSect; */
2312
2313 /*
2314 * Register the backdoor logging port
2315 */
2316 rc = PDMDevHlpIOPortRegister(pDevIns, RTLOG_DEBUG_PORT, 1, NULL, vmmdevBackdoorLog, NULL, NULL, NULL, "VMMDev backdoor logging");
2317 AssertRCReturn(rc, rc);
2318
2319#ifdef TIMESYNC_BACKDOOR
2320 /*
2321 * Alternative timesync source (temporary!)
2322 */
2323 rc = PDMDevHlpIOPortRegister(pDevIns, 0x505, 1, NULL, vmmdevTimesyncBackdoorWrite, vmmdevTimesyncBackdoorRead, NULL, NULL, "VMMDev timesync backdoor");
2324 AssertRCReturn(rc, rc);
2325#endif
2326
2327 /*
2328 * Allocate and initialize the MMIO2 memory.
2329 */
2330 rc = PDMDevHlpMMIO2Register(pDevIns, 1 /*iRegion*/, VMMDEV_RAM_SIZE, 0 /*fFlags*/, (void **)&pThis->pVMMDevRAMR3, "VMMDev");
2331 if (RT_FAILURE(rc))
2332 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
2333 N_("Failed to allocate %u bytes of memory for the VMM device"), VMMDEV_RAM_SIZE);
2334 vmmdevInitRam(pThis);
2335
2336 if (fHeapEnabled)
2337 {
2338 rc = PDMDevHlpMMIO2Register(pDevIns, 2 /*iRegion*/, VMMDEV_HEAP_SIZE, 0 /*fFlags*/, (void **)&pThis->pVMMDevHeapR3, "VMMDev Heap");
2339 if (RT_FAILURE(rc))
2340 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
2341 N_("Failed to allocate %u bytes of memory for the VMM device heap"), PAGE_SIZE);
2342 }
2343
2344 /*
2345 * Register the PCI device.
2346 */
2347 rc = PDMDevHlpPCIRegister(pDevIns, &pThis->dev);
2348 if (RT_FAILURE(rc))
2349 return rc;
2350 if (pThis->dev.devfn == 32 || iInstance != 0)
2351 Log(("!!WARNING!!: pThis->dev.devfn=%d (ignore if testcase or no started by Main)\n", pThis->dev.devfn));
2352 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 0x20, PCI_ADDRESS_SPACE_IO, vmmdevIOPortRegionMap);
2353 if (RT_FAILURE(rc))
2354 return rc;
2355 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 1, VMMDEV_RAM_SIZE, PCI_ADDRESS_SPACE_MEM, vmmdevIORAMRegionMap);
2356 if (RT_FAILURE(rc))
2357 return rc;
2358 if (fHeapEnabled)
2359 {
2360 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2, VMMDEV_HEAP_SIZE, PCI_ADDRESS_SPACE_MEM_PREFETCH, vmmdevIORAMRegionMap);
2361 if (RT_FAILURE(rc))
2362 return rc;
2363 }
2364
2365 /*
2366 * Get the corresponding connector interface
2367 */
2368 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->Base, &pThis->pDrvBase, "VMM Driver Port");
2369 if (RT_SUCCESS(rc))
2370 {
2371 pThis->pDrv = (PPDMIVMMDEVCONNECTOR)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_VMMDEV_CONNECTOR);
2372 if (!pThis->pDrv)
2373 AssertMsgFailedReturn(("LUN #0 doesn't have a VMMDev connector interface!\n"), VERR_PDM_MISSING_INTERFACE);
2374#ifdef VBOX_WITH_HGCM
2375 pThis->pHGCMDrv = (PPDMIHGCMCONNECTOR)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_HGCM_CONNECTOR);
2376 if (!pThis->pHGCMDrv)
2377 {
2378 Log(("LUN #0 doesn't have a HGCM connector interface, HGCM is not supported. rc=%Rrc\n", rc));
2379 /* this is not actually an error, just means that there is no support for HGCM */
2380 }
2381#endif
2382 }
2383 else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
2384 {
2385 Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
2386 rc = VINF_SUCCESS;
2387 }
2388 else
2389 AssertMsgFailedReturn(("Failed to attach LUN #0! rc=%Rrc\n", rc), rc);
2390
2391 /*
2392 * Attach status driver for shared folders (optional).
2393 */
2394 PPDMIBASE pBase;
2395 rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->Base, &pBase, "Status Port");
2396 if (RT_SUCCESS(rc))
2397 pThis->SharedFolders.pLedsConnector = (PPDMILEDCONNECTORS)
2398 pBase->pfnQueryInterface(pBase, PDMINTERFACE_LED_CONNECTORS);
2399 else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
2400 {
2401 AssertMsgFailed(("Failed to attach to status driver. rc=%Rrc\n", rc));
2402 return rc;
2403 }
2404
2405 /*
2406 * Register saved state and init the HGCM CmdList critsect.
2407 */
2408 rc = PDMDevHlpSSMRegister(pDevIns, "VMMDev", iInstance, VMMDEV_SSM_VERSION, sizeof(*pThis),
2409 NULL, vmmdevSaveState, NULL,
2410 NULL, vmmdevLoadState, vmmdevLoadStateDone);
2411 AssertRCReturn(rc, rc);
2412
2413#ifdef VBOX_WITH_HGCM
2414 pThis->pHGCMCmdList = NULL;
2415 rc = RTCritSectInit(&pThis->critsectHGCMCmdList);
2416 AssertRCReturn(rc, rc);
2417 pThis->u32HGCMEnabled = 0;
2418#endif /* VBOX_WITH_HGCM */
2419
2420 return rc;
2421}
2422
2423/**
2424 * Reset notification.
2425 *
2426 * @returns VBox status.
2427 * @param pDrvIns The driver instance data.
2428 */
2429static DECLCALLBACK(void) vmmdevReset(PPDMDEVINS pDevIns)
2430{
2431 VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
2432
2433 /*
2434 * Reset the mouse integration feature bit
2435 */
2436 if (pThis->mouseCapabilities & (VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE|VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR))
2437 {
2438 pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE;
2439 /* notify the connector */
2440 Log(("vmmdevReset: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
2441 pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
2442 }
2443
2444 pThis->hypervisorSize = 0;
2445
2446 pThis->u32HostEventFlags = 0;
2447
2448 /* re-initialize the VMMDev memory */
2449 if (pThis->pVMMDevRAMR3)
2450 vmmdevInitRam(pThis);
2451
2452 /* credentials have to go away (by default) */
2453 if (!pThis->fKeepCredentials)
2454 {
2455 memset(pThis->credentialsLogon.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
2456 memset(pThis->credentialsLogon.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
2457 memset(pThis->credentialsLogon.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
2458 }
2459 memset(pThis->credentialsJudge.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
2460 memset(pThis->credentialsJudge.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
2461 memset(pThis->credentialsJudge.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
2462
2463 /* Reset means that additions will report again. */
2464 const bool fVersionChanged = pThis->fu32AdditionsOk
2465 || pThis->guestInfo.additionsVersion
2466 || pThis->guestInfo.osType != VBOXOSTYPE_Unknown;
2467 if (fVersionChanged)
2468 Log(("vmmdevReset: fu32AdditionsOk=%d additionsVersion=%x osType=%#x\n",
2469 pThis->fu32AdditionsOk, pThis->guestInfo.additionsVersion, pThis->guestInfo.osType));
2470 pThis->fu32AdditionsOk = false;
2471 memset (&pThis->guestInfo, 0, sizeof (pThis->guestInfo));
2472
2473 /* clear pending display change request. */
2474 memset (&pThis->lastReadDisplayChangeRequest, 0, sizeof (pThis->lastReadDisplayChangeRequest));
2475
2476 /* disable seamless mode */
2477 pThis->fLastSeamlessEnabled = false;
2478
2479 /* disabled memory ballooning */
2480 pThis->u32LastMemoryBalloonSize = 0;
2481
2482 /* disabled statistics updating */
2483 pThis->u32LastStatIntervalSize = 0;
2484
2485 /* Clear the "HGCM event enabled" flag so the event can be automatically reenabled. */
2486 pThis->u32HGCMEnabled = 0;
2487
2488 /*
2489 * Clear the event variables.
2490 *
2491 * Note: The pThis->u32HostEventFlags is not cleared.
2492 * It is designed that way so host events do not
2493 * depend on guest resets.
2494 */
2495 pThis->u32GuestFilterMask = 0;
2496 pThis->u32NewGuestFilterMask = 0;
2497 pThis->fNewGuestFilterMask = 0;
2498
2499 /* This is the default, as Windows and OS/2 guests take this for granted. (Actually, neither does...) */
2500 /** @todo change this when we next bump the interface version */
2501 const bool fCapsChanged = pThis->guestCaps != VMMDEV_GUEST_SUPPORTS_GRAPHICS;
2502 if (fCapsChanged)
2503 Log(("vmmdevReset: fCapsChanged=%#x -> %#x\n", pThis->guestCaps, VMMDEV_GUEST_SUPPORTS_GRAPHICS));
2504 pThis->guestCaps = VMMDEV_GUEST_SUPPORTS_GRAPHICS; /** @todo r=bird: why? I cannot see this being done at construction?*/
2505
2506 /*
2507 * Call the update functions as required.
2508 */
2509 if (fVersionChanged)
2510 pThis->pDrv->pfnUpdateGuestVersion(pThis->pDrv, &pThis->guestInfo);
2511 if (fCapsChanged)
2512 pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
2513}
2514
2515
2516/**
2517 * The device registration structure.
2518 */
2519extern "C" const PDMDEVREG g_DeviceVMMDev =
2520{
2521 /* u32Version */
2522 PDM_DEVREG_VERSION,
2523 /* szDeviceName */
2524 "VMMDev",
2525 /* szRCMod */
2526 "",
2527 /* szR0Mod */
2528 "",
2529 /* pszDescription */
2530 "VirtualBox VMM Device\n",
2531 /* fFlags */
2532 PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT | PDM_DEVREG_FLAGS_GUEST_BITS_32,
2533 /* fClass */
2534 PDM_DEVREG_CLASS_VMM_DEV,
2535 /* cMaxInstances */
2536 1,
2537 /* cbInstance */
2538 sizeof(VMMDevState),
2539 /* pfnConstruct */
2540 vmmdevConstruct,
2541 /* pfnDestruct */
2542 NULL,
2543 /* pfnRelocate */
2544 NULL,
2545 /* pfnIOCtl */
2546 NULL,
2547 /* pfnPowerOn */
2548 NULL,
2549 /* pfnReset */
2550 vmmdevReset,
2551 /* pfnSuspend */
2552 NULL,
2553 /* pfnResume */
2554 NULL,
2555 /* pfnAttach */
2556 NULL,
2557 /* pfnDetach */
2558 NULL,
2559 /* pfnQueryInterface. */
2560 NULL,
2561 /* pfnInitComplete */
2562 NULL,
2563 /* pfnPowerOff */
2564 NULL,
2565 /* pfnSoftReset */
2566 NULL,
2567 /* u32VersionEnd */
2568 PDM_DEVREG_VERSION
2569};
2570#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
2571
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