/**
* Stop all service threads and free the device chain.
*/
USBProxyServiceFreeBSD::~USBProxyServiceFreeBSD()
{
LogFlowThisFunc(("\n"));
/*
* Stop the service.
*/
if (isActive())
stop();
RTSemEventDestroy(mNotifyEventSem);
mNotifyEventSem = NULL;
}
STDMETHODIMP Session::OnNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter)
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
return mConsole->onNetworkAdapterChange(networkAdapter, changeAdapter);
}
STDMETHODIMP Session::OnCPUExecutionCapChange(ULONG aExecutionCap)
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
return mConsole->onCPUExecutionCapChange(aExecutionCap);
}
int VBoxMainDriveInfo::updateFloppies ()
{
LogFlowThisFunc(("entered\n"));
int rc = VINF_SUCCESS;
bool fSuccess = false; /* Have we succeeded in finding anything yet? */
try
{
mFloppyList.clear ();
/* Always allow the user to override our auto-detection using an
* environment variable. */
if (RT_SUCCESS(rc) && !fSuccess)
rc = getDriveInfoFromEnv("VBOX_FLOPPY", &mFloppyList, false /* isDVD */,
&fSuccess);
}
catch(std::bad_alloc &e)
{
rc = VERR_NO_MEMORY;
}
LogFlowThisFunc(("rc=%Rrc\n", rc));
return rc;
}
STDMETHODIMP ProgressProxy::WaitForCompletion(LONG aTimeout)
{
HRESULT hrc;
LogFlowThisFuncEnter();
LogFlowThisFunc(("aTimeout=%d\n", aTimeout));
/* No need to wait on the proxied object for these since we'll get the
normal completion notifications. */
hrc = Progress::WaitForCompletion(aTimeout);
LogFlowThisFuncLeave();
return hrc;
}
void USBProxyServiceDarwin::releaseDeviceCompleted(HostUSBDevice *aDevice, bool aSuccess)
{
AssertReturnVoid(aDevice->isWriteLockOnCurrentThread());
#ifdef VBOX_WITH_NEW_USB_CODE_ON_DARWIN
/*
* Remove the one-shot filter if necessary.
*/
LogFlowThisFunc(("aDevice=%s aSuccess=%RTbool mOneShotId=%p\n", aDevice->getName().c_str(), aSuccess, aDevice->mOneShotId));
if (!aSuccess && aDevice->mOneShotId)
USBLibRemoveFilter(aDevice->mOneShotId);
aDevice->mOneShotId = NULL;
#endif
}
STDMETHODIMP Session::OnMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce)
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
return mConsole->onMediumChange(aMediumAttachment, aForce);
}
/**
* Uninitializes the instance and sets the ready flag to FALSE.
* Called either from FinalRelease() or by the parent when it gets destroyed.
*/
void Guest::uninit()
{
LogFlowThisFunc(("\n"));
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan(this);
if (autoUninitSpan.uninitDone())
return;
#ifdef VBOX_WITH_GUEST_CONTROL
/* Scope write lock as much as possible. */
{
/*
* Cleanup must be done *before* AutoUninitSpan to cancel all
* all outstanding waits in API functions (which hold AutoCaller
* ref counts).
*/
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/* Notify left over callbacks that we are about to shutdown ... */
CallbackMapIter it;
for (it = mCallbackMap.begin(); it != mCallbackMap.end(); it++)
{
int rc2 = callbackNotifyEx(it->first, VERR_CANCELLED,
Guest::tr("VM is shutting down, canceling uncompleted guest requests ..."));
AssertRC(rc2);
}
/* Destroy left over callback data. */
for (it = mCallbackMap.begin(); it != mCallbackMap.end(); it++)
callbackDestroy(it->first);
/* Clear process map (remove all callbacks). */
mGuestProcessMap.clear();
}
#endif
/* Destroy stat update timer */
int vrc = RTTimerLRDestroy (mStatTimer);
AssertMsgRC (vrc, ("Failed to create guest statistics "
"update timer(%Rra)\n", vrc));
mStatTimer = NULL;
mMagic = 0;
#ifdef VBOX_WITH_DRAG_AND_DROP
delete m_pGuestDnD;
m_pGuestDnD = NULL;
#endif
unconst(mParent) = NULL;
}
STDMETHODIMP NetworkAdapter::SetProperty(IN_BSTR aKey, IN_BSTR aValue)
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/* The machine needs to be mutable. */
AutoMutableStateDependency adep(mParent);
if (FAILED(adep.rc())) return adep.rc();
Bstr key = aKey;
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
bool fGenericChange = (mData->mAttachmentType == NetworkAttachmentType_Generic);
/* Generic properties processing.
* Look up the old value first; if nothing's changed then do nothing.
*/
Utf8Str strValue(aValue);
Utf8Str strKey(aKey);
Utf8Str strOldValue;
settings::StringsMap::const_iterator it = mData->mGenericProperties.find(strKey);
if (it != mData->mGenericProperties.end())
strOldValue = it->second;
if (strOldValue != strValue)
{
if (strValue.isEmpty())
mData->mGenericProperties.erase(strKey);
else
mData->mGenericProperties[strKey] = strValue;
/* leave the lock before informing callbacks */
alock.release();
AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);
mParent->setModified(Machine::IsModified_NetworkAdapters);
mlock.release();
/* Avoid deadlock when the event triggers a call to a method of this
* interface. */
adep.release();
mParent->onNetworkAdapterChange(this, fGenericChange);
}
return S_OK;
}
/**
* Issued by the guest when a guest user changed its state.
*
* @return IPRT status code.
* @param aUser Guest user name.
* @param aDomain Domain of guest user account. Optional.
* @param enmState New state to indicate.
* @param pbDetails Pointer to state details. Optional.
* @param cbDetails Size (in bytes) of state details. Pass 0 if not used.
*/
void Guest::i_onUserStateChange(Bstr aUser, Bstr aDomain, VBoxGuestUserState enmState,
const uint8_t *pbDetails, uint32_t cbDetails)
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
AssertComRCReturnVoid(autoCaller.rc());
Bstr strDetails; /** @todo Implement state details here. */
fireGuestUserStateChangedEvent(mEventSource, aUser.raw(), aDomain.raw(),
(GuestUserState_T)enmState, strDetails.raw());
LogFlowFuncLeave();
}
/**
* Uninitializes the instance and sets the ready flag to FALSE.
* Called either from FinalRelease() or by the parent when it gets destroyed.
*/
void AudioAdapter::uninit()
{
LogFlowThisFunc(("\n"));
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan(this);
if (autoUninitSpan.uninitDone())
return;
mData.free();
unconst(mPeer) = NULL;
unconst(mParent) = NULL;
}
void DisplaySourceBitmap::uninit()
{
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan(this);
if (autoUninitSpan.uninitDone())
return;
LogFlowThisFunc(("[%u]\n", m.uScreenId));
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
m.pDisplay.setNull();
RTMemFree(m.pu8Allocated);
}
int SessionTaskCopyFrom::RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress)
{
LogFlowThisFunc(("strDesc=%s, strSource=%s, strDest=%s, uFlags=%x\n",
strDesc.c_str(), mSource.c_str(), mDest.c_str(), mFlags));
mDesc = strDesc;
mProgress = pProgress;
int rc = RTThreadCreate(NULL, SessionTaskCopyFrom::taskThread, this,
0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
"gctlCpyFrom");
LogFlowFuncLeaveRC(rc);
return rc;
}
STDMETHODIMP Session::OnUSBDeviceDetach(IN_BSTR aId,
IVirtualBoxErrorInfo *aError)
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
return mConsole->onUSBDeviceDetach(aId, aError);
}
STDMETHODIMP GuestDirectory::Close(void)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AssertPtr(mData.mSession);
int rc = mData.mSession->directoryRemoveFromList(this);
AssertRC(rc);
HRESULT hr = S_OK;
int guestRc;
rc = mData.mProcessTool.Terminate(30 * 1000, &guestRc);
if (RT_FAILURE(rc))
{
switch (rc)
{
case VERR_GSTCTL_GUEST_ERROR:
hr = GuestProcess::setErrorExternal(this, guestRc);
break;
case VERR_NOT_SUPPORTED:
/* Silently skip old Guest Additions which do not support killing the
* the guest directory handling process. */
break;
default:
hr = setError(VBOX_E_IPRT_ERROR,
tr("Terminating open guest directory \"%s\" failed: %Rrc"),
mData.mName.c_str(), rc);
break;
}
}
/*
* Release autocaller before calling uninit.
*/
autoCaller.release();
uninit();
LogFlowThisFunc(("Returning rc=%Rrc\n", rc));
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP Session::UnlockMachine()
{
LogFlowThisFunc(("mState=%d, mType=%d\n", mState, mType));
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/* close() needs write lock */
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
CHECK_OPEN();
return unlockMachine(false /* aFinalRelease */, false /* aFromServer */);
}
STDMETHODIMP Session::OnSharedFolderChange(BOOL aGlobal)
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
return mConsole->onSharedFolderChange(aGlobal);
}
int GuestDnDBase::getProtocolVersion(uint32_t *puVersion)
{
AssertPtrReturn(puVersion, VERR_INVALID_POINTER);
int rc;
uint32_t uVer, uVerAdditions = 0;
if ( m_pGuest
&& (uVerAdditions = m_pGuest->i_getAdditionsVersion()) > 0)
{
uint32_t uVBoxMajor = VBOX_FULL_VERSION_GET_MAJOR(uVerAdditions);
uint32_t uVBoxMinor = VBOX_FULL_VERSION_GET_MINOR(uVerAdditions);
#if 0 /*def DEBUG_andy*/
/* Hardcode the to-used protocol version; nice for testing side effects. */
uVer = 2;
#else
uVer = ( uVBoxMajor >= 5)
? 2 /* VBox 5.0 and up: Protocol version 2. */
: 1; /* VBox <= 4.3: Protocol version 1. */
/* Build revision is ignored. */
#endif
LogFlowThisFunc(("uVerAdditions=%RU32 (%RU32.%RU32)\n", uVerAdditions, uVBoxMajor, uVBoxMinor));
rc = VINF_SUCCESS;
}
else
{
uVer = 1; /* Fallback. */
rc = VERR_NOT_FOUND;
}
LogFlowThisFunc(("uVer=%RU32, uVerAdditions=%RU32, rc=%Rrc\n", uVer, uVerAdditions, rc));
*puVersion = uVer;
return rc;
}
int USBProxyServiceSolaris::releaseDevice(HostUSBDevice *aDevice)
{
/*
* Check preconditions.
*/
AssertReturn(aDevice, VERR_GENERAL_FAILURE);
LogFlowThisFunc(("aDevice=%s\n", aDevice->getName().c_str()));
AssertReturn(aDevice->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE);
Assert(aDevice->getUnistate() == kHostUSBDeviceState_ReleasingToHost);
AssertReturn(aDevice->mUsb, VERR_INVALID_POINTER);
/*
* Create a one-shot ignore filter for the device and reset it.
*/
USBFILTER Filter;
USBFilterInit(&Filter, USBFILTERTYPE_ONESHOT_IGNORE);
initFilterFromDevice(&Filter, aDevice);
void *pvId = USBLibAddFilter(&Filter);
if (!pvId)
{
LogRel(("USBService: Adding ignore filter failed!\n"));
return VERR_GENERAL_FAILURE;
}
PUSBDEVICE pDev = aDevice->mUsb;
int rc = USBLibResetDevice(pDev->pszDevicePath, true /* Re-attach */);
if (RT_SUCCESS(rc))
aDevice->mOneShotId = pvId;
else
{
USBLibRemoveFilter(pvId);
pvId = NULL;
}
LogFlowThisFunc(("returns %Rrc pvId=%p\n", rc, pvId));
return rc;
}
/**
* @note XPCOM: when this method is not called on the main XPCOM thread, it
* simply blocks the thread until mCompletedSem is signalled. If the
* thread has its own event queue (hmm, what for?) that it must run, then
* calling this method will definitely freeze event processing.
*/
HRESULT Progress::waitForCompletion(LONG aTimeout)
{
LogFlowThisFuncEnter();
LogFlowThisFunc(("aTimeout=%d\n", aTimeout));
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/* if we're already completed, take a shortcut */
if (!mCompleted)
{
int vrc = VINF_SUCCESS;
bool fForever = aTimeout < 0;
int64_t timeLeft = aTimeout;
int64_t lastTime = RTTimeMilliTS();
while (!mCompleted && (fForever || timeLeft > 0))
{
mWaitersCount++;
alock.release();
vrc = RTSemEventMultiWait(mCompletedSem,
fForever ? RT_INDEFINITE_WAIT : (RTMSINTERVAL)timeLeft);
alock.acquire();
mWaitersCount--;
/* the last waiter resets the semaphore */
if (mWaitersCount == 0)
RTSemEventMultiReset(mCompletedSem);
if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
break;
if (!fForever)
{
int64_t now = RTTimeMilliTS();
timeLeft -= now - lastTime;
lastTime = now;
}
}
if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
return setError(VBOX_E_IPRT_ERROR,
tr("Failed to wait for the task completion (%Rrc)"),
vrc);
}
LogFlowThisFuncLeave();
return S_OK;
}
int GuestBase::registerWaitEvent(uint32_t uSessionID, uint32_t uObjectID,
const GuestEventTypes &lstEvents,
GuestWaitEvent **ppEvent)
{
AssertPtrReturn(ppEvent, VERR_INVALID_POINTER);
uint32_t uContextID;
int rc = generateContextID(uSessionID, uObjectID, &uContextID);
if (RT_FAILURE(rc))
return rc;
rc = RTCritSectEnter(&mWaitEventCritSect);
if (RT_SUCCESS(rc))
{
try
{
GuestWaitEvent *pEvent = new GuestWaitEvent(uContextID, lstEvents);
AssertPtr(pEvent);
LogFlowThisFunc(("New event=%p, CID=%RU32\n", pEvent, uContextID));
/* Insert event into matching event group. This is for faster per-group
* lookup of all events later. */
for (GuestEventTypes::const_iterator itEvents = lstEvents.begin();
itEvents != lstEvents.end(); itEvents++)
{
mWaitEventGroups[(*itEvents)].insert(
std::pair<uint32_t, GuestWaitEvent*>(uContextID, pEvent));
/** @todo Check for key collision. */
}
/* Register event in regular event list. */
/** @todo Check for key collisions. */
mWaitEvents[uContextID] = pEvent;
*ppEvent = pEvent;
}
catch(std::bad_alloc &)
{
rc = VERR_NO_MEMORY;
}
int rc2 = RTCritSectLeave(&mWaitEventCritSect);
if (RT_SUCCESS(rc))
rc = rc2;
}
return rc;
}
int CollectorWin::getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle)
{
LogFlowThisFuncEnter();
FILETIME ftIdle, ftKernel, ftUser;
if (mpfnGetSystemTimes)
{
if (!mpfnGetSystemTimes(&ftIdle, &ftKernel, &ftUser))
{
DWORD dwError = GetLastError();
Log (("GetSystemTimes() -> 0x%x\n", dwError));
return RTErrConvertFromWin32(dwError);
}
*user = FILETTIME_TO_100NS(ftUser);
*idle = FILETTIME_TO_100NS(ftIdle);
*kernel = FILETTIME_TO_100NS(ftKernel) - *idle;
}
else
{
/* GetSystemTimes is not available, fall back to NtQuerySystemInformation */
if (!mpfnNtQuerySystemInformation)
return VERR_NOT_IMPLEMENTED;
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION sppi[MAXIMUM_PROCESSORS];
ULONG ulReturned;
NTSTATUS status = mpfnNtQuerySystemInformation(
SystemProcessorPerformanceInformation, &sppi, sizeof(sppi), &ulReturned);
if (NT_ERROR(status))
{
Log(("NtQuerySystemInformation() -> 0x%x\n", status));
return RTErrConvertFromNtStatus(status);
}
/* Sum up values across all processors */
*user = *kernel = *idle = 0;
for (unsigned i = 0; i < ulReturned / sizeof(sppi[0]); ++i)
{
*idle += sppi[i].IdleTime.QuadPart;
*kernel += sppi[i].KernelTime.QuadPart - sppi[i].IdleTime.QuadPart;
*user += sppi[i].UserTime.QuadPart;
}
}
LogFlowThisFunc(("user=%lu kernel=%lu idle=%lu\n", *user, *kernel, *idle));
LogFlowThisFuncLeave();
return VINF_SUCCESS;
}
int GuestDirectory::init(GuestSession *aSession,
const Utf8Str &strPath, const Utf8Str &strFilter, uint32_t uFlags)
{
LogFlowThisFunc(("strPath=%s, strFilter=%s, uFlags=%x\n",
strPath.c_str(), strFilter.c_str(), uFlags));
/* Enclose the state transition NotReady->InInit->Ready. */
AutoInitSpan autoInitSpan(this);
AssertReturn(autoInitSpan.isOk(), E_FAIL);
mData.mSession = aSession;
mData.mName = strPath;
mData.mFilter = strFilter;
mData.mFlags = uFlags;
/* Start the directory process on the guest. */
GuestProcessStartupInfo procInfo;
procInfo.mName = Utf8StrFmt(tr("Reading directory \"%s\"", strPath.c_str()));
procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_LS);
procInfo.mTimeoutMS = 5 * 60 * 1000; /* 5 minutes timeout. */
procInfo.mFlags = ProcessCreateFlag_WaitForStdOut;
procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
/* We want the long output format which contains all the object details. */
procInfo.mArguments.push_back(Utf8Str("-l"));
#if 0 /* Flags are not supported yet. */
if (uFlags & DirectoryOpenFlag_NoSymlinks)
procInfo.mArguments.push_back(Utf8Str("--nosymlinks")); /** @todo What does GNU here? */
#endif
/** @todo Recursion support? */
procInfo.mArguments.push_back(strPath); /* The directory we want to open. */
/*
* Start the process asynchronously and keep it around so that we can use
* it later in subsequent read() calls.
* Note: No guest rc available because operation is asynchronous.
*/
int rc = mData.mProcessTool.Init(mData.mSession, procInfo,
true /* Async */, NULL /* Guest rc */);
if (RT_SUCCESS(rc))
{
/* Confirm a successful initialization when it's the case. */
autoInitSpan.setSucceeded();
return rc;
}
autoInitSpan.setFailed();
return rc;
}
/**
* Uninitializes the instance and sets the ready flag to FALSE.
* Called either from FinalRelease() or by the parent when it gets destroyed.
*/
void SharedFolder::uninit()
{
LogFlowThisFunc(("\n"));
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan(this);
if (autoUninitSpan.uninitDone())
return;
unconst(mParent) = NULL;
unconst(mMachine) = NULL;
unconst(mConsole) = NULL;
unconst(mVirtualBox) = NULL;
}
STDMETHODIMP ProgressProxy::WaitForOperationCompletion(ULONG aOperation, LONG aTimeout)
{
LogFlowThisFuncEnter();
LogFlowThisFunc(("aOperation=%d aTimeout=%d\n", aOperation, aTimeout));
AutoCaller autoCaller(this);
HRESULT hrc = autoCaller.rc();
if (SUCCEEDED(hrc))
{
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
CheckComArgExpr(aOperation, aOperation < m_cOperations);
/*
* Check if we can wait locally.
*/
if ( aOperation + 1 == m_cOperations /* final operation */
|| mptrOtherProgress.isNull())
{
/* ASSUMES that Progress::WaitForOperationCompletion is using
AutoWriteLock::leave() as it saves us from duplicating the code! */
hrc = Progress::WaitForOperationCompletion(aOperation, aTimeout);
}
else
{
LogFlowThisFunc(("calling the other object...\n"));
ComPtr<IProgress> ptrOtherProgress = mptrOtherProgress;
alock.release();
hrc = ptrOtherProgress->WaitForOperationCompletion(aOperation, aTimeout);
}
}
LogFlowThisFuncLeave();
return hrc;
}
void HostNetworkInterface::i_registerMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
{
LogFlowThisFunc(("mShortName={%ls}, mInterfaceName={%ls}, mGuid={%s}, mSpeedMbits=%u\n",
mShortName.raw(), mInterfaceName.raw(), mGuid.toString().c_str(), m.speedMbits));
pm::CollectorHAL *hal = aCollector->getHAL();
/* Create sub metrics */
Utf8StrFmt strName("Net/%ls", mShortName.raw());
pm::SubMetric *networkLoadRx = new pm::SubMetric(strName + "/Load/Rx",
"Percentage of network interface receive bandwidth used.");
pm::SubMetric *networkLoadTx = new pm::SubMetric(strName + "/Load/Tx",
"Percentage of network interface transmit bandwidth used.");
pm::SubMetric *networkLinkSpeed = new pm::SubMetric(strName + "/LinkSpeed",
"Physical link speed.");
/* Create and register base metrics */
pm::BaseMetric *networkSpeed = new pm::HostNetworkSpeed(hal, objptr, strName + "/LinkSpeed",
Utf8Str(mShortName), Utf8Str(mInterfaceName),
m.speedMbits, networkLinkSpeed);
aCollector->registerBaseMetric(networkSpeed);
pm::BaseMetric *networkLoad = new pm::HostNetworkLoadRaw(hal, objptr, strName + "/Load",
Utf8Str(mShortName), Utf8Str(mInterfaceName),
m.speedMbits, networkLoadRx, networkLoadTx);
aCollector->registerBaseMetric(networkLoad);
aCollector->registerMetric(new pm::Metric(networkSpeed, networkLinkSpeed, 0));
aCollector->registerMetric(new pm::Metric(networkSpeed, networkLinkSpeed,
new pm::AggregateAvg()));
aCollector->registerMetric(new pm::Metric(networkSpeed, networkLinkSpeed,
new pm::AggregateMin()));
aCollector->registerMetric(new pm::Metric(networkSpeed, networkLinkSpeed,
new pm::AggregateMax()));
aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx, 0));
aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
new pm::AggregateAvg()));
aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
new pm::AggregateMin()));
aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
new pm::AggregateMax()));
aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx, 0));
aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
new pm::AggregateAvg()));
aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
new pm::AggregateMin()));
aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
new pm::AggregateMax()));
}
/**
* Uninitializes the instance and sets the ready flag to FALSE.
* Called either from FinalRelease() or by the parent when it gets destroyed.
*/
void USBDeviceFilter::uninit()
{
LogFlowThisFunc(("\n"));
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan(this);
if (autoUninitSpan.uninitDone())
return;
mInList = false;
bd.free();
unconst(mPeer) = NULL;
unconst(mParent) = NULL;
}
/**
* Uninitializes the instance and sets the ready flag to FALSE.
* Called either from FinalRelease() or by the parent when it gets destroyed.
*/
void MachineToken::uninit(bool fAbandon)
{
LogFlowThisFunc(("\n"));
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan(this);
if (autoUninitSpan.uninitDone())
return;
/* Destroy the SessionMachine object, check is paranoia */
if (!m.pSessionMachine.isNull())
{
m.pSessionMachine->uninit(fAbandon ? SessionMachine::Uninit::Normal : SessionMachine::Uninit::Abnormal);
m.pSessionMachine.setNull();
}
}
int GuestFile::i_seekAt(int64_t iOffset, GUEST_FILE_SEEKTYPE eSeekType,
uint32_t uTimeoutMS, uint64_t *puOffset)
{
LogFlowThisFunc(("iOffset=%RI64, uTimeoutMS=%RU32\n",
iOffset, uTimeoutMS));
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
int vrc;
GuestWaitEvent *pEvent = NULL;
GuestEventTypes eventTypes;
try
{
eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
eventTypes.push_back(VBoxEventType_OnGuestFileOffsetChanged);
vrc = registerWaitEvent(eventTypes, &pEvent);
}
catch (std::bad_alloc)
{
vrc = VERR_NO_MEMORY;
}
if (RT_FAILURE(vrc))
return vrc;
/* Prepare HGCM call. */
VBOXHGCMSVCPARM paParms[4];
int i = 0;
paParms[i++].setUInt32(pEvent->ContextID());
paParms[i++].setUInt32(mData.mID /* File handle */);
paParms[i++].setUInt32(eSeekType /* Seek method */);
/** @todo uint64_t vs. int64_t! */
paParms[i++].setUInt64((uint64_t)iOffset /* Offset (in bytes) to start reading */);
alock.release(); /* Drop write lock before sending. */
vrc = sendCommand(HOST_FILE_SEEK, i, paParms);
if (RT_SUCCESS(vrc))
vrc = i_waitForOffsetChange(pEvent, uTimeoutMS, puOffset);
unregisterWaitEvent(pEvent);
LogFlowFuncLeaveRC(vrc);
return vrc;
}
int USBProxyBackendFreeBSD::releaseDevice(HostUSBDevice *aDevice)
{
AssertReturn(aDevice, VERR_GENERAL_FAILURE);
AssertReturn(!aDevice->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE);
AutoReadLock devLock(aDevice COMMA_LOCKVAL_SRC_POS);
LogFlowThisFunc(("aDevice=%s\n", aDevice->i_getName().c_str()));
/*
* We're not really holding it atm., just fake it.
*/
Assert(aDevice->i_getUnistate() == kHostUSBDeviceState_ReleasingToHost);
devLock.release();
interruptWait();
return VINF_SUCCESS;
}