VirtualBox

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

Last change on this file since 4032 was 4032, checked in by vboxsync, 18 years ago

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