VirtualBox

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

Last change on this file since 10390 was 9662, checked in by vboxsync, 17 years ago

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