/** * 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; }