VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxBFE/VMMDevInterface.cpp@ 41105

Last change on this file since 41105 was 40282, checked in by vboxsync, 13 years ago

*: gcc-4.7: ~0 => ~0U in initializers (warning: narrowing conversion of -1' from int' to `unsigned int' inside { } is ill-formed in C++11 [-Wnarrowing])
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 14.6 KB
Line 
1/* $Id: VMMDevInterface.cpp 40282 2012-02-28 21:02:40Z vboxsync $ */
2/** @file
3 * VBox frontends: Basic Frontend (BFE):
4 * Implementation of VMMDev: driver interface to VMM device
5 */
6
7/*
8 * Copyright (C) 2006-2010 Oracle Corporation
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 (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 */
18
19#define LOG_GROUP LOG_GROUP_MAIN
20
21#ifdef VBOXBFE_WITHOUT_COM
22# include "COMDefs.h"
23#else
24# include <VBox/com/defs.h>
25#endif
26#include <VBox/vmm/pdm.h>
27#include <VBox/VMMDev.h>
28#include <VBox/vmm/cfgm.h>
29#include <VBox/err.h>
30#include <iprt/assert.h>
31#include <VBox/log.h>
32#include <iprt/asm.h>
33#include <iprt/uuid.h>
34
35#include "VBoxBFE.h"
36#include "VMMDev.h"
37#include "MouseImpl.h"
38#include "DisplayImpl.h"
39#include "ConsoleImpl.h"
40#ifdef VBOX_WITH_HGCM
41#include "HGCM.h"
42#endif
43
44#ifdef RT_OS_OS2
45# define VBOXSHAREDFOLDERS_DLL "VBoxSFld"
46#else
47# define VBOXSHAREDFOLDERS_DLL "VBoxSharedFolders"
48#endif
49
50/**
51 * VMMDev driver instance data.
52 */
53typedef struct DRVMAINVMMDEV
54{
55 /** Pointer to the VMMDev object. */
56 VMMDev *pVMMDev;
57 /** Pointer to the driver instance structure. */
58 PPDMDRVINS pDrvIns;
59 /** Pointer to the VMMDev port interface of the driver/device above us. */
60 PPDMIVMMDEVPORT pUpPort;
61 /** Our VMM device connector interface. */
62 PDMIVMMDEVCONNECTOR Connector;
63
64#ifdef VBOX_WITH_HGCM
65 /** Pointer to the HGCM port interface of the driver/device above us. */
66 PPDMIHGCMPORT pHGCMPort;
67 /** Our HGCM connector interface. */
68 PDMIHGCMCONNECTOR HGCMConnector;
69#endif
70} DRVMAINVMMDEV, *PDRVMAINVMMDEV;
71
72/** Converts PDMIVMMDEVCONNECTOR pointer to a DRVMAINVMMDEV pointer. */
73#define PDMIVMMDEVCONNECTOR_2_MAINVMMDEV(pInterface) ( (PDRVMAINVMMDEV) ((uintptr_t)pInterface - RT_OFFSETOF(DRVMAINVMMDEV, Connector)) )
74
75#ifdef VBOX_WITH_HGCM
76/** Converts PDMIHGCMCONNECTOR pointer to a DRVMAINVMMDEV pointer. */
77#define PDMIHGCMCONNECTOR_2_MAINVMMDEV(pInterface) ( (PDRVMAINVMMDEV) ((uintptr_t)pInterface - RT_OFFSETOF(DRVMAINVMMDEV, HGCMConnector)) )
78#endif
79
80VMMDev::VMMDev() : mpDrv(NULL)
81{
82#ifdef VBOX_WITH_HGCM
83 int rc = VINF_SUCCESS;
84 if (fActivateHGCM())
85 rc = HGCMHostInit();
86 AssertRC(rc);
87#endif
88}
89
90VMMDev::~VMMDev()
91{
92#ifdef VBOX_WITH_HGCM
93 if (fActivateHGCM())
94 HGCMHostShutdown ();
95#endif /* VBOX_WITH_HGCM */
96}
97
98
99PPDMIVMMDEVPORT VMMDev::getVMMDevPort()
100{
101 Assert(mpDrv);
102 return mpDrv->pUpPort;
103}
104
105/**
106 * Update the mouse capabilities.
107 * This is called when the mouse capabilities change. The new capabilities
108 * are given and the connector should update its internal state.
109 *
110 * @param pInterface Pointer to this interface.
111 * @param newCapabilities New capabilities.
112 * @thread The emulation thread.
113 */
114DECLCALLBACK(void) VMMDev::UpdateMouseCapabilities(PPDMIVMMDEVCONNECTOR pInterface, uint32_t fNewCaps)
115{
116 /*
117 * Tell the console interface about the event so that it can notify its consumers.
118 */
119
120 if (gMouse)
121 gMouse->onVMMDevGuestCapsChange(fNewCaps & VMMDEV_MOUSE_GUEST_MASK);
122 if (gConsole)
123 gConsole->resetCursor();
124}
125
126
127/**
128 * Update the pointer shape or visibility.
129 *
130 * This is called when the mouse pointer shape changes or pointer is hidden/displaying.
131 * The new shape is passed as a caller allocated buffer that will be freed after returning.
132 *
133 * @param pInterface Pointer to this interface.
134 * @param fVisible Whether the pointer is visible or not.
135 * @param fAlpha Alpha channel information is present.
136 * @param xHot Horizontal coordinate of the pointer hot spot.
137 * @param yHot Vertical coordinate of the pointer hot spot.
138 * @param width Pointer width in pixels.
139 * @param height Pointer height in pixels.
140 * @param pShape The shape buffer. If NULL, then only pointer visibility is being changed.
141 * @thread The emulation thread.
142 */
143DECLCALLBACK(void) VMMDev::UpdatePointerShape(PPDMIVMMDEVCONNECTOR pInterface, bool fVisible, bool fAlpha,
144 uint32_t xHot, uint32_t yHot,
145 uint32_t width, uint32_t height,
146 void *pShape)
147{
148 if (gConsole)
149 gConsole->onMousePointerShapeChange(fVisible, fAlpha, xHot,
150 yHot, width, height, pShape);
151}
152
153DECLCALLBACK(int) iface_VideoAccelEnable(PPDMIVMMDEVCONNECTOR pInterface, bool fEnable, VBVAMEMORY *pVbvaMemory)
154{
155 LogFlow(("VMMDev::VideoAccelEnable: %d, %p\n", fEnable, pVbvaMemory));
156 if (gDisplay)
157 gDisplay->VideoAccelEnable (fEnable, pVbvaMemory);
158 return VINF_SUCCESS;
159}
160
161DECLCALLBACK(void) iface_VideoAccelFlush(PPDMIVMMDEVCONNECTOR pInterface)
162{
163 if (gDisplay)
164 gDisplay->VideoAccelFlush ();
165}
166
167DECLCALLBACK(int) iface_SetVisibleRegion(PPDMIVMMDEVCONNECTOR pInterface, uint32_t cRect, PRTRECT pRect)
168{
169 /* not implemented */
170 return VINF_SUCCESS;
171}
172
173DECLCALLBACK(int) iface_QueryVisibleRegion(PPDMIVMMDEVCONNECTOR pInterface, uint32_t *pcRect, PRTRECT pRect)
174{
175 /* not implemented */
176 return VINF_SUCCESS;
177}
178
179DECLCALLBACK(int) VMMDev::VideoModeSupported(PPDMIVMMDEVCONNECTOR pInterface, uint32_t display, uint32_t width, uint32_t height,
180 uint32_t bpp, bool *fSupported)
181{
182 PDRVMAINVMMDEV pDrv = PDMIVMMDEVCONNECTOR_2_MAINVMMDEV(pInterface);
183 (void)pDrv;
184
185 if (!fSupported)
186 return VERR_INVALID_PARAMETER;
187 *fSupported = true;
188 return VINF_SUCCESS;
189}
190
191DECLCALLBACK(int) VMMDev::GetHeightReduction(PPDMIVMMDEVCONNECTOR pInterface, uint32_t *heightReduction)
192{
193 PDRVMAINVMMDEV pDrv = PDMIVMMDEVCONNECTOR_2_MAINVMMDEV(pInterface);
194 (void)pDrv;
195
196 if (!heightReduction)
197 return VERR_INVALID_PARAMETER;
198 /* XXX hard-coded */
199 *heightReduction = 18;
200 return VINF_SUCCESS;
201}
202
203DECLCALLBACK(int) VMMDev::QueryBalloonSize(PPDMIVMMDEVCONNECTOR pInterface, uint32_t *pu32BalloonSize)
204{
205 PDRVMAINVMMDEV pDrv = PDMIVMMDEVCONNECTOR_2_MAINVMMDEV(pInterface);
206 (void)pDrv;
207
208 AssertPtr(pu32BalloonSize);
209 *pu32BalloonSize = 0;
210 return VINF_SUCCESS;
211}
212
213#ifdef VBOX_WITH_HGCM
214
215/* HGCM connector interface */
216
217static DECLCALLBACK(int) iface_hgcmConnect (PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, PHGCMSERVICELOCATION pServiceLocation, uint32_t *pu32ClientID)
218{
219 LogSunlover(("Enter\n"));
220
221 PDRVMAINVMMDEV pDrv = PDMIHGCMCONNECTOR_2_MAINVMMDEV(pInterface);
222
223 if ( !pServiceLocation
224 || ( pServiceLocation->type != VMMDevHGCMLoc_LocalHost
225 && pServiceLocation->type != VMMDevHGCMLoc_LocalHost_Existing))
226 {
227 return VERR_INVALID_PARAMETER;
228 }
229
230 return HGCMGuestConnect (pDrv->pHGCMPort, pCmd, pServiceLocation->u.host.achName, pu32ClientID);
231}
232
233static DECLCALLBACK(int) iface_hgcmDisconnect (PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID)
234{
235 LogSunlover(("Enter\n"));
236
237 PDRVMAINVMMDEV pDrv = PDMIHGCMCONNECTOR_2_MAINVMMDEV(pInterface);
238
239 return HGCMGuestDisconnect (pDrv->pHGCMPort, pCmd, u32ClientID);
240}
241
242static DECLCALLBACK(int) iface_hgcmCall (PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID, uint32_t u32Function,
243 uint32_t cParms, PVBOXHGCMSVCPARM paParms)
244{
245 LogSunlover(("Enter\n"));
246
247 PDRVMAINVMMDEV pDrv = PDMIHGCMCONNECTOR_2_MAINVMMDEV(pInterface);
248
249 return HGCMGuestCall (pDrv->pHGCMPort, pCmd, u32ClientID, u32Function, cParms, paParms);
250}
251
252/**
253 * Execute state save operation.
254 *
255 * @returns VBox status code.
256 * @param pDrvIns Driver instance of the driver which registered the data unit.
257 * @param pSSM SSM operation handle.
258 */
259static DECLCALLBACK(int) iface_hgcmSave(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM)
260{
261 LogSunlover(("Enter\n"));
262 return HGCMHostSaveState (pSSM);
263}
264
265
266/**
267 * Execute state load operation.
268 *
269 * @returns VBox status code.
270 * @param pDrvIns Driver instance of the driver which registered the data unit.
271 * @param pSSM SSM operation handle.
272 * @param uVersion Data layout version.
273 * @param uPass The data pass.
274 */
275static DECLCALLBACK(int) iface_hgcmLoad(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
276{
277 LogFlowFunc(("Enter\n"));
278
279 if (uVersion != HGCM_SSM_VERSION)
280 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
281 Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
282
283 return HGCMHostLoadState (pSSM);
284}
285
286int VMMDev::hgcmLoadService (const char *pszServiceLibrary, const char *pszServiceName)
287{
288 return HGCMHostLoad (pszServiceLibrary, pszServiceName);
289}
290
291int VMMDev::hgcmHostCall (const char *pszServiceName, uint32_t u32Function,
292 uint32_t cParms, PVBOXHGCMSVCPARM paParms)
293{
294 return HGCMHostCall (pszServiceName, u32Function, cParms, paParms);
295}
296#endif /* HGCM */
297
298/**
299 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
300 */
301DECLCALLBACK(void *) VMMDev::drvQueryInterface(PPDMIBASE pInterface, const char *pszIID)
302{
303 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
304 PDRVMAINVMMDEV pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINVMMDEV);
305 if (RTUuidCompare2Strs(pszIID, PDMIBASE_IID) == 0)
306 return &pDrvIns->IBase;
307 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIVMMDEVCONNECTOR, &pDrv->Connector);
308#ifdef VBOX_WITH_HGCM
309 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHGCMCONNECTOR, fActivateHGCM() ? &pDrv->HGCMConnector : NULL);
310#endif
311 return NULL;
312}
313
314
315/**
316 * Destruct a VMMDev driver instance.
317 *
318 * @returns VBox status.
319 * @param pDrvIns The driver instance data.
320 */
321DECLCALLBACK(void) VMMDev::drvDestruct(PPDMDRVINS pDrvIns)
322{
323 /*PDRVMAINVMMDEV pData = PDMINS_2_DATA(pDrvIns, PDRVMAINVMMDEV); - unused variables makes gcc bitch. */
324}
325
326
327/**
328 * Construct a VMMDev driver instance.
329 *
330 * @copydoc FNPDMDRVCONSTRUCT
331 */
332DECLCALLBACK(int) VMMDev::drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
333{
334 PDRVMAINVMMDEV pData = PDMINS_2_DATA(pDrvIns, PDRVMAINVMMDEV);
335 LogFlow(("Keyboard::drvConstruct: iInstance=%d\n", pDrvIns->iInstance));
336
337 /*
338 * Validate configuration.
339 */
340 if (!CFGMR3AreValuesValid(pCfg, "Object\0"))
341 return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
342 AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
343 ("Configuration error: Not possible to attach anything to this driver!\n"),
344 VERR_PDM_DRVINS_NO_ATTACH);
345
346 /*
347 * IBase.
348 */
349 pDrvIns->IBase.pfnQueryInterface = VMMDev::drvQueryInterface;
350
351 //pData->Connector.pfnUpdateGuestStatus = VMMDev::UpdateGuestStatus;
352 //pData->Connector.pfnUpdateGuestInfo = VMMDev::UpdateGuestInfo;
353 //pData->Connector.pfnUpdateGuestCapabilities = VMMDev::UpdateGuestCapabilities;
354 pData->Connector.pfnUpdateMouseCapabilities = VMMDev::UpdateMouseCapabilities;
355 pData->Connector.pfnUpdatePointerShape = VMMDev::UpdatePointerShape;
356 pData->Connector.pfnVideoAccelEnable = iface_VideoAccelEnable;
357 pData->Connector.pfnVideoAccelFlush = iface_VideoAccelFlush;
358 pData->Connector.pfnVideoModeSupported = VMMDev::VideoModeSupported;
359 pData->Connector.pfnGetHeightReduction = VMMDev::GetHeightReduction;
360 pData->Connector.pfnSetVisibleRegion = iface_SetVisibleRegion;
361 pData->Connector.pfnQueryVisibleRegion = iface_QueryVisibleRegion;
362 pData->Connector.pfnQueryBalloonSize = VMMDev::QueryBalloonSize;
363
364#ifdef VBOX_WITH_HGCM
365 if (fActivateHGCM())
366 {
367 pData->HGCMConnector.pfnConnect = iface_hgcmConnect;
368 pData->HGCMConnector.pfnDisconnect = iface_hgcmDisconnect;
369 pData->HGCMConnector.pfnCall = iface_hgcmCall;
370 }
371#endif
372
373 /*
374 * Get the IVMMDevPort interface of the above driver/device.
375 */
376 pData->pUpPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIVMMDEVPORT);
377 AssertMsgReturn(pData->pUpPort, ("Configuration error: No VMMDev port interface above!\n"), VERR_PDM_MISSING_INTERFACE_ABOVE);
378
379#ifdef VBOX_WITH_HGCM
380 if (fActivateHGCM())
381 {
382 pData->pHGCMPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIHGCMPORT);
383 AssertMsgReturn(pData->pHGCMPort, ("Configuration error: No HGCM port interface above!\n"), VERR_PDM_MISSING_INTERFACE_ABOVE);
384 }
385#endif
386
387 /*
388 * Get the VMMDev object pointer and update the mpDrv member.
389 */
390 void *pv;
391 int rc = CFGMR3QueryPtr(pCfg, "Object", &pv);
392 if (RT_FAILURE(rc))
393 {
394 AssertMsgFailed(("Configuration error: No/bad \"Object\" value! rc=%Rrc\n", rc));
395 return rc;
396 }
397
398 pData->pVMMDev = (VMMDev*)pv; /** @todo Check this cast! */
399 pData->pVMMDev->mpDrv = pData;
400
401#ifdef VBOX_WITH_HGCM
402 if (fActivateHGCM())
403 {
404 rc = pData->pVMMDev->hgcmLoadService (VBOXSHAREDFOLDERS_DLL, "VBoxSharedFolders");
405 pData->pVMMDev->fSharedFolderActive = RT_SUCCESS(rc);
406 if (RT_SUCCESS(rc))
407 LogRel(("Shared Folders service loaded.\n"));
408 else
409 LogRel(("Failed to load Shared Folders service %Rrc\n", rc));
410
411
412 rc = PDMDrvHlpSSMRegisterEx(pDrvIns, HGCM_SSM_VERSION, 4096 /* bad guess */,
413 NULL, NULL, NULL,
414 NULL, iface_hgcmSave, NULL,
415 NULL, iface_hgcmLoad, NULL);
416 if (RT_FAILURE(rc))
417 return rc;
418
419 }
420#endif /* VBOX_WITH_HGCM */
421
422 return VINF_SUCCESS;
423}
424
425
426/**
427 * VMMDevice driver registration record.
428 */
429const PDMDRVREG VMMDev::DrvReg =
430{
431 /* u32Version */
432 PDM_DRVREG_VERSION,
433 /* szName */
434 "HGCM",
435 /* szRCMod */
436 "",
437 /* szR0Mod */
438 "",
439 /* pszDescription */
440 "Main VMMDev driver (Main as in the API).",
441 /* fFlags */
442 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
443 /* fClass. */
444 PDM_DRVREG_CLASS_VMMDEV,
445 /* cMaxInstances */
446 ~0U,
447 /* cbInstance */
448 sizeof(DRVMAINVMMDEV),
449 /* pfnConstruct */
450 VMMDev::drvConstruct,
451 /* pfnDestruct */
452 VMMDev::drvDestruct,
453 /* pfnRelocate */
454 NULL,
455 /* pfnIOCtl */
456 NULL,
457 /* pfnPowerOn */
458 NULL,
459 /* pfnReset */
460 NULL,
461 /* pfnSuspend */
462 NULL,
463 /* pfnResume */
464 NULL,
465 /* pfnAttach */
466 NULL,
467 /* pfnDetach */
468 NULL,
469 /* pfnPowerOff */
470 NULL,
471 /* pfnSoftReset */
472 NULL,
473 /* u32EndVersion */
474 PDM_DRVREG_VERSION
475};
476
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