int GuestDirectory::parseData(GuestProcessStreamBlock &streamBlock) { LogFlowThisFunc(("cbStream=%RU32\n", mData.mStream.GetSize())); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); int rc; do { /* Try parsing the data to see if the current block is complete. */ rc = mData.mStream.ParseBlock(streamBlock); if (streamBlock.GetCount()) break; } while (RT_SUCCESS(rc)); LogFlowFuncLeaveRC(rc); return rc; }
/** Just a wrapper so we can automatically do the handover before setting * the result locally. */ HRESULT ProgressProxy::notifyComplete(HRESULT aResultCode, const GUID &aIID, const char *pcszComponent, const char *aText, ...) { AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); clearOtherProgressObjectInternal(true /* fEarly */); HRESULT hrc = S_OK; if (!mCompleted) { va_list va; va_start(va, aText); hrc = Progress::i_notifyCompleteV(aResultCode, aIID, pcszComponent, aText, va); va_end(va); } return hrc; }
HRESULT MachineDebugger::dumpGuestCore(const com::Utf8Str &aFilename, const com::Utf8Str &aCompression) { if (aCompression.length()) return setError(E_INVALIDARG, tr("The compression parameter must be empty")); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); Console::SafeVMPtr ptrVM(mParent); HRESULT hrc = ptrVM.rc(); if (SUCCEEDED(hrc)) { int vrc = DBGFR3CoreWrite(ptrVM.rawUVM(), aFilename.c_str(), false /*fReplaceFile*/); if (RT_SUCCESS(vrc)) hrc = S_OK; else hrc = setError(E_FAIL, tr("DBGFR3CoreWrite failed with %Rrc"), vrc); } return hrc; }
STDMETHODIMP Session::EnableVMMStatistics(BOOL aEnable) { 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); #ifndef VBOX_COM_INPROC_API_CLIENT AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE); mConsole->enableVMMStatistics(aEnable); return S_OK; #else AssertFailed(); return E_NOTIMPL; #endif }
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); #ifndef VBOX_COM_INPROC_API_CLIENT AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE); return mConsole->onUSBDeviceDetach(aId, aError); #else return S_OK; #endif }
HRESULT MachineDebugger::i_logStringProps(PRTLOGGER pLogger, PFNLOGGETSTR pfnLogGetStr, const char *pszLogGetStr, Utf8Str *pstrSettings) { /* Make sure the VM is powered up. */ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); Console::SafeVMPtr ptrVM(mParent); HRESULT hrc = ptrVM.rc(); if (FAILED(hrc)) return hrc; /* Make sure we've got a logger. */ if (!pLogger) { *pstrSettings = ""; return S_OK; } /* Do the job. */ size_t cbBuf = _1K; for (;;) { char *pszBuf = (char *)RTMemTmpAlloc(cbBuf); AssertReturn(pszBuf, E_OUTOFMEMORY); int vrc = pstrSettings->reserveNoThrow(cbBuf); if (RT_SUCCESS(vrc)) { vrc = pfnLogGetStr(pLogger, pstrSettings->mutableRaw(), cbBuf); if (RT_SUCCESS(vrc)) { pstrSettings->jolt(); return S_OK; } *pstrSettings = ""; AssertReturn(vrc == VERR_BUFFER_OVERFLOW, setError(VBOX_E_IPRT_ERROR, tr("%s returned %Rrc"), pszLogGetStr, vrc)); } else return E_OUTOFMEMORY; /* try again with a bigger buffer. */ cbBuf *= 2; AssertReturn(cbBuf <= _256K, setError(E_FAIL, tr("%s returns too much data"), pszLogGetStr)); } }
STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Active) (BOOL aActive) { AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); if (mData->mActive != aActive) { mData->mActive = aActive; /* leave the lock before informing callbacks */ alock.release(); return mParent->onUSBDeviceFilterChange (this, TRUE /* aActiveChanged */); } return S_OK; }
int GuestFile::i_setFileStatus(FileStatus_T fileStatus, int fileRc) { LogFlowThisFuncEnter(); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); LogFlowThisFunc(("oldStatus=%RU32, newStatus=%RU32, fileRc=%Rrc\n", mData.mStatus, fileStatus, fileRc)); #ifdef VBOX_STRICT if (fileStatus == FileStatus_Error) { AssertMsg(RT_FAILURE(fileRc), ("Guest rc must be an error (%Rrc)\n", fileRc)); } else AssertMsg(RT_SUCCESS(fileRc), ("Guest rc must not be an error (%Rrc)\n", fileRc)); #endif if (mData.mStatus != fileStatus) { mData.mStatus = fileStatus; mData.mLastError = fileRc; ComObjPtr<VirtualBoxErrorInfo> errorInfo; HRESULT hr = errorInfo.createObject(); ComAssertComRC(hr); if (RT_FAILURE(fileRc)) { hr = errorInfo->initEx(VBOX_E_IPRT_ERROR, fileRc, COM_IIDOF(IGuestFile), getComponentName(), i_guestErrorToString(fileRc)); ComAssertComRC(hr); } alock.release(); /* Release lock before firing off event. */ fireGuestFileStateChangedEvent(mEventSource, mSession, this, fileStatus, errorInfo); } return VINF_SUCCESS; }
void CameraClient::dataCallback(int32_t msgType, const sp<IMemory>& dataPtr, camera_frame_metadata_t *metadata, void* user) { LOG2("dataCallback(%d)", msgType); Mutex* lock = getClientLockFromCookie(user); if (lock == NULL) return; Mutex::Autolock alock(*lock); CameraClient* client = static_cast<CameraClient*>(getClientFromCookie(user)); if (client == NULL) return; if (!client->lockIfMessageWanted(msgType)) return; if (dataPtr == 0 && metadata == NULL) { ALOGE("Null data returned in data callback"); client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0); return; } switch (msgType & ~CAMERA_MSG_PREVIEW_METADATA) { case CAMERA_MSG_PREVIEW_FRAME: client->handlePreviewData(msgType, dataPtr, metadata); break; case CAMERA_MSG_POSTVIEW_FRAME: client->handlePostview(dataPtr); break; case CAMERA_MSG_RAW_IMAGE: client->handleRawPicture(dataPtr); break; case CAMERA_MSG_COMPRESSED_IMAGE: client->handleCompressedPicture(dataPtr); break; #if defined(OMAP_ICS_CAMERA) || defined(OMAP_ENHANCEMENT_BURST_CAPTURE) case CAMERA_MSG_COMPRESSED_BURST_IMAGE: client->handleCompressedBurstPicture(dataPtr); break; #endif default: client->handleGenericData(msgType, dataPtr, metadata); break; } }
STDMETHODIMP AudioAdapter::COMSETTER(AudioController)(AudioControllerType_T aAudioController) { 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(); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); HRESULT rc = S_OK; if (mData->mAudioController != aAudioController) { /* * which audio hardware type are we supposed to use? */ switch (aAudioController) { case AudioControllerType_AC97: case AudioControllerType_SB16: case AudioControllerType_HDA: { mData.backup(); mData->mAudioController = aAudioController; alock.release(); AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS); // mParent is const, needs no locking mParent->setModified(Machine::IsModified_AudioAdapter); break; } default: AssertMsgFailed (("Wrong audio controller type %d\n", aAudioController)); rc = E_FAIL; } } return rc; }
HRESULT StorageController::setName(const com::Utf8Str &aName) { /* the machine needs to be mutable */ AutoMutableStateDependency adep(m->pParent); if (FAILED(adep.rc())) return adep.rc(); AutoMultiWriteLock2 alock(m->pParent, this COMMA_LOCKVAL_SRC_POS); if (m->bd->strName != aName) { ComObjPtr<StorageController> ctrl; HRESULT rc = m->pParent->i_getStorageControllerByName(aName, ctrl, false /* aSetError */); if (SUCCEEDED(rc)) return setError(VBOX_E_OBJECT_IN_USE, tr("Storage controller named '%s' already exists"), aName.c_str()); Machine::MediumAttachmentList atts; rc = m->pParent->i_getMediumAttachmentsOfController(m->bd->strName, atts); for (Machine::MediumAttachmentList::const_iterator it = atts.begin(); it != atts.end(); ++it) { IMediumAttachment *iA = *it; MediumAttachment *pAttach = static_cast<MediumAttachment *>(iA); AutoWriteLock attlock(pAttach COMMA_LOCKVAL_SRC_POS); pAttach->i_updateName(aName); } m->bd.backup(); m->bd->strName = aName; m->pParent->i_setModified(Machine::IsModified_Storage); alock.release(); m->pParent->i_onStorageControllerChange(m->pParent->i_getId(), aName); } return S_OK; }
void CameraClient::notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void* user) { LOG2("notifyCallback(%d)", msgType); // Ignore CAF_RESTART callbacks from Samsung's camera driver if (msgType == CAMERA_MSG_FOCUS && ext1 == 4) { LOG2("Ignore CAF_RESTART callback"); return; } #ifdef MTK_HARDWARE if (msgType == 0x40000000) { //MTK_CAMERA_MSG_EXT_NOTIFY if (ext1 == 0x11) { //MTK_CAMERA_MSG_EXT_NOTIFY_SHUTTER msgType = CAMERA_MSG_SHUTTER; } if (ext1 == 0x10) { //MTK_CAMERA_MSG_EXT_CAPTURE_DONE return; } LOG2("MtknotifyCallback(0x%x, 0x%x)", ext1, ext2); } #endif Mutex* lock = getClientLockFromCookie(user); if (lock == NULL) return; Mutex::Autolock alock(*lock); CameraClient* client = static_cast<CameraClient*>(getClientFromCookie(user)); if (client == NULL) return; if (!client->lockIfMessageWanted(msgType)) return; switch (msgType) { case CAMERA_MSG_SHUTTER: // ext1 is the dimension of the yuv picture. client->handleShutter(); break; default: client->handleGenericNotify(msgType, ext1, ext2); break; } }
HRESULT USBDeviceFilters::getDeviceFilters(std::vector<ComPtr<IUSBDeviceFilter> > &aDeviceFilters) { #ifdef VBOX_WITH_USB AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); SafeIfaceArray<IUSBDeviceFilter> collection(*m->llDeviceFilters.data()); aDeviceFilters.resize(collection.size()); if (collection.size()) for (size_t i = 0; i < collection.size(); ++i) aDeviceFilters[i] = collection[i]; return S_OK; #else NOREF(aDeviceFilters); # ifndef RT_OS_WINDOWS NOREF(aDeviceFilters); # endif ReturnComNotImplemented(); #endif }
STDMETHODIMP SystemProperties::COMSETTER(DefaultFrontend)(IN_BSTR aDefaultFrontend) { AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); if (m->strDefaultFrontend == Utf8Str(aDefaultFrontend)) return S_OK; HRESULT rc = setDefaultFrontend(aDefaultFrontend); alock.release(); if (SUCCEEDED(rc)) { // VirtualBox::saveSettings() needs vbox write lock AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS); rc = mParent->saveSettings(); } return rc; }
STDMETHODIMP NATEngine::GetNetworkSettings(ULONG *aMtu, ULONG *aSockSnd, ULONG *aSockRcv, ULONG *aTcpWndSnd, ULONG *aTcpWndRcv) { AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); if (aMtu) *aMtu = mData->mMtu; if (aSockSnd) *aSockSnd = mData->mSockSnd; if (aSockRcv) *aSockRcv = mData->mSockRcv; if (aTcpWndSnd) *aTcpWndSnd = mData->mTcpSnd; if (aTcpWndRcv) *aTcpWndRcv = mData->mTcpRcv; return S_OK; }
HRESULT DHCPServer::addGlobalOption(DhcpOpt_T aOption, const com::Utf8Str &aValue) { AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); int rc = addOption(m->GlobalDhcpOptions, aOption, aValue); if (!RT_SUCCESS(rc)) return E_INVALIDARG; /* Indirect way to understand that we're on NAT network */ if (aOption == DhcpOpt_Router) { m->dhcp.setOption(NetworkServiceRunner::kNsrKeyNeedMain, "on"); m->router = true; } alock.release(); AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS); return mVirtualBox->i_saveSettings(); }
void HostUSBDeviceFilter::saveSettings(settings::USBDeviceFilter &data) { AutoCaller autoCaller(this); AssertComRCReturnVoid(autoCaller.rc()); AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); data.strName = mData->mName; data.fActive = !!mData->mActive; usbFilterFieldToString(&mData->mUSBFilter, USBFILTERIDX_VENDOR_ID, data.strVendorId); usbFilterFieldToString(&mData->mUSBFilter, USBFILTERIDX_PRODUCT_ID, data.strProductId); usbFilterFieldToString(&mData->mUSBFilter, USBFILTERIDX_DEVICE, data.strRevision); usbFilterFieldToString(&mData->mUSBFilter, USBFILTERIDX_MANUFACTURER_STR, data.strManufacturer); usbFilterFieldToString(&mData->mUSBFilter, USBFILTERIDX_PRODUCT_STR, data.strProduct); usbFilterFieldToString(&mData->mUSBFilter, USBFILTERIDX_SERIAL_NUMBER_STR, data.strSerialNumber); usbFilterFieldToString(&mData->mUSBFilter, USBFILTERIDX_PORT, data.strPort); COMGETTER(Action)(&data.action); }
/** * this is mapping (vm, slot) */ HRESULT DHCPServer::getVmSlotOptions(const com::Utf8Str &aVmName, LONG aSlot, std::vector<com::Utf8Str> &aValues) { AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); settings::DhcpOptionMap &map = i_findOptMapByVmNameSlot(aVmName, aSlot); aValues.resize(map.size()); size_t i = 0; settings::DhcpOptionMap::const_iterator it; for (it = map.begin(); it != map.end(); ++it, ++i) { uint32_t OptCode = (*it).first; const settings::DhcpOptValue &OptValue = (*it).second; encodeOption(aValues[i], OptCode, OptValue); } return S_OK; }
int USBProxyBackendLinux::interruptWait(void) { AssertReturn(!isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE); AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); #ifdef VBOX_USB_WITH_SYSFS LogFlowFunc(("mUsingUsbfsDevices=%d\n", mUsingUsbfsDevices)); if (!mUsingUsbfsDevices) { mpWaiter->Interrupt(); LogFlowFunc(("Returning VINF_SUCCESS\n")); return VINF_SUCCESS; } #endif /* VBOX_USB_WITH_SYSFS */ int rc = RTPipeWriteBlocking(mhWakeupPipeW, WAKE_UP_STRING, WAKE_UP_STRING_LEN, NULL); if (RT_SUCCESS(rc)) RTPipeFlush(mhWakeupPipeW); LogFlowFunc(("returning %Rrc\n", rc)); return rc; }
STDMETHODIMP VBoxEvent::WaitProcessed(LONG aTimeout, BOOL *aResult) { CheckComArgNotNull(aResult); AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); { AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); if (m->mProcessed) { *aResult = TRUE; return S_OK; } if (aTimeout == 0) { *aResult = m->mProcessed; return S_OK; } } /* @todo: maybe while loop for spurious wakeups? */ int vrc = ::RTSemEventWait(m->mWaitEvent, aTimeout); AssertMsg(RT_SUCCESS(vrc) || vrc == VERR_TIMEOUT || vrc == VERR_INTERRUPTED, ("RTSemEventWait returned %Rrc\n", vrc)); if (RT_SUCCESS(vrc)) { AssertMsg(m->mProcessed, ("mProcessed must be set here\n")); *aResult = m->mProcessed; } else { *aResult = FALSE; } return S_OK; }
/** * Generic USB filter field setter, expects UTF-8 input. * * @param aIdx The field index. * @param aStr The new value. * * @return COM status. */ HRESULT USBDeviceFilter::usbFilterFieldSetter(USBFILTERIDX aIdx, const Utf8Str &strNew) { AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); /* the machine needs to be mutable */ AutoMutableStateDependency adep(mParent->getMachine()); if (FAILED(adep.rc())) return adep.rc(); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); Utf8Str strOld; usbFilterFieldToString(&mData->mUSBFilter, aIdx, strOld); if (strOld != strNew) { m_fModified = true; ComObjPtr<Machine> pMachine = mParent->getMachine(); mData.backup(); Utf8Str errStr; HRESULT rc = usbFilterFieldFromString(&mData->mUSBFilter, aIdx, strNew, errStr); if (FAILED(rc)) { mData.rollback(); return setError(rc, "%s", errStr.c_str()); } // leave the lock before informing callbacks alock.release(); AutoWriteLock mlock(pMachine COMMA_LOCKVAL_SRC_POS); pMachine->setModified(Machine::IsModified_USB); mlock.release(); return mParent->onDeviceFilterChange(this); } return S_OK; }
/** * Notification from VM process about USB device detaching progress. * * This is in an interface for SessionMachine::DetachUSBDevice(), which is * an internal worker used by Console::DetachUSBDevice() from the VM process. * * @param aMachine The machine which is sending the notification. * @param aId The UUID of the USB device is concerns. * @param aDone \a false for the pre-action notification (necessary * for advancing the device state to avoid confusing * the guest). * \a true for the post-action notification. The device * will be subjected to all filters except those of * of \a Machine. * * @returns COM status code. * * @remarks When \a aDone is \a true this method may end up doing IPC to other * VMs when running filters. In these cases it will temporarily * abandon its locks. */ HRESULT USBProxyService::detachDeviceFromVM(SessionMachine *aMachine, IN_GUID aId, bool aDone) { LogFlowThisFunc(("aMachine=%p{%s} aId={%RTuuid} aDone=%RTbool\n", aMachine, aMachine->getName().c_str(), Guid(aId).raw(), aDone)); // get a list of all running machines while we're outside the lock // (getOpenedMachines requests locks which are incompatible with the lock of the machines list) SessionMachinesList llOpenedMachines; mHost->parent()->getOpenedMachines(llOpenedMachines); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); ComObjPtr<HostUSBDevice> pHostDevice = findDeviceById(aId); ComAssertRet(!pHostDevice.isNull(), E_FAIL); AutoWriteLock devLock(pHostDevice COMMA_LOCKVAL_SRC_POS); /* * Work the state machine. */ LogFlowThisFunc(("id={%RTuuid} state=%s aDone=%RTbool name={%s}\n", pHostDevice->getId().raw(), pHostDevice->getStateName(), aDone, pHostDevice->getName().c_str())); bool fRunFilters = false; HRESULT hrc = pHostDevice->onDetachFromVM(aMachine, aDone, &fRunFilters); /* * Run filters if necessary. */ if ( SUCCEEDED(hrc) && fRunFilters) { Assert(aDone && pHostDevice->getUnistate() == kHostUSBDeviceState_HeldByProxy && pHostDevice->getMachine().isNull()); devLock.release(); alock.release(); HRESULT hrc2 = runAllFiltersOnDevice(pHostDevice, llOpenedMachines, aMachine); ComAssertComRC(hrc2); } return hrc; }
HRESULT SystemProperties::loadSettings(const settings::SystemProperties &data) { AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); HRESULT rc = S_OK; rc = setDefaultMachineFolder(data.strDefaultMachineFolder); if (FAILED(rc)) return rc; rc = setDefaultHardDiskFormat(data.strDefaultHardDiskFormat); if (FAILED(rc)) return rc; rc = setVRDEAuthLibrary(data.strVRDEAuthLibrary); if (FAILED(rc)) return rc; rc = setWebServiceAuthLibrary(data.strWebServiceAuthLibrary); if (FAILED(rc)) return rc; rc = setDefaultVRDEExtPack(data.strDefaultVRDEExtPack); if (FAILED(rc)) return rc; m->ulLogHistoryCount = data.ulLogHistoryCount; rc = setAutostartDatabasePath(data.strAutostartDatabasePath); if (FAILED(rc)) return rc; { /* must ignore errors signalled here, because the guest additions * file may not exist, and in this case keep the empty string */ ErrorInfoKeeper eik; (void)setDefaultAdditionsISO(data.strDefaultAdditionsISO); } rc = setDefaultFrontend(data.strDefaultFrontend); if (FAILED(rc)) return rc; return S_OK; }
STDMETHODIMP NetworkAdapter::COMSETTER(InternalNetwork)(IN_BSTR aInternalNetwork) { 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(); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); if (mData->mInternalNetwork != aInternalNetwork) { /* if an empty/null string is to be set, internal networking must be * turned off */ if ( (aInternalNetwork == NULL || *aInternalNetwork == '\0') && mData->mAttachmentType == NetworkAttachmentType_Internal) { return setError(E_FAIL, tr("Empty or null internal network name is not valid")); } mData.backup(); mData->mInternalNetwork = aInternalNetwork; m_fModified = true; // leave the lock before informing callbacks alock.release(); AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS); // mParent is const, no need to lock mParent->setModified(Machine::IsModified_NetworkAdapters); mlock.release(); /* When changing the internal network, adapt the CFGM logic to make this * change immediately effect and to notify the guest that the network * might have changed, therefore changeAdapter=TRUE. */ mParent->onNetworkAdapterChange(this, TRUE); } return S_OK; }
HRESULT Progress::cancel() { AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); if (!mCancelable) return setError(VBOX_E_INVALID_OBJECT_STATE, tr("Operation cannot be canceled")); if (!mCanceled) { LogThisFunc(("Canceling\n")); mCanceled = TRUE; if (m_pfnCancelCallback) m_pfnCancelCallback(m_pvCancelUserArg); } else LogThisFunc(("Already canceled\n")); return S_OK; }
STDMETHODIMP ProgressProxy::Cancel() { LogFlowThisFunc(("\n")); AutoCaller autoCaller(this); HRESULT hrc = autoCaller.rc(); if (SUCCEEDED(hrc)) { AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); if (mptrOtherProgress.isNull() || !mCancelable) hrc = Progress::Cancel(); else { hrc = mptrOtherProgress->Cancel(); if (SUCCEEDED(hrc)) clearOtherProgressObjectInternal(false /*fEarly*/); } } LogFlowThisFunc(("returns %Rhrc\n", hrc)); return hrc; }
STDMETHODIMP ProgressProxy::COMGETTER(Operation)(ULONG *aOperation) { CheckComArgOutPointerValid(aOperation); AutoCaller autoCaller(this); HRESULT hrc = autoCaller.rc(); if (SUCCEEDED(hrc)) { AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); if (mptrOtherProgress.isNull()) hrc = Progress::COMGETTER(Operation)(aOperation); else { ULONG uCurOtherOperation; hrc = mptrOtherProgress->COMGETTER(Operation)(&uCurOtherOperation); if (SUCCEEDED(hrc)) *aOperation = uCurOtherOperation + muOtherProgressStartOperation; } } return hrc; }
/** * Returns S_OK if the given port and device numbers are within the range supported * by this controller. If not, it sets an error and returns E_INVALIDARG. * @param ulPort * @param ulDevice * @return */ HRESULT StorageController::i_checkPortAndDeviceValid(LONG aControllerPort, LONG aDevice) { AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); ULONG portCount = m->bd->mPortCount; ULONG devicesPerPort; HRESULT rc = m->pSystemProperties->GetMaxDevicesPerPortForStorageBus(m->bd->mStorageBus, &devicesPerPort); if (FAILED(rc)) return rc; if ( aControllerPort < 0 || aControllerPort >= (LONG)portCount || aDevice < 0 || aDevice >= (LONG)devicesPerPort ) return setError(E_INVALIDARG, tr("The port and/or device parameter are out of range: port=%d (must be in range [0, %d]), device=%d (must be in range [0, %d])"), (int)aControllerPort, (int)portCount-1, (int)aDevice, (int)devicesPerPort-1); return S_OK; }
/** * Sets the supported features (and whether they are active or not). * * @param fCaps Guest capability bit mask (VMMDEV_GUEST_SUPPORTS_XXX). */ void Guest::setSupportedFeatures(uint32_t aCaps) { AutoCaller autoCaller(this); AssertComRCReturnVoid(autoCaller.rc()); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); /** @todo A nit: The timestamp is wrong on saved state restore. Would be better * to move the graphics and seamless capability -> facility translation to * VMMDev so this could be saved. */ RTTIMESPEC TimeSpecTS; RTTimeNow(&TimeSpecTS); facilityUpdate(VBoxGuestFacilityType_Seamless, aCaps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? VBoxGuestFacilityStatus_Active : VBoxGuestFacilityStatus_Inactive, 0 /*fFlags*/, &TimeSpecTS); /** @todo Add VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING */ facilityUpdate(VBoxGuestFacilityType_Graphics, aCaps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? VBoxGuestFacilityStatus_Active : VBoxGuestFacilityStatus_Inactive, 0 /*fFlags*/, &TimeSpecTS); }
STDMETHODIMP Guest::COMGETTER(OSTypeId)(BSTR *a_pbstrOSTypeId) { CheckComArgOutPointerValid(a_pbstrOSTypeId); AutoCaller autoCaller(this); HRESULT hrc = autoCaller.rc(); if (SUCCEEDED(hrc)) { AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); if (!mData.mInterfaceVersion.isEmpty()) mData.mOSTypeId.cloneTo(a_pbstrOSTypeId); else { /* Redirect the call to IMachine if no additions are installed. */ ComPtr<IMachine> ptrMachine(mParent->machine()); alock.release(); hrc = ptrMachine->COMGETTER(OSTypeId)(a_pbstrOSTypeId); } } return hrc; }