STDMETHODIMP Guest::COMSETTER(MemoryBalloonSize)(ULONG aMemoryBalloonSize)
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/* We must be 100% sure that IMachine::COMSETTER(MemoryBalloonSize)
* does not call us back in any way! */
HRESULT ret = mParent->machine()->COMSETTER(MemoryBalloonSize)(aMemoryBalloonSize);
if (ret == S_OK)
{
mMemoryBalloonSize = aMemoryBalloonSize;
/* forward the information to the VMM device */
VMMDev *pVMMDev = mParent->getVMMDev();
/* MUST release all locks before calling VMM device as its critsect
* has higher lock order than anything in Main. */
alock.release();
if (pVMMDev)
{
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (pVMMDevPort)
pVMMDevPort->pfnSetMemoryBalloon(pVMMDevPort, aMemoryBalloonSize);
}
}
return ret;
}
STDMETHODIMP Guest::SetCredentials(IN_BSTR aUserName, IN_BSTR aPassword,
IN_BSTR aDomain, BOOL aAllowInteractiveLogon)
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/* forward the information to the VMM device */
VMMDev *pVMMDev = mParent->getVMMDev();
if (pVMMDev)
{
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (pVMMDevPort)
{
uint32_t u32Flags = VMMDEV_SETCREDENTIALS_GUESTLOGON;
if (!aAllowInteractiveLogon)
u32Flags = VMMDEV_SETCREDENTIALS_NOLOCALLOGON;
pVMMDevPort->pfnSetCredentials(pVMMDevPort,
Utf8Str(aUserName).c_str(),
Utf8Str(aPassword).c_str(),
Utf8Str(aDomain).c_str(),
u32Flags);
return S_OK;
}
}
return setError(VBOX_E_VM_ERROR,
tr("VMM device is not available (is the VM running?)"));
}
void Display::SetVideoModeHint(ULONG aWidth, ULONG aHeight, ULONG aBitsPerPixel, ULONG aDisplay)
{
PPDMIVMMDEVPORT pVMMDevPort = gVMMDev->getVMMDevPort ();
if (pVMMDevPort)
pVMMDevPort->pfnRequestDisplayChange(pVMMDevPort, aWidth, aHeight, aBitsPerPixel, aDisplay);
}
STDMETHODIMP Guest::COMSETTER(StatisticsUpdateInterval)(ULONG aUpdateInterval)
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
if (mStatUpdateInterval)
if (aUpdateInterval == 0)
RTTimerLRStop(mStatTimer);
else
RTTimerLRChangeInterval(mStatTimer, aUpdateInterval);
else
if (aUpdateInterval != 0)
{
RTTimerLRChangeInterval(mStatTimer, aUpdateInterval);
RTTimerLRStart(mStatTimer, 0);
}
mStatUpdateInterval = aUpdateInterval;
/* forward the information to the VMM device */
VMMDev *pVMMDev = mParent->getVMMDev();
/* MUST release all locks before calling VMM device as its critsect
* has higher lock order than anything in Main. */
alock.release();
if (pVMMDev)
{
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (pVMMDevPort)
pVMMDevPort->pfnSetStatisticsInterval(pVMMDevPort, aUpdateInterval);
}
return S_OK;
}
void Display::SetVideoModeHint(ULONG aDisplay, BOOL aEnabled,
BOOL aChangeOrigin, LONG aOriginX, LONG aOriginY,
ULONG aWidth, ULONG aHeight, ULONG aBitsPerPixel)
{
PPDMIVMMDEVPORT pVMMDevPort = gVMMDev->getVMMDevPort ();
if (pVMMDevPort)
pVMMDevPort->pfnRequestDisplayChange(pVMMDevPort, aWidth, aHeight, aBitsPerPixel,
aDisplay, aOriginX, aOriginY, aEnabled, aChangeOrigin);
}
/** Report the front-end's mouse handling capabilities to the VMM device and
* thus to the guest.
* @note all calls out of this object are made with no locks held! */
HRESULT Mouse::updateVMMDevMouseCaps(uint32_t fCapsAdded,
uint32_t fCapsRemoved)
{
VMMDevMouseInterface *pVMMDev = mParent->getVMMDevMouseInterface();
if (!pVMMDev)
return E_FAIL; /* No assertion, as the front-ends can send events
* at all sorts of inconvenient times. */
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (!pVMMDevPort)
return E_FAIL; /* same here */
int rc = pVMMDevPort->pfnUpdateMouseCapabilities(pVMMDevPort, fCapsAdded,
fCapsRemoved);
return RT_SUCCESS(rc) ? S_OK : E_FAIL;
}
/**
* Send an absolute position event to the VMM device.
* @note all calls out of this object are made with no locks held!
*
* @returns COM status code
*/
HRESULT Mouse::reportAbsEventToVMMDev(int32_t x, int32_t y)
{
VMMDevMouseInterface *pVMMDev = mParent->getVMMDevMouseInterface();
ComAssertRet(pVMMDev, E_FAIL);
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
ComAssertRet(pVMMDevPort, E_FAIL);
if (x != mcLastX || y != mcLastY)
{
int vrc = pVMMDevPort->pfnSetAbsoluteMouse(pVMMDevPort,
x, y);
if (RT_FAILURE(vrc))
return setError(VBOX_E_IPRT_ERROR,
tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
vrc);
}
return S_OK;
}
/**
* Send an absolute position event to the VMM device.
* @note all calls out of this object are made with no locks held!
*
* @returns COM status code
*/
HRESULT Mouse::reportAbsEventToVMMDev(int32_t mouseXAbs, int32_t mouseYAbs)
{
VMMDev *pVMMDev = mParent->getVMMDev();
ComAssertRet(pVMMDev, E_FAIL);
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
ComAssertRet(pVMMDevPort, E_FAIL);
if (mouseXAbs != mcLastAbsX || mouseYAbs != mcLastAbsY)
{
int vrc = pVMMDevPort->pfnSetAbsoluteMouse(pVMMDevPort,
mouseXAbs, mouseYAbs);
if (RT_FAILURE(vrc))
return setError(VBOX_E_IPRT_ERROR,
tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
vrc);
}
return S_OK;
}
/** Report the front-end's mouse handling capabilities to the VMM device and
* thus to the guest.
* @note all calls out of this object are made with no locks held! */
HRESULT Mouse::updateVMMDevMouseCaps(uint32_t fCapsAdded,
uint32_t fCapsRemoved)
{
VMMDevMouseInterface *pVMMDev = mParent->getVMMDevMouseInterface();
if (!pVMMDev)
return E_FAIL; /* No assertion, as the front-ends can send events
* at all sorts of inconvenient times. */
DisplayMouseInterface *pDisplay = mParent->getDisplayMouseInterface();
if (pDisplay == NULL)
return E_FAIL;
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (!pVMMDevPort)
return E_FAIL; /* same here */
int rc = pVMMDevPort->pfnUpdateMouseCapabilities(pVMMDevPort, fCapsAdded,
fCapsRemoved);
if (RT_FAILURE(rc))
return E_FAIL;
return pDisplay->i_reportHostCursorCapabilities(fCapsAdded, fCapsRemoved);
}
HRESULT Guest::setCredentials(const com::Utf8Str &aUserName, const com::Utf8Str &aPassword,
const com::Utf8Str &aDomain, BOOL aAllowInteractiveLogon)
{
/* Check for magic domain names which are used to pass encryption keys to the disk. */
if (Utf8Str(aDomain) == "@@disk")
return mParent->i_setDiskEncryptionKeys(aPassword);
else if (Utf8Str(aDomain) == "@@mem")
{
/** @todo */
return E_NOTIMPL;
}
else
{
/* forward the information to the VMM device */
VMMDev *pVMMDev = mParent->i_getVMMDev();
if (pVMMDev)
{
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (pVMMDevPort)
{
uint32_t u32Flags = VMMDEV_SETCREDENTIALS_GUESTLOGON;
if (!aAllowInteractiveLogon)
u32Flags = VMMDEV_SETCREDENTIALS_NOLOCALLOGON;
pVMMDevPort->pfnSetCredentials(pVMMDevPort,
aUserName.c_str(),
aPassword.c_str(),
aDomain.c_str(),
u32Flags);
return S_OK;
}
}
}
return setError(VBOX_E_VM_ERROR,
tr("VMM device is not available (is the VM running?)"));
}
int Display::i_videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort)
{
int rc = VINF_SUCCESS;
VIDEOACCEL *pVideoAccel = &mVideoAccelLegacy;
/* Called each time the guest wants to use acceleration,
* or when the VGA device disables acceleration,
* or when restoring the saved state with accel enabled.
*
* VGA device disables acceleration on each video mode change
* and on reset.
*
* Guest enabled acceleration at will. And it has to enable
* acceleration after a mode change.
*/
LogRelFlowFunc(("mfVideoAccelEnabled = %d, fEnable = %d, pVbvaMemory = %p\n",
pVideoAccel->fVideoAccelEnabled, fEnable, pVbvaMemory));
/* Strictly check parameters. Callers must not pass anything in the case. */
Assert((fEnable && pVbvaMemory) || (!fEnable && pVbvaMemory == NULL));
if (!i_VideoAccelAllowed ())
return VERR_NOT_SUPPORTED;
/* Check that current status is not being changed */
if (pVideoAccel->fVideoAccelEnabled == fEnable)
return rc;
if (pVideoAccel->fVideoAccelEnabled)
{
/* Process any pending orders and empty the VBVA ring buffer. */
i_videoAccelFlush (pUpPort);
}
if (!fEnable && pVideoAccel->pVbvaMemory)
pVideoAccel->pVbvaMemory->fu32ModeFlags &= ~VBVA_F_MODE_ENABLED;
if (fEnable)
{
/* Process any pending VGA device changes, resize. */
pUpPort->pfnUpdateDisplayAll(pUpPort, /* fFailOnResize = */ false);
}
/* Protect the videoaccel state transition. */
RTCritSectEnter(&mVideoAccelLock);
if (fEnable)
{
/* Initialize the hardware memory. */
i_vbvaSetMemoryFlags(pVbvaMemory, true, mfVideoAccelVRDP,
mfu32SupportedOrders, maFramebuffers, mcMonitors);
pVbvaMemory->off32Data = 0;
pVbvaMemory->off32Free = 0;
memset(pVbvaMemory->aRecords, 0, sizeof(pVbvaMemory->aRecords));
pVbvaMemory->indexRecordFirst = 0;
pVbvaMemory->indexRecordFree = 0;
pVideoAccel->pVbvaMemory = pVbvaMemory;
pVideoAccel->fVideoAccelEnabled = true;
LogRel(("VBVA: Enabled.\n"));
}
else
{
pVideoAccel->pVbvaMemory = NULL;
pVideoAccel->fVideoAccelEnabled = false;
LogRel(("VBVA: Disabled.\n"));
}
RTCritSectLeave(&mVideoAccelLock);
if (!fEnable)
{
pUpPort->pfnUpdateDisplayAll(pUpPort, /* fFailOnResize = */ false);
}
/* Notify the VMMDev, which saves VBVA status in the saved state,
* and needs to know current status.
*/
VMMDev *pVMMDev = mParent->i_getVMMDev();
if (pVMMDev)
{
PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
if (pVMMDevPort)
pVMMDevPort->pfnVBVAChange(pVMMDevPort, fEnable);
}
LogRelFlowFunc(("%Rrc.\n", rc));
return rc;
}
/**
* @thread EMT
*/
int Display::VideoAccelEnable (bool fEnable, VBVAMEMORY *pVbvaMemory)
{
int rc = VINF_SUCCESS;
/* Called each time the guest wants to use acceleration,
* or when the VGA device disables acceleration,
* or when restoring the saved state with accel enabled.
*
* VGA device disables acceleration on each video mode change
* and on reset.
*
* Guest enabled acceleration at will. And it needs to enable
* acceleration after a mode change.
*/
LogFlow(("Display::VideoAccelEnable: mfVideoAccelEnabled = %d, fEnable = %d, pVbvaMemory = %p\n",
mfVideoAccelEnabled, fEnable, pVbvaMemory));
/* Strictly check parameters. Callers must not pass anything in the case. */
Assert((fEnable && pVbvaMemory) || (!fEnable && pVbvaMemory == NULL));
if (!VideoAccelAllowed ())
return VERR_NOT_SUPPORTED;
/*
* Verify that the VM is in running state. If it is not,
* then this must be postponed until it goes to running.
*/
if (!mfMachineRunning)
{
Assert (!mfVideoAccelEnabled);
LogFlow(("Display::VideoAccelEnable: Machine is not yet running.\n"));
if (fEnable)
{
mfPendingVideoAccelEnable = fEnable;
mpPendingVbvaMemory = pVbvaMemory;
}
return rc;
}
/* Check that current status is not being changed */
if (mfVideoAccelEnabled == fEnable)
return rc;
if (mfVideoAccelEnabled)
{
/* Process any pending orders and empty the VBVA ring buffer. */
VideoAccelFlush ();
}
if (!fEnable && mpVbvaMemory)
mpVbvaMemory->fu32ModeFlags &= ~VBVA_F_MODE_ENABLED;
/* Safety precaution. There is no more VBVA until everything is setup! */
mpVbvaMemory = NULL;
mfVideoAccelEnabled = false;
/* Update entire display. */
mpDrv->pUpPort->pfnUpdateDisplayAll(mpDrv->pUpPort);
/* Everything OK. VBVA status can be changed. */
/* Notify the VMMDev, which saves VBVA status in the saved state,
* and needs to know current status.
*/
PPDMIVMMDEVPORT pVMMDevPort = gVMMDev->getVMMDevPort ();
if (pVMMDevPort)
pVMMDevPort->pfnVBVAChange (pVMMDevPort, fEnable);
if (fEnable)
{
mpVbvaMemory = pVbvaMemory;
mfVideoAccelEnabled = true;
/* Initialize the hardware memory. */
vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, false);
mpVbvaMemory->off32Data = 0;
mpVbvaMemory->off32Free = 0;
memset (mpVbvaMemory->aRecords, 0, sizeof (mpVbvaMemory->aRecords));
mpVbvaMemory->indexRecordFirst = 0;
mpVbvaMemory->indexRecordFree = 0;
LogRel(("VBVA: Enabled.\n"));
}
else
{
LogRel(("VBVA: Disabled.\n"));
}
LogFlow(("Display::VideoAccelEnable: rc = %Rrc.\n", rc));
return rc;
}
