Lines Matching defs:it
11 * you can redistribute it and/or modify it under the terms of the GNU
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
143 * (e.g. passing it as a thread function argument). If #rc() returns a
599 /* Confirm a successful initialization when it's the case */
787 // we don't perform uninit() as it's possible that some pending event refers to this source
1242 /* Save the connected client id. From now on it will be necessary to disconnect this one. */
1541 * console data from it has already been loaded.
1608 for (SharedFolderMap::const_iterator it = that->m_mapSharedFolders.begin();
1609 it != that->m_mapSharedFolders.end();
1610 ++it)
1612 SharedFolder *pSF = (*it).second;
1901 /* we return our local state (since it's always the same as on the server) */
1962 for (USBDeviceList::const_iterator it = mUSBDevices.begin(); it != mUSBDevices.end(); ++i, ++it)
1963 (*it).queryInterfaceTo(aUSBDevices[i].asOutParam());
1975 for (RemoteUSBDeviceList::const_iterator it = mRemoteUSBDevices.begin(); it != mRemoteUSBDevices.end(); ++i, ++it)
1976 (*it).queryInterfaceTo(aRemoteUSBDevices[i].asOutParam());
2008 for (SharedFolderMap::const_iterator it = m_mapSharedFolders.begin(); it != m_mapSharedFolders.end(); ++i, ++it)
2009 (it)->second.queryInterfaceTo(aSharedFolders[i].asOutParam());
2195 /* task is now owned by powerDownThread(), so release it */
2212 * This will reset the machine state to the state it had right
2245 /* release the lock before a VMR3* call (EMT might wait for it, @bugref{7648})! */
2340 /* If the CPU was unlocked we can detach it now. */
2352 /* release the lock before a VMR3* call (EMT might wait for it, @bugref{7648})! */
2364 /* Detach it from the VM */
2460 /* release the lock before a VMR3* call (EMT might wait for it, @bugref{7648})! */
2477 /** @todo warning if the guest doesn't support it */
2508 tr("Cannot resume the machine as it is not paused (machine state: %s)"),
2823 /* Find it. */
2825 USBDeviceList::iterator it = mUSBDevices.begin();
2826 while (it != mUSBDevices.end())
2828 if ((*it)->i_id() == aId)
2830 pUSBDevice = *it;
2833 ++it;
2841 /* Remove the device from the collection, it is re-added below for failures */
2842 mUSBDevices.erase(it);
2861 /* Request the device release. Even if it fails, the device will
2966 tr("Cannot create a transient shared folder on the machine while it is changing the state (machine state: %s)"),
2994 SharedFolderDataMap::const_iterator it;
2995 if (i_findOtherSharedFolder(aName, it))
3038 tr("Cannot remove a transient shared folder from the machine while it is changing the state (machine state: %s)"),
3060 SharedFolderDataMap::const_iterator it;
3061 if (i_findOtherSharedFolder(strName, it))
3063 rc = i_createSharedFolder(strName, it->second);
3175 ErrorInfoKeeper eik; /* Keep current error info or it gets deestroyed in the IPC methods below. */
3323 * to leave it in order to avoid deadlocks.
3399 * @param fForce Force medium chance, if it is locked or not.
3463 * Suspend the VM first. The VM must not be running since it might have
3481 /* release the lock before waiting for a result (EMT might wait for it, @bugref{7648})! */
3529 * @note The VM must not be running since it might have pending I/O to the drive which is being changed.
3644 * Suspend the VM first. The VM must not be running since it might have
3662 /* release the lock before waiting for a result (EMT might wait for it, @bugref{7648})! */
3704 * @note The VM must not be running since it might have pending I/O to the drive which is being changed.
3815 * Suspend the VM first. The VM must not be running since it might have
3833 /* release the lock before waiting for a result (EMT might wait for it, @bugref{7648})! */
3874 * @note The VM must not be running since it might have pending I/O to the drive which is being changed.
3951 USBStorageDeviceList::iterator it;
3952 for (it = pThis->mUSBStorageDevices.begin(); it != pThis->mUSBStorageDevices.end(); it++)
3954 if (it->iPort == lPort)
3958 AssertReturn(it != pThis->mUSBStorageDevices.end(), VERR_INTERNAL_ERROR);
3959 rc = PDMR3UsbDetachDevice(pUVM, &it->mUuid);
3961 pThis->mUSBStorageDevices.erase(it);
4422 * Useful when changing the key store or dropping it.
4676 ErrorInfoKeeper eik; /* Keep current error info or it gets deestroyed in the IPC methods below. */
5419 /* Get the VM pointer (we don't need error info, since it's a callback). */
5424 * (e.g. it may be Saving or Stopping or just PoweredOff) --
5489 USBDeviceList::iterator it = mUSBDevices.begin();
5490 while (it != mUSBDevices.end())
5492 LogFlowThisFunc(("it={%RTuuid}\n", (*it)->i_id().raw()));
5493 if ((*it)->i_id() == Uuid)
5495 pUSBDevice = *it;
5498 ++it;
5507 * (e.g. it may be Saving or Stopping or just PoweredOff). Use
5508 * AutoVMCaller to detect it -- AutoVMCaller::rc() will return a
5531 /* Remove the device from the collection, it is re-added below for failures */
5532 mUSBDevices.erase(it);
6014 /* Pause the VM, as it might have pending IO on this drive */
6057 /* Pause the VM, as it might have pending IO on this drive */
6166 * in module VBoxC (and ConsoleImpl.cpp is part of it and thus can call it).
6227 /* release the lock before a VMR3* call (EMT might wait for it, @bugref{7648})! */
6273 /* release the lock before a VMR3* call (EMT might wait for it, @bugref{7648})! */
6376 /* Get the VM handle early, we need it in several places. */
6384 /* release the lock before a VMR3* call (EMT might wait for it, @bugref{7648})! */
6427 * The machine has been successfully saved, so power it down
6429 * Note: we release the VM caller, otherwise it will deadlock.
6749 * Guarantees that VMR3Destroy() will not be called on it at least until
6761 * returned instead of asserting. Having it false is intended as a sanity check
6926 /* If the old file doesn't exist, delete the new file (if it
7010 #if 0 /** @todo we should save it afterwards, but that isn't necessarily a good idea. Find a better place for this (VBoxSVC). */
7070 for (SharedFolderDataMap::const_iterator it = m_mapGlobalSharedFolders.begin();
7071 it != m_mapGlobalSharedFolders.end();
7072 ++it)
7074 const SharedFolderData &d = it->second;
7075 sharedFolders[it->first] = d;
7079 for (SharedFolderDataMap::const_iterator it = m_mapMachineSharedFolders.begin();
7080 it != m_mapMachineSharedFolders.end();
7081 ++it)
7083 const SharedFolderData &d = it->second;
7084 sharedFolders[it->first] = d;
7088 for (SharedFolderMap::const_iterator it = m_mapSharedFolders.begin();
7089 it != m_mapSharedFolders.end();
7090 ++it)
7092 SharedFolder *pSF = it->second;
7095 sharedFolders[it->first] = SharedFolderData(pSF->i_getHostPath(),
7118 * state of the machine while it was previously running, but without
7239 for (VMPowerUpTask::ProgressList::const_iterator it = progresses.begin(); it != progresses.end(); ++it)
7285 combine/proxy it to any openRemoteSession caller. */
7375 /* task is now owned by powerUpThread(), so release it */
7379 * since we've already started the thread and it is now responsible for
7400 * progress notification above, as saving the error info deletes it
7429 * Calling it in situations other than the above will cause unexpected behavior.
7431 * Note that this method should be the only one that destroys mpUVM and sets it
7440 * release(). Otherwise it will deadlock.
7498 * vmstateChangeCallback() needs it to set the state to Saved on
7513 * DONE with necessary state changes, perform the power down actions (it's
7548 * that need it) may be called after this point
7604 /* Leave the lock since EMT might wait for it and will call us back as addVMCaller() */
7635 * it will result into calling destructors of drivers associated with
7738 // Event thread, like it is done in VirtualBox. This will make it
7741 // ability to synchronously react to state changes (is it really
7791 SharedFolderMap::const_iterator it = m_mapSharedFolders.find(strName);
7792 if (it != m_mapSharedFolders.end())
7794 aSharedFolder = it->second;
7821 /* Check if we're online and keep it that way. */
7877 SharedFolderDataMap::iterator it = oldFolders.find(strName);
7878 if ( it == oldFolders.end()
7879 || it->second.m_strHostPath != strHostPath)
7889 if ( it != oldFolders.end()
7904 if (it != oldFolders.end())
7905 oldFolders.erase(it);
7912 for (SharedFolderDataMap::const_iterator it = oldFolders.begin();
7913 it != oldFolders.end(); ++it)
7915 if (m_mapSharedFolders.find(it->first) != m_mapSharedFolders.end())
7920 rc = removeSharedFolder(it->first);
7925 m_mapGlobalSharedFolders.find(it->first);
8029 // now that we know the path is good, give it to HGCM
8192 /* Do we still think that it is running? It may happen if this is a
8204 LogFlowFunc(("VM has powered itself off but Console still thinks it is running. Notifying.\n"));
8251 /* task is now owned by powerDownThread(), so release it */
8260 * 1) At the end of VMR3Destroy() if it was not called from EMT.
8455 * raised, so it is not worth adding a new externally
8634 /* Create a OUSBDevice and add it to the device list */
8843 /* If we are using a static TAP device then try to open it. */
8859 * Make it pollable.
8866 * the host interface name to the server if/when it becomes really
8916 /* If we are using a static TAP device then try to open it. */
8997 /* If the name is empty, this is a dynamic TAP device, so close it now,
9007 /* If we are using a static TAP device, we close it now, after having called the
9237 for (RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
9238 it != mRemoteUSBDevices.end();
9239 ++it)
9241 (*it)->dirty(true);
9269 for (RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
9270 it != mRemoteUSBDevices.end();
9271 ++it)
9273 if ((*it)->devId() == e->id
9274 && (*it)->clientId() == u32ClientId)
9277 (*it)->dirty(false);
9340 RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
9341 while (it != mRemoteUSBDevices.end())
9343 if ((*it)->dirty())
9345 pUSBDevice = *it;
9349 ++it;
9379 /* And remove it from the list. */
9380 mRemoteUSBDevices.erase(it);
9423 /* Set up a build identifier so that it can be seen from core dumps what
9434 * releases it only after RTThreadCreate()) that we can start the job */
9454 it = task->hardDiskProgresses.begin();
9455 it != task->hardDiskProgresses.end(); ++it)
9457 HRESULT rc2 = (*it)->WaitForCompletion(-1);
9590 for (SharedFolderDataMap::const_iterator it = task->mSharedFolders.begin();
9591 it != task->mSharedFolders.end();
9592 ++it)
9594 const SharedFolderData &d = it->second;
9595 rc = pConsole->i_createSharedFolder(it->first, d);
9603 it->first.c_str(), eik.getText().raw());
9768 * If VMR3Create() failed it has released the VM memory.
9794 * Progress::notifyComplete() will pick it up later. */
9827 /* release the lock, don't need it any more */
9986 * it can pop up a progress object and stuff. The progress object created
9988 * anyone noticing it.
10167 * the unit and requery it.
10206 Console::MediumAttachmentMap::const_iterator it = pThis->pmapMediumAttachments->find(devicePath);
10207 if (it != end)
10208 pMediumAtt = it->second;