VirtualBox

source: vbox/trunk/src/VBox/Main/src-server/MachineImpl.cpp@ 52235

Last change on this file since 52235 was 52175, checked in by vboxsync, 11 years ago

MachineImpl.cpp: Create the log directory before launching the VM; Hexadecimal exit code in error messages to make it easier to see which NT status code we're looking at.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 498.6 KB
Line 
1/* $Id: MachineImpl.cpp 52175 2014-07-24 18:45:59Z vboxsync $ */
2/** @file
3 * Implementation of IMachine in VBoxSVC.
4 */
5
6/*
7 * Copyright (C) 2004-2014 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/* Make sure all the stdint.h macros are included - must come first! */
19#ifndef __STDC_LIMIT_MACROS
20# define __STDC_LIMIT_MACROS
21#endif
22#ifndef __STDC_CONSTANT_MACROS
23# define __STDC_CONSTANT_MACROS
24#endif
25
26#include "Logging.h"
27#include "VirtualBoxImpl.h"
28#include "MachineImpl.h"
29#include "ClientToken.h"
30#include "ProgressImpl.h"
31#include "ProgressProxyImpl.h"
32#include "MediumAttachmentImpl.h"
33#include "MediumImpl.h"
34#include "MediumLock.h"
35#include "USBControllerImpl.h"
36#include "USBDeviceFiltersImpl.h"
37#include "HostImpl.h"
38#include "SharedFolderImpl.h"
39#include "GuestOSTypeImpl.h"
40#include "VirtualBoxErrorInfoImpl.h"
41#include "GuestImpl.h"
42#include "StorageControllerImpl.h"
43#include "DisplayImpl.h"
44#include "DisplayUtils.h"
45#include "MachineImplCloneVM.h"
46#include "AutostartDb.h"
47#include "SystemPropertiesImpl.h"
48
49// generated header
50#include "VBoxEvents.h"
51
52#ifdef VBOX_WITH_USB
53# include "USBProxyService.h"
54#endif
55
56#include "AutoCaller.h"
57#include "HashedPw.h"
58#include "Performance.h"
59
60#include <iprt/asm.h>
61#include <iprt/path.h>
62#include <iprt/dir.h>
63#include <iprt/env.h>
64#include <iprt/lockvalidator.h>
65#include <iprt/process.h>
66#include <iprt/cpp/utils.h>
67#include <iprt/cpp/xml.h> /* xml::XmlFileWriter::s_psz*Suff. */
68#include <iprt/sha.h>
69#include <iprt/string.h>
70#include <iprt/base64.h>
71
72#include <VBox/com/array.h>
73#include <VBox/com/list.h>
74
75#include <VBox/err.h>
76#include <VBox/param.h>
77#include <VBox/settings.h>
78#include <VBox/vmm/ssm.h>
79
80#ifdef VBOX_WITH_GUEST_PROPS
81# include <VBox/HostServices/GuestPropertySvc.h>
82# include <VBox/com/array.h>
83#endif
84
85#include "VBox/com/MultiResult.h"
86
87#include <algorithm>
88
89#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
90# define HOSTSUFF_EXE ".exe"
91#else /* !RT_OS_WINDOWS */
92# define HOSTSUFF_EXE ""
93#endif /* !RT_OS_WINDOWS */
94
95// defines / prototypes
96/////////////////////////////////////////////////////////////////////////////
97
98/////////////////////////////////////////////////////////////////////////////
99// Machine::Data structure
100/////////////////////////////////////////////////////////////////////////////
101
102Machine::Data::Data()
103{
104 mRegistered = FALSE;
105 pMachineConfigFile = NULL;
106 /* Contains hints on what has changed when the user is using the VM (config
107 * changes, running the VM, ...). This is used to decide if a config needs
108 * to be written to disk. */
109 flModifications = 0;
110 /* VM modification usually also trigger setting the current state to
111 * "Modified". Although this is not always the case. An e.g. is the VM
112 * initialization phase or when snapshot related data is changed. The
113 * actually behavior is controlled by the following flag. */
114 m_fAllowStateModification = false;
115 mAccessible = FALSE;
116 /* mUuid is initialized in Machine::init() */
117
118 mMachineState = MachineState_PoweredOff;
119 RTTimeNow(&mLastStateChange);
120
121 mMachineStateDeps = 0;
122 mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
123 mMachineStateChangePending = 0;
124
125 mCurrentStateModified = TRUE;
126 mGuestPropertiesModified = FALSE;
127
128 mSession.mPID = NIL_RTPROCESS;
129 mSession.mState = SessionState_Unlocked;
130}
131
132Machine::Data::~Data()
133{
134 if (mMachineStateDepsSem != NIL_RTSEMEVENTMULTI)
135 {
136 RTSemEventMultiDestroy(mMachineStateDepsSem);
137 mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
138 }
139 if (pMachineConfigFile)
140 {
141 delete pMachineConfigFile;
142 pMachineConfigFile = NULL;
143 }
144}
145
146/////////////////////////////////////////////////////////////////////////////
147// Machine::HWData structure
148/////////////////////////////////////////////////////////////////////////////
149
150Machine::HWData::HWData()
151{
152 /* default values for a newly created machine */
153 mHWVersion = "2"; /** @todo get the default from the schema if that is possible. */
154 mMemorySize = 128;
155 mCPUCount = 1;
156 mCPUHotPlugEnabled = false;
157 mMemoryBalloonSize = 0;
158 mPageFusionEnabled = false;
159 mGraphicsControllerType = GraphicsControllerType_VBoxVGA;
160 mVRAMSize = 8;
161 mAccelerate3DEnabled = false;
162 mAccelerate2DVideoEnabled = false;
163 mMonitorCount = 1;
164 mVideoCaptureWidth = 1024;
165 mVideoCaptureHeight = 768;
166 mVideoCaptureRate = 512;
167 mVideoCaptureFPS = 25;
168 mVideoCaptureEnabled = false;
169 for (unsigned i = 0; i < RT_ELEMENTS(maVideoCaptureScreens); ++i)
170 maVideoCaptureScreens[i] = true;
171
172 mHWVirtExEnabled = true;
173 mHWVirtExNestedPagingEnabled = true;
174#if HC_ARCH_BITS == 64 && !defined(RT_OS_LINUX)
175 mHWVirtExLargePagesEnabled = true;
176#else
177 /* Not supported on 32 bits hosts. */
178 mHWVirtExLargePagesEnabled = false;
179#endif
180 mHWVirtExVPIDEnabled = true;
181 mHWVirtExUXEnabled = true;
182 mHWVirtExForceEnabled = false;
183#if HC_ARCH_BITS == 64 || defined(RT_OS_WINDOWS) || defined(RT_OS_DARWIN)
184 mPAEEnabled = true;
185#else
186 mPAEEnabled = false;
187#endif
188 mLongMode = HC_ARCH_BITS == 64 ? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
189 mSyntheticCpu = false;
190 mTripleFaultReset = false;
191 mHPETEnabled = false;
192
193 /* default boot order: floppy - DVD - HDD */
194 mBootOrder[0] = DeviceType_Floppy;
195 mBootOrder[1] = DeviceType_DVD;
196 mBootOrder[2] = DeviceType_HardDisk;
197 for (size_t i = 3; i < RT_ELEMENTS(mBootOrder); ++i)
198 mBootOrder[i] = DeviceType_Null;
199
200 mClipboardMode = ClipboardMode_Disabled;
201 mDnDMode = DnDMode_Disabled;
202 mGuestPropertyNotificationPatterns = "";
203
204 mFirmwareType = FirmwareType_BIOS;
205 mKeyboardHIDType = KeyboardHIDType_PS2Keyboard;
206 mPointingHIDType = PointingHIDType_PS2Mouse;
207 mChipsetType = ChipsetType_PIIX3;
208 mParavirtProvider = ParavirtProvider_Default;
209 mEmulatedUSBCardReaderEnabled = FALSE;
210
211 for (size_t i = 0; i < RT_ELEMENTS(mCPUAttached); ++i)
212 mCPUAttached[i] = false;
213
214 mIOCacheEnabled = true;
215 mIOCacheSize = 5; /* 5MB */
216
217 /* Maximum CPU execution cap by default. */
218 mCpuExecutionCap = 100;
219}
220
221Machine::HWData::~HWData()
222{
223}
224
225/////////////////////////////////////////////////////////////////////////////
226// Machine::HDData structure
227/////////////////////////////////////////////////////////////////////////////
228
229Machine::MediaData::MediaData()
230{
231}
232
233Machine::MediaData::~MediaData()
234{
235}
236
237/////////////////////////////////////////////////////////////////////////////
238// Machine class
239/////////////////////////////////////////////////////////////////////////////
240
241// constructor / destructor
242/////////////////////////////////////////////////////////////////////////////
243
244Machine::Machine() :
245#ifdef VBOX_WITH_RESOURCE_USAGE_API
246 mCollectorGuest(NULL),
247#endif
248 mPeer(NULL),
249 mParent(NULL),
250 mSerialPorts(),
251 mParallelPorts(),
252 uRegistryNeedsSaving(0)
253{}
254
255Machine::~Machine()
256{}
257
258HRESULT Machine::FinalConstruct()
259{
260 LogFlowThisFunc(("\n"));
261 return BaseFinalConstruct();
262}
263
264void Machine::FinalRelease()
265{
266 LogFlowThisFunc(("\n"));
267 uninit();
268 BaseFinalRelease();
269}
270
271/**
272 * Initializes a new machine instance; this init() variant creates a new, empty machine.
273 * This gets called from VirtualBox::CreateMachine().
274 *
275 * @param aParent Associated parent object
276 * @param strConfigFile Local file system path to the VM settings file (can
277 * be relative to the VirtualBox config directory).
278 * @param strName name for the machine
279 * @param llGroups list of groups for the machine
280 * @param aOsType OS Type of this machine or NULL.
281 * @param aId UUID for the new machine.
282 * @param fForceOverwrite Whether to overwrite an existing machine settings file.
283 *
284 * @return Success indicator. if not S_OK, the machine object is invalid
285 */
286HRESULT Machine::init(VirtualBox *aParent,
287 const Utf8Str &strConfigFile,
288 const Utf8Str &strName,
289 const StringsList &llGroups,
290 GuestOSType *aOsType,
291 const Guid &aId,
292 bool fForceOverwrite,
293 bool fDirectoryIncludesUUID)
294{
295 LogFlowThisFuncEnter();
296 LogFlowThisFunc(("(Init_New) aConfigFile='%s'\n", strConfigFile.c_str()));
297
298 /* Enclose the state transition NotReady->InInit->Ready */
299 AutoInitSpan autoInitSpan(this);
300 AssertReturn(autoInitSpan.isOk(), E_FAIL);
301
302 HRESULT rc = initImpl(aParent, strConfigFile);
303 if (FAILED(rc)) return rc;
304
305 rc = i_tryCreateMachineConfigFile(fForceOverwrite);
306 if (FAILED(rc)) return rc;
307
308 if (SUCCEEDED(rc))
309 {
310 // create an empty machine config
311 mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
312
313 rc = initDataAndChildObjects();
314 }
315
316 if (SUCCEEDED(rc))
317 {
318 // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
319 mData->mAccessible = TRUE;
320
321 unconst(mData->mUuid) = aId;
322
323 mUserData->s.strName = strName;
324
325 mUserData->s.llGroups = llGroups;
326
327 mUserData->s.fDirectoryIncludesUUID = fDirectoryIncludesUUID;
328 // the "name sync" flag determines whether the machine directory gets renamed along
329 // with the machine file; say so if the settings file name is the same as the
330 // settings file parent directory (machine directory)
331 mUserData->s.fNameSync = i_isInOwnDir();
332
333 // initialize the default snapshots folder
334 rc = COMSETTER(SnapshotFolder)(NULL);
335 AssertComRC(rc);
336
337 if (aOsType)
338 {
339 /* Store OS type */
340 mUserData->s.strOsType = aOsType->i_id();
341
342 /* Apply BIOS defaults */
343 mBIOSSettings->i_applyDefaults(aOsType);
344
345 /* Apply network adapters defaults */
346 for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
347 mNetworkAdapters[slot]->i_applyDefaults(aOsType);
348
349 /* Apply serial port defaults */
350 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
351 mSerialPorts[slot]->i_applyDefaults(aOsType);
352
353 /* Let the OS type select 64-bit ness. */
354 mHWData->mLongMode = aOsType->i_is64Bit()
355 ? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
356 }
357
358 /* At this point the changing of the current state modification
359 * flag is allowed. */
360 i_allowStateModification();
361
362 /* commit all changes made during the initialization */
363 i_commit();
364 }
365
366 /* Confirm a successful initialization when it's the case */
367 if (SUCCEEDED(rc))
368 {
369 if (mData->mAccessible)
370 autoInitSpan.setSucceeded();
371 else
372 autoInitSpan.setLimited();
373 }
374
375 LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool, rc=%08X\n",
376 !!mUserData ? mUserData->s.strName.c_str() : "NULL",
377 mData->mRegistered,
378 mData->mAccessible,
379 rc));
380
381 LogFlowThisFuncLeave();
382
383 return rc;
384}
385
386/**
387 * Initializes a new instance with data from machine XML (formerly Init_Registered).
388 * Gets called in two modes:
389 *
390 * -- from VirtualBox::initMachines() during VirtualBox startup; in that case, the
391 * UUID is specified and we mark the machine as "registered";
392 *
393 * -- from the public VirtualBox::OpenMachine() API, in which case the UUID is NULL
394 * and the machine remains unregistered until RegisterMachine() is called.
395 *
396 * @param aParent Associated parent object
397 * @param aConfigFile Local file system path to the VM settings file (can
398 * be relative to the VirtualBox config directory).
399 * @param aId UUID of the machine or NULL (see above).
400 *
401 * @return Success indicator. if not S_OK, the machine object is invalid
402 */
403HRESULT Machine::initFromSettings(VirtualBox *aParent,
404 const Utf8Str &strConfigFile,
405 const Guid *aId)
406{
407 LogFlowThisFuncEnter();
408 LogFlowThisFunc(("(Init_Registered) aConfigFile='%s\n", strConfigFile.c_str()));
409
410 /* Enclose the state transition NotReady->InInit->Ready */
411 AutoInitSpan autoInitSpan(this);
412 AssertReturn(autoInitSpan.isOk(), E_FAIL);
413
414 HRESULT rc = initImpl(aParent, strConfigFile);
415 if (FAILED(rc)) return rc;
416
417 if (aId)
418 {
419 // loading a registered VM:
420 unconst(mData->mUuid) = *aId;
421 mData->mRegistered = TRUE;
422 // now load the settings from XML:
423 rc = i_registeredInit();
424 // this calls initDataAndChildObjects() and loadSettings()
425 }
426 else
427 {
428 // opening an unregistered VM (VirtualBox::OpenMachine()):
429 rc = initDataAndChildObjects();
430
431 if (SUCCEEDED(rc))
432 {
433 // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
434 mData->mAccessible = TRUE;
435
436 try
437 {
438 // load and parse machine XML; this will throw on XML or logic errors
439 mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
440
441 // reject VM UUID duplicates, they can happen if someone
442 // tries to register an already known VM config again
443 if (aParent->i_findMachine(mData->pMachineConfigFile->uuid,
444 true /* fPermitInaccessible */,
445 false /* aDoSetError */,
446 NULL) != VBOX_E_OBJECT_NOT_FOUND)
447 {
448 throw setError(E_FAIL,
449 tr("Trying to open a VM config '%s' which has the same UUID as an existing virtual machine"),
450 mData->m_strConfigFile.c_str());
451 }
452
453 // use UUID from machine config
454 unconst(mData->mUuid) = mData->pMachineConfigFile->uuid;
455
456 rc = i_loadMachineDataFromSettings(*mData->pMachineConfigFile,
457 NULL /* puuidRegistry */);
458 if (FAILED(rc)) throw rc;
459
460 /* At this point the changing of the current state modification
461 * flag is allowed. */
462 i_allowStateModification();
463
464 i_commit();
465 }
466 catch (HRESULT err)
467 {
468 /* we assume that error info is set by the thrower */
469 rc = err;
470 }
471 catch (...)
472 {
473 rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
474 }
475 }
476 }
477
478 /* Confirm a successful initialization when it's the case */
479 if (SUCCEEDED(rc))
480 {
481 if (mData->mAccessible)
482 autoInitSpan.setSucceeded();
483 else
484 {
485 autoInitSpan.setLimited();
486
487 // uninit media from this machine's media registry, or else
488 // reloading the settings will fail
489 mParent->i_unregisterMachineMedia(i_getId());
490 }
491 }
492
493 LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
494 "rc=%08X\n",
495 !!mUserData ? mUserData->s.strName.c_str() : "NULL",
496 mData->mRegistered, mData->mAccessible, rc));
497
498 LogFlowThisFuncLeave();
499
500 return rc;
501}
502
503/**
504 * Initializes a new instance from a machine config that is already in memory
505 * (import OVF case). Since we are importing, the UUID in the machine
506 * config is ignored and we always generate a fresh one.
507 *
508 * @param strName Name for the new machine; this overrides what is specified in config and is used
509 * for the settings file as well.
510 * @param config Machine configuration loaded and parsed from XML.
511 *
512 * @return Success indicator. if not S_OK, the machine object is invalid
513 */
514HRESULT Machine::init(VirtualBox *aParent,
515 const Utf8Str &strName,
516 const settings::MachineConfigFile &config)
517{
518 LogFlowThisFuncEnter();
519
520 /* Enclose the state transition NotReady->InInit->Ready */
521 AutoInitSpan autoInitSpan(this);
522 AssertReturn(autoInitSpan.isOk(), E_FAIL);
523
524 Utf8Str strConfigFile;
525 aParent->i_getDefaultMachineFolder(strConfigFile);
526 strConfigFile.append(RTPATH_DELIMITER);
527 strConfigFile.append(strName);
528 strConfigFile.append(RTPATH_DELIMITER);
529 strConfigFile.append(strName);
530 strConfigFile.append(".vbox");
531
532 HRESULT rc = initImpl(aParent, strConfigFile);
533 if (FAILED(rc)) return rc;
534
535 rc = i_tryCreateMachineConfigFile(false /* fForceOverwrite */);
536 if (FAILED(rc)) return rc;
537
538 rc = initDataAndChildObjects();
539
540 if (SUCCEEDED(rc))
541 {
542 // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
543 mData->mAccessible = TRUE;
544
545 // create empty machine config for instance data
546 mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
547
548 // generate fresh UUID, ignore machine config
549 unconst(mData->mUuid).create();
550
551 rc = i_loadMachineDataFromSettings(config,
552 &mData->mUuid); // puuidRegistry: initialize media with this registry ID
553
554 // override VM name as well, it may be different
555 mUserData->s.strName = strName;
556
557 if (SUCCEEDED(rc))
558 {
559 /* At this point the changing of the current state modification
560 * flag is allowed. */
561 i_allowStateModification();
562
563 /* commit all changes made during the initialization */
564 i_commit();
565 }
566 }
567
568 /* Confirm a successful initialization when it's the case */
569 if (SUCCEEDED(rc))
570 {
571 if (mData->mAccessible)
572 autoInitSpan.setSucceeded();
573 else
574 {
575 /* Ignore all errors from unregistering, they would destroy
576- * the more interesting error information we already have,
577- * pinpointing the issue with the VM config. */
578 ErrorInfoKeeper eik;
579
580 autoInitSpan.setLimited();
581
582 // uninit media from this machine's media registry, or else
583 // reloading the settings will fail
584 mParent->i_unregisterMachineMedia(i_getId());
585 }
586 }
587
588 LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
589 "rc=%08X\n",
590 !!mUserData ? mUserData->s.strName.c_str() : "NULL",
591 mData->mRegistered, mData->mAccessible, rc));
592
593 LogFlowThisFuncLeave();
594
595 return rc;
596}
597
598/**
599 * Shared code between the various init() implementations.
600 * @param aParent
601 * @return
602 */
603HRESULT Machine::initImpl(VirtualBox *aParent,
604 const Utf8Str &strConfigFile)
605{
606 LogFlowThisFuncEnter();
607
608 AssertReturn(aParent, E_INVALIDARG);
609 AssertReturn(!strConfigFile.isEmpty(), E_INVALIDARG);
610
611 HRESULT rc = S_OK;
612
613 /* share the parent weakly */
614 unconst(mParent) = aParent;
615
616 /* allocate the essential machine data structure (the rest will be
617 * allocated later by initDataAndChildObjects() */
618 mData.allocate();
619
620 /* memorize the config file name (as provided) */
621 mData->m_strConfigFile = strConfigFile;
622
623 /* get the full file name */
624 int vrc1 = mParent->i_calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
625 if (RT_FAILURE(vrc1))
626 return setError(VBOX_E_FILE_ERROR,
627 tr("Invalid machine settings file name '%s' (%Rrc)"),
628 strConfigFile.c_str(),
629 vrc1);
630
631 LogFlowThisFuncLeave();
632
633 return rc;
634}
635
636/**
637 * Tries to create a machine settings file in the path stored in the machine
638 * instance data. Used when a new machine is created to fail gracefully if
639 * the settings file could not be written (e.g. because machine dir is read-only).
640 * @return
641 */
642HRESULT Machine::i_tryCreateMachineConfigFile(bool fForceOverwrite)
643{
644 HRESULT rc = S_OK;
645
646 // when we create a new machine, we must be able to create the settings file
647 RTFILE f = NIL_RTFILE;
648 int vrc = RTFileOpen(&f, mData->m_strConfigFileFull.c_str(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
649 if ( RT_SUCCESS(vrc)
650 || vrc == VERR_SHARING_VIOLATION
651 )
652 {
653 if (RT_SUCCESS(vrc))
654 RTFileClose(f);
655 if (!fForceOverwrite)
656 rc = setError(VBOX_E_FILE_ERROR,
657 tr("Machine settings file '%s' already exists"),
658 mData->m_strConfigFileFull.c_str());
659 else
660 {
661 /* try to delete the config file, as otherwise the creation
662 * of a new settings file will fail. */
663 int vrc2 = RTFileDelete(mData->m_strConfigFileFull.c_str());
664 if (RT_FAILURE(vrc2))
665 rc = setError(VBOX_E_FILE_ERROR,
666 tr("Could not delete the existing settings file '%s' (%Rrc)"),
667 mData->m_strConfigFileFull.c_str(), vrc2);
668 }
669 }
670 else if ( vrc != VERR_FILE_NOT_FOUND
671 && vrc != VERR_PATH_NOT_FOUND
672 )
673 rc = setError(VBOX_E_FILE_ERROR,
674 tr("Invalid machine settings file name '%s' (%Rrc)"),
675 mData->m_strConfigFileFull.c_str(),
676 vrc);
677 return rc;
678}
679
680/**
681 * Initializes the registered machine by loading the settings file.
682 * This method is separated from #init() in order to make it possible to
683 * retry the operation after VirtualBox startup instead of refusing to
684 * startup the whole VirtualBox server in case if the settings file of some
685 * registered VM is invalid or inaccessible.
686 *
687 * @note Must be always called from this object's write lock
688 * (unless called from #init() that doesn't need any locking).
689 * @note Locks the mUSBController method for writing.
690 * @note Subclasses must not call this method.
691 */
692HRESULT Machine::i_registeredInit()
693{
694 AssertReturn(!i_isSessionMachine(), E_FAIL);
695 AssertReturn(!i_isSnapshotMachine(), E_FAIL);
696 AssertReturn(mData->mUuid.isValid(), E_FAIL);
697 AssertReturn(!mData->mAccessible, E_FAIL);
698
699 HRESULT rc = initDataAndChildObjects();
700
701 if (SUCCEEDED(rc))
702 {
703 /* Temporarily reset the registered flag in order to let setters
704 * potentially called from loadSettings() succeed (isMutable() used in
705 * all setters will return FALSE for a Machine instance if mRegistered
706 * is TRUE). */
707 mData->mRegistered = FALSE;
708
709 try
710 {
711 // load and parse machine XML; this will throw on XML or logic errors
712 mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
713
714 if (mData->mUuid != mData->pMachineConfigFile->uuid)
715 throw setError(E_FAIL,
716 tr("Machine UUID {%RTuuid} in '%s' doesn't match its UUID {%s} in the registry file '%s'"),
717 mData->pMachineConfigFile->uuid.raw(),
718 mData->m_strConfigFileFull.c_str(),
719 mData->mUuid.toString().c_str(),
720 mParent->i_settingsFilePath().c_str());
721
722 rc = i_loadMachineDataFromSettings(*mData->pMachineConfigFile,
723 NULL /* const Guid *puuidRegistry */);
724 if (FAILED(rc)) throw rc;
725 }
726 catch (HRESULT err)
727 {
728 /* we assume that error info is set by the thrower */
729 rc = err;
730 }
731 catch (...)
732 {
733 rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
734 }
735
736 /* Restore the registered flag (even on failure) */
737 mData->mRegistered = TRUE;
738 }
739
740 if (SUCCEEDED(rc))
741 {
742 /* Set mAccessible to TRUE only if we successfully locked and loaded
743 * the settings file */
744 mData->mAccessible = TRUE;
745
746 /* commit all changes made during loading the settings file */
747 i_commit(); // @todo r=dj why do we need a commit during init?!? this is very expensive
748 /// @todo r=klaus for some reason the settings loading logic backs up
749 // the settings, and therefore a commit is needed. Should probably be changed.
750 }
751 else
752 {
753 /* If the machine is registered, then, instead of returning a
754 * failure, we mark it as inaccessible and set the result to
755 * success to give it a try later */
756
757 /* fetch the current error info */
758 mData->mAccessError = com::ErrorInfo();
759 LogWarning(("Machine {%RTuuid} is inaccessible! [%ls]\n",
760 mData->mUuid.raw(),
761 mData->mAccessError.getText().raw()));
762
763 /* rollback all changes */
764 i_rollback(false /* aNotify */);
765
766 // uninit media from this machine's media registry, or else
767 // reloading the settings will fail
768 mParent->i_unregisterMachineMedia(i_getId());
769
770 /* uninitialize the common part to make sure all data is reset to
771 * default (null) values */
772 uninitDataAndChildObjects();
773
774 rc = S_OK;
775 }
776
777 return rc;
778}
779
780/**
781 * Uninitializes the instance.
782 * Called either from FinalRelease() or by the parent when it gets destroyed.
783 *
784 * @note The caller of this method must make sure that this object
785 * a) doesn't have active callers on the current thread and b) is not locked
786 * by the current thread; otherwise uninit() will hang either a) due to
787 * AutoUninitSpan waiting for a number of calls to drop to zero or b) due to
788 * a dead-lock caused by this thread waiting for all callers on the other
789 * threads are done but preventing them from doing so by holding a lock.
790 */
791void Machine::uninit()
792{
793 LogFlowThisFuncEnter();
794
795 Assert(!isWriteLockOnCurrentThread());
796
797 Assert(!uRegistryNeedsSaving);
798 if (uRegistryNeedsSaving)
799 {
800 AutoCaller autoCaller(this);
801 if (SUCCEEDED(autoCaller.rc()))
802 {
803 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
804 i_saveSettings(NULL, Machine::SaveS_Force);
805 }
806 }
807
808 /* Enclose the state transition Ready->InUninit->NotReady */
809 AutoUninitSpan autoUninitSpan(this);
810 if (autoUninitSpan.uninitDone())
811 return;
812
813 Assert(!i_isSnapshotMachine());
814 Assert(!i_isSessionMachine());
815 Assert(!!mData);
816
817 LogFlowThisFunc(("initFailed()=%d\n", autoUninitSpan.initFailed()));
818 LogFlowThisFunc(("mRegistered=%d\n", mData->mRegistered));
819
820 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
821
822 if (!mData->mSession.mMachine.isNull())
823 {
824 /* Theoretically, this can only happen if the VirtualBox server has been
825 * terminated while there were clients running that owned open direct
826 * sessions. Since in this case we are definitely called by
827 * VirtualBox::uninit(), we may be sure that SessionMachine::uninit()
828 * won't happen on the client watcher thread (because it does
829 * VirtualBox::addCaller() for the duration of the
830 * SessionMachine::checkForDeath() call, so that VirtualBox::uninit()
831 * cannot happen until the VirtualBox caller is released). This is
832 * important, because SessionMachine::uninit() cannot correctly operate
833 * after we return from this method (it expects the Machine instance is
834 * still valid). We'll call it ourselves below.
835 */
836 LogWarningThisFunc(("Session machine is not NULL (%p), the direct session is still open!\n",
837 (SessionMachine*)mData->mSession.mMachine));
838
839 if (Global::IsOnlineOrTransient(mData->mMachineState))
840 {
841 LogWarningThisFunc(("Setting state to Aborted!\n"));
842 /* set machine state using SessionMachine reimplementation */
843 static_cast<Machine*>(mData->mSession.mMachine)->i_setMachineState(MachineState_Aborted);
844 }
845
846 /*
847 * Uninitialize SessionMachine using public uninit() to indicate
848 * an unexpected uninitialization.
849 */
850 mData->mSession.mMachine->uninit();
851 /* SessionMachine::uninit() must set mSession.mMachine to null */
852 Assert(mData->mSession.mMachine.isNull());
853 }
854
855 // uninit media from this machine's media registry, if they're still there
856 Guid uuidMachine(i_getId());
857
858 /* the lock is no more necessary (SessionMachine is uninitialized) */
859 alock.release();
860
861 /* XXX This will fail with
862 * "cannot be closed because it is still attached to 1 virtual machines"
863 * because at this point we did not call uninitDataAndChildObjects() yet
864 * and therefore also removeBackReference() for all these mediums was not called! */
865
866 if (uuidMachine.isValid() && !uuidMachine.isZero()) // can be empty if we're called from a failure of Machine::init
867 mParent->i_unregisterMachineMedia(uuidMachine);
868
869 // has machine been modified?
870 if (mData->flModifications)
871 {
872 LogWarningThisFunc(("Discarding unsaved settings changes!\n"));
873 i_rollback(false /* aNotify */);
874 }
875
876 if (mData->mAccessible)
877 uninitDataAndChildObjects();
878
879 /* free the essential data structure last */
880 mData.free();
881
882 LogFlowThisFuncLeave();
883}
884
885// Wrapped IMachine properties
886/////////////////////////////////////////////////////////////////////////////
887HRESULT Machine::getParent(ComPtr<IVirtualBox> &aParent)
888{
889 /* mParent is constant during life time, no need to lock */
890 ComObjPtr<VirtualBox> pVirtualBox(mParent);
891 pVirtualBox.queryInterfaceTo(aParent.asOutParam());
892
893 return S_OK;
894}
895
896
897HRESULT Machine::getAccessible(BOOL *aAccessible)
898{
899 /* In some cases (medium registry related), it is necessary to be able to
900 * go through the list of all machines. Happens when an inaccessible VM
901 * has a sensible medium registry. */
902 AutoReadLock mllock(mParent->i_getMachinesListLockHandle() COMMA_LOCKVAL_SRC_POS);
903 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
904
905 HRESULT rc = S_OK;
906
907 if (!mData->mAccessible)
908 {
909 /* try to initialize the VM once more if not accessible */
910
911 AutoReinitSpan autoReinitSpan(this);
912 AssertReturn(autoReinitSpan.isOk(), E_FAIL);
913
914#ifdef DEBUG
915 LogFlowThisFunc(("Dumping media backreferences\n"));
916 mParent->i_dumpAllBackRefs();
917#endif
918
919 if (mData->pMachineConfigFile)
920 {
921 // reset the XML file to force loadSettings() (called from registeredInit())
922 // to parse it again; the file might have changed
923 delete mData->pMachineConfigFile;
924 mData->pMachineConfigFile = NULL;
925 }
926
927 rc = i_registeredInit();
928
929 if (SUCCEEDED(rc) && mData->mAccessible)
930 {
931 autoReinitSpan.setSucceeded();
932
933 /* make sure interesting parties will notice the accessibility
934 * state change */
935 mParent->i_onMachineStateChange(mData->mUuid, mData->mMachineState);
936 mParent->i_onMachineDataChange(mData->mUuid);
937 }
938 }
939
940 if (SUCCEEDED(rc))
941 *aAccessible = mData->mAccessible;
942
943 LogFlowThisFuncLeave();
944
945 return rc;
946}
947
948HRESULT Machine::getAccessError(ComPtr<IVirtualBoxErrorInfo> &aAccessError)
949{
950 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
951
952 if (mData->mAccessible || !mData->mAccessError.isBasicAvailable())
953 {
954 /* return shortly */
955 aAccessError = NULL;
956 return S_OK;
957 }
958
959 HRESULT rc = S_OK;
960
961 ComObjPtr<VirtualBoxErrorInfo> errorInfo;
962 rc = errorInfo.createObject();
963 if (SUCCEEDED(rc))
964 {
965 errorInfo->init(mData->mAccessError.getResultCode(),
966 mData->mAccessError.getInterfaceID().ref(),
967 Utf8Str(mData->mAccessError.getComponent()).c_str(),
968 Utf8Str(mData->mAccessError.getText()));
969 rc = errorInfo.queryInterfaceTo(aAccessError.asOutParam());
970 }
971
972 return rc;
973}
974
975HRESULT Machine::getName(com::Utf8Str &aName)
976{
977 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
978
979 aName = mUserData->s.strName;
980
981 return S_OK;
982}
983
984HRESULT Machine::setName(const com::Utf8Str &aName)
985{
986 // prohibit setting a UUID only as the machine name, or else it can
987 // never be found by findMachine()
988 Guid test(aName);
989
990 if (test.isValid())
991 return setError(E_INVALIDARG, tr("A machine cannot have a UUID as its name"));
992
993 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
994
995 HRESULT rc = i_checkStateDependency(MutableStateDep);
996 if (FAILED(rc)) return rc;
997
998 i_setModified(IsModified_MachineData);
999 mUserData.backup();
1000 mUserData->s.strName = aName;
1001
1002 return S_OK;
1003}
1004
1005HRESULT Machine::getDescription(com::Utf8Str &aDescription)
1006{
1007 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1008
1009 aDescription = mUserData->s.strDescription;
1010
1011 return S_OK;
1012}
1013
1014HRESULT Machine::setDescription(const com::Utf8Str &aDescription)
1015{
1016 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1017
1018 // this can be done in principle in any state as it doesn't affect the VM
1019 // significantly, but play safe by not messing around while complex
1020 // activities are going on
1021 HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
1022 if (FAILED(rc)) return rc;
1023
1024 i_setModified(IsModified_MachineData);
1025 mUserData.backup();
1026 mUserData->s.strDescription = aDescription;
1027
1028 return S_OK;
1029}
1030
1031HRESULT Machine::getId(com::Guid &aId)
1032{
1033 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1034
1035 aId = mData->mUuid;
1036
1037 return S_OK;
1038}
1039
1040HRESULT Machine::getGroups(std::vector<com::Utf8Str> &aGroups)
1041{
1042 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1043 aGroups.resize(mUserData->s.llGroups.size());
1044 size_t i = 0;
1045 for (StringsList::const_iterator it = mUserData->s.llGroups.begin();
1046 it != mUserData->s.llGroups.end(); ++it, ++i)
1047 aGroups[i] = (*it);
1048
1049 return S_OK;
1050}
1051
1052HRESULT Machine::setGroups(const std::vector<com::Utf8Str> &aGroups)
1053{
1054 StringsList llGroups;
1055 HRESULT rc = mParent->i_convertMachineGroups(aGroups, &llGroups);
1056 if (FAILED(rc))
1057 return rc;
1058
1059 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1060
1061 // changing machine groups is possible while the VM is offline
1062 rc = i_checkStateDependency(OfflineStateDep);
1063 if (FAILED(rc)) return rc;
1064
1065 i_setModified(IsModified_MachineData);
1066 mUserData.backup();
1067 mUserData->s.llGroups = llGroups;
1068
1069 return S_OK;
1070}
1071
1072HRESULT Machine::getOSTypeId(com::Utf8Str &aOSTypeId)
1073{
1074 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1075
1076 aOSTypeId = mUserData->s.strOsType;
1077
1078 return S_OK;
1079}
1080
1081HRESULT Machine::setOSTypeId(const com::Utf8Str &aOSTypeId)
1082{
1083 /* look up the object by Id to check it is valid */
1084 ComPtr<IGuestOSType> guestOSType;
1085 HRESULT rc = mParent->GetGuestOSType(Bstr(aOSTypeId).raw(), guestOSType.asOutParam());
1086 if (FAILED(rc)) return rc;
1087
1088 /* when setting, always use the "etalon" value for consistency -- lookup
1089 * by ID is case-insensitive and the input value may have different case */
1090 Bstr osTypeId;
1091 rc = guestOSType->COMGETTER(Id)(osTypeId.asOutParam());
1092 if (FAILED(rc)) return rc;
1093
1094 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1095
1096 rc = i_checkStateDependency(MutableStateDep);
1097 if (FAILED(rc)) return rc;
1098
1099 i_setModified(IsModified_MachineData);
1100 mUserData.backup();
1101 mUserData->s.strOsType = osTypeId;
1102
1103 return S_OK;
1104}
1105
1106HRESULT Machine::getFirmwareType(FirmwareType_T *aFirmwareType)
1107{
1108 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1109
1110 *aFirmwareType = mHWData->mFirmwareType;
1111
1112 return S_OK;
1113}
1114
1115HRESULT Machine::setFirmwareType(FirmwareType_T aFirmwareType)
1116{
1117 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1118
1119 HRESULT rc = i_checkStateDependency(MutableStateDep);
1120 if (FAILED(rc)) return rc;
1121
1122 i_setModified(IsModified_MachineData);
1123 mHWData.backup();
1124 mHWData->mFirmwareType = aFirmwareType;
1125
1126 return S_OK;
1127}
1128
1129HRESULT Machine::getKeyboardHIDType(KeyboardHIDType_T *aKeyboardHIDType)
1130{
1131 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1132
1133 *aKeyboardHIDType = mHWData->mKeyboardHIDType;
1134
1135 return S_OK;
1136}
1137
1138HRESULT Machine::setKeyboardHIDType(KeyboardHIDType_T aKeyboardHIDType)
1139{
1140 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1141
1142 HRESULT rc = i_checkStateDependency(MutableStateDep);
1143 if (FAILED(rc)) return rc;
1144
1145 i_setModified(IsModified_MachineData);
1146 mHWData.backup();
1147 mHWData->mKeyboardHIDType = aKeyboardHIDType;
1148
1149 return S_OK;
1150}
1151
1152HRESULT Machine::getPointingHIDType(PointingHIDType_T *aPointingHIDType)
1153{
1154 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1155
1156 *aPointingHIDType = mHWData->mPointingHIDType;
1157
1158 return S_OK;
1159}
1160
1161HRESULT Machine::setPointingHIDType(PointingHIDType_T aPointingHIDType)
1162{
1163 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1164
1165 HRESULT rc = i_checkStateDependency(MutableStateDep);
1166 if (FAILED(rc)) return rc;
1167
1168 i_setModified(IsModified_MachineData);
1169 mHWData.backup();
1170 mHWData->mPointingHIDType = aPointingHIDType;
1171
1172 return S_OK;
1173}
1174
1175HRESULT Machine::getChipsetType(ChipsetType_T *aChipsetType)
1176{
1177 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1178
1179 *aChipsetType = mHWData->mChipsetType;
1180
1181 return S_OK;
1182}
1183
1184HRESULT Machine::setChipsetType(ChipsetType_T aChipsetType)
1185{
1186 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1187
1188 HRESULT rc = i_checkStateDependency(MutableStateDep);
1189 if (FAILED(rc)) return rc;
1190
1191 if (aChipsetType != mHWData->mChipsetType)
1192 {
1193 i_setModified(IsModified_MachineData);
1194 mHWData.backup();
1195 mHWData->mChipsetType = aChipsetType;
1196
1197 // Resize network adapter array, to be finalized on commit/rollback.
1198 // We must not throw away entries yet, otherwise settings are lost
1199 // without a way to roll back.
1200 size_t newCount = Global::getMaxNetworkAdapters(aChipsetType);
1201 size_t oldCount = mNetworkAdapters.size();
1202 if (newCount > oldCount)
1203 {
1204 mNetworkAdapters.resize(newCount);
1205 for (ULONG slot = oldCount; slot < mNetworkAdapters.size(); slot++)
1206 {
1207 unconst(mNetworkAdapters[slot]).createObject();
1208 mNetworkAdapters[slot]->init(this, slot);
1209 }
1210 }
1211 }
1212
1213 return S_OK;
1214}
1215
1216HRESULT Machine::getParavirtProvider(ParavirtProvider_T *aParavirtProvider)
1217{
1218 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1219
1220 *aParavirtProvider = mHWData->mParavirtProvider;
1221
1222 return S_OK;
1223}
1224
1225HRESULT Machine::setParavirtProvider(ParavirtProvider_T aParavirtProvider)
1226{
1227 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1228
1229 HRESULT rc = i_checkStateDependency(MutableStateDep);
1230 if (FAILED(rc)) return rc;
1231
1232 if (aParavirtProvider != mHWData->mParavirtProvider)
1233 {
1234 i_setModified(IsModified_MachineData);
1235 mHWData.backup();
1236 mHWData->mParavirtProvider = aParavirtProvider;
1237 }
1238
1239 return S_OK;
1240}
1241
1242HRESULT Machine::getEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider)
1243{
1244 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1245
1246 *aParavirtProvider = mHWData->mParavirtProvider;
1247 switch (mHWData->mParavirtProvider)
1248 {
1249 case ParavirtProvider_None:
1250 case ParavirtProvider_HyperV:
1251 case ParavirtProvider_Minimal:
1252 break;
1253
1254 /* Resolve dynamic provider types to the effective types. */
1255 default:
1256 {
1257 ComPtr<IGuestOSType> ptrGuestOSType;
1258 HRESULT hrc2 = mParent->GetGuestOSType(Bstr(mUserData->s.strOsType).raw(), ptrGuestOSType.asOutParam());
1259 AssertMsgReturn(SUCCEEDED(hrc2), ("Failed to get guest OS type. hrc2=%Rhrc\n", hrc2), hrc2);
1260
1261 Bstr guestTypeFamilyId;
1262 hrc2 = ptrGuestOSType->COMGETTER(FamilyId)(guestTypeFamilyId.asOutParam());
1263 AssertMsgReturn(SUCCEEDED(hrc2), ("Failed to get guest family. hrc2=%Rhrc\n", hrc2), hrc2);
1264 BOOL fOsXGuest = guestTypeFamilyId == Bstr("MacOS");
1265
1266 switch (mHWData->mParavirtProvider)
1267 {
1268 case ParavirtProvider_Legacy:
1269 {
1270 if (fOsXGuest)
1271 *aParavirtProvider = ParavirtProvider_Minimal;
1272 else
1273 *aParavirtProvider = ParavirtProvider_None;
1274 break;
1275 }
1276
1277 case ParavirtProvider_Default:
1278 {
1279 if (fOsXGuest)
1280 *aParavirtProvider = ParavirtProvider_Minimal;
1281#if 0 /* Activate this soon. */
1282 else if ( mUserData->s.strOsType == "Windows81"
1283 || mUserData->s.strOsType == "Windows81_64"
1284 || mUserData->s.strOsType == "Windows8"
1285 || mUserData->s.strOsType == "Windows8_64"
1286 || mUserData->s.strOsType == "Windows7"
1287 || mUserData->s.strOsType == "Windows7_64"
1288 || mUserData->s.strOsType == "WindowsVista"
1289 || mUserData->s.strOsType == "WindowsVista_64"
1290 || mUserData->s.strOsType == "Windows2012"
1291 || mUserData->s.strOsType == "Windows2012_64"
1292 || mUserData->s.strOsType == "Windows2008"
1293 || mUserData->s.strOsType == "Windows2008_64")
1294 {
1295 *aParavirtProvider = ParavirtProvider_HyperV;
1296 }
1297#endif
1298 else
1299 *aParavirtProvider = ParavirtProvider_None;
1300 break;
1301 }
1302 }
1303 break;
1304 }
1305 }
1306
1307 Assert( *aParavirtProvider == ParavirtProvider_None
1308 || *aParavirtProvider == ParavirtProvider_Minimal
1309 || *aParavirtProvider == ParavirtProvider_HyperV);
1310 return S_OK;
1311}
1312
1313HRESULT Machine::getHardwareVersion(com::Utf8Str &aHardwareVersion)
1314{
1315 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1316
1317 aHardwareVersion = mHWData->mHWVersion;
1318
1319 return S_OK;
1320}
1321
1322HRESULT Machine::setHardwareVersion(const com::Utf8Str &aHardwareVersion)
1323{
1324 /* check known version */
1325 Utf8Str hwVersion = aHardwareVersion;
1326 if ( hwVersion.compare("1") != 0
1327 && hwVersion.compare("2") != 0)
1328 return setError(E_INVALIDARG,
1329 tr("Invalid hardware version: %s\n"), aHardwareVersion.c_str());
1330
1331 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1332
1333 HRESULT rc = i_checkStateDependency(MutableStateDep);
1334 if (FAILED(rc)) return rc;
1335
1336 i_setModified(IsModified_MachineData);
1337 mHWData.backup();
1338 mHWData->mHWVersion = aHardwareVersion;
1339
1340 return S_OK;
1341}
1342
1343HRESULT Machine::getHardwareUUID(com::Guid &aHardwareUUID)
1344{
1345 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1346
1347 if (!mHWData->mHardwareUUID.isZero())
1348 aHardwareUUID = mHWData->mHardwareUUID;
1349 else
1350 aHardwareUUID = mData->mUuid;
1351
1352 return S_OK;
1353}
1354
1355HRESULT Machine::setHardwareUUID(const com::Guid &aHardwareUUID)
1356{
1357 if (!aHardwareUUID.isValid())
1358 return E_INVALIDARG;
1359
1360 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1361
1362 HRESULT rc = i_checkStateDependency(MutableStateDep);
1363 if (FAILED(rc)) return rc;
1364
1365 i_setModified(IsModified_MachineData);
1366 mHWData.backup();
1367 if (aHardwareUUID == mData->mUuid)
1368 mHWData->mHardwareUUID.clear();
1369 else
1370 mHWData->mHardwareUUID = aHardwareUUID;
1371
1372 return S_OK;
1373}
1374
1375HRESULT Machine::getMemorySize(ULONG *aMemorySize)
1376{
1377 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1378
1379 *aMemorySize = mHWData->mMemorySize;
1380
1381 return S_OK;
1382}
1383
1384HRESULT Machine::setMemorySize(ULONG aMemorySize)
1385{
1386 /* check RAM limits */
1387 if ( aMemorySize < MM_RAM_MIN_IN_MB
1388 || aMemorySize > MM_RAM_MAX_IN_MB
1389 )
1390 return setError(E_INVALIDARG,
1391 tr("Invalid RAM size: %lu MB (must be in range [%lu, %lu] MB)"),
1392 aMemorySize, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
1393
1394 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1395
1396 HRESULT rc = i_checkStateDependency(MutableStateDep);
1397 if (FAILED(rc)) return rc;
1398
1399 i_setModified(IsModified_MachineData);
1400 mHWData.backup();
1401 mHWData->mMemorySize = aMemorySize;
1402
1403 return S_OK;
1404}
1405
1406HRESULT Machine::getCPUCount(ULONG *aCPUCount)
1407{
1408 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1409
1410 *aCPUCount = mHWData->mCPUCount;
1411
1412 return S_OK;
1413}
1414
1415HRESULT Machine::setCPUCount(ULONG aCPUCount)
1416{
1417 /* check CPU limits */
1418 if ( aCPUCount < SchemaDefs::MinCPUCount
1419 || aCPUCount > SchemaDefs::MaxCPUCount
1420 )
1421 return setError(E_INVALIDARG,
1422 tr("Invalid virtual CPU count: %lu (must be in range [%lu, %lu])"),
1423 aCPUCount, SchemaDefs::MinCPUCount, SchemaDefs::MaxCPUCount);
1424
1425 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1426
1427 /* We cant go below the current number of CPUs attached if hotplug is enabled*/
1428 if (mHWData->mCPUHotPlugEnabled)
1429 {
1430 for (unsigned idx = aCPUCount; idx < SchemaDefs::MaxCPUCount; idx++)
1431 {
1432 if (mHWData->mCPUAttached[idx])
1433 return setError(E_INVALIDARG,
1434 tr("There is still a CPU attached to socket %lu."
1435 "Detach the CPU before removing the socket"),
1436 aCPUCount, idx+1);
1437 }
1438 }
1439
1440 HRESULT rc = i_checkStateDependency(MutableStateDep);
1441 if (FAILED(rc)) return rc;
1442
1443 i_setModified(IsModified_MachineData);
1444 mHWData.backup();
1445 mHWData->mCPUCount = aCPUCount;
1446
1447 return S_OK;
1448}
1449
1450HRESULT Machine::getCPUExecutionCap(ULONG *aCPUExecutionCap)
1451{
1452 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1453
1454 *aCPUExecutionCap = mHWData->mCpuExecutionCap;
1455
1456 return S_OK;
1457}
1458
1459HRESULT Machine::setCPUExecutionCap(ULONG aCPUExecutionCap)
1460{
1461 HRESULT rc = S_OK;
1462
1463 /* check throttle limits */
1464 if ( aCPUExecutionCap < 1
1465 || aCPUExecutionCap > 100
1466 )
1467 return setError(E_INVALIDARG,
1468 tr("Invalid CPU execution cap value: %lu (must be in range [%lu, %lu])"),
1469 aCPUExecutionCap, 1, 100);
1470
1471 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1472
1473 alock.release();
1474 rc = i_onCPUExecutionCapChange(aCPUExecutionCap);
1475 alock.acquire();
1476 if (FAILED(rc)) return rc;
1477
1478 i_setModified(IsModified_MachineData);
1479 mHWData.backup();
1480 mHWData->mCpuExecutionCap = aCPUExecutionCap;
1481
1482 /** Save settings if online - @todo why is this required? -- @bugref{6818} */
1483 if (Global::IsOnline(mData->mMachineState))
1484 i_saveSettings(NULL);
1485
1486 return S_OK;
1487}
1488
1489HRESULT Machine::getCPUHotPlugEnabled(BOOL *aCPUHotPlugEnabled)
1490{
1491 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1492
1493 *aCPUHotPlugEnabled = mHWData->mCPUHotPlugEnabled;
1494
1495 return S_OK;
1496}
1497
1498HRESULT Machine::setCPUHotPlugEnabled(BOOL aCPUHotPlugEnabled)
1499{
1500 HRESULT rc = S_OK;
1501
1502 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1503
1504 rc = i_checkStateDependency(MutableStateDep);
1505 if (FAILED(rc)) return rc;
1506
1507 if (mHWData->mCPUHotPlugEnabled != aCPUHotPlugEnabled)
1508 {
1509 if (aCPUHotPlugEnabled)
1510 {
1511 i_setModified(IsModified_MachineData);
1512 mHWData.backup();
1513
1514 /* Add the amount of CPUs currently attached */
1515 for (unsigned i = 0; i < mHWData->mCPUCount; ++i)
1516 mHWData->mCPUAttached[i] = true;
1517 }
1518 else
1519 {
1520 /*
1521 * We can disable hotplug only if the amount of maximum CPUs is equal
1522 * to the amount of attached CPUs
1523 */
1524 unsigned cCpusAttached = 0;
1525 unsigned iHighestId = 0;
1526
1527 for (unsigned i = 0; i < SchemaDefs::MaxCPUCount; ++i)
1528 {
1529 if (mHWData->mCPUAttached[i])
1530 {
1531 cCpusAttached++;
1532 iHighestId = i;
1533 }
1534 }
1535
1536 if ( (cCpusAttached != mHWData->mCPUCount)
1537 || (iHighestId >= mHWData->mCPUCount))
1538 return setError(E_INVALIDARG,
1539 tr("CPU hotplugging can't be disabled because the maximum number of CPUs is not equal to the amount of CPUs attached"));
1540
1541 i_setModified(IsModified_MachineData);
1542 mHWData.backup();
1543 }
1544 }
1545
1546 mHWData->mCPUHotPlugEnabled = aCPUHotPlugEnabled;
1547
1548 return rc;
1549}
1550
1551HRESULT Machine::getEmulatedUSBCardReaderEnabled(BOOL *aEmulatedUSBCardReaderEnabled)
1552{
1553#ifdef VBOX_WITH_USB_CARDREADER
1554 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1555
1556 *aEmulatedUSBCardReaderEnabled = mHWData->mEmulatedUSBCardReaderEnabled;
1557
1558 return S_OK;
1559#else
1560 NOREF(aEmulatedUSBCardReaderEnabled);
1561 return E_NOTIMPL;
1562#endif
1563}
1564
1565HRESULT Machine::setEmulatedUSBCardReaderEnabled(BOOL aEmulatedUSBCardReaderEnabled)
1566{
1567#ifdef VBOX_WITH_USB_CARDREADER
1568 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1569
1570 HRESULT rc = i_checkStateDependency(MutableStateDep);
1571 if (FAILED(rc)) return rc;
1572
1573 i_setModified(IsModified_MachineData);
1574 mHWData.backup();
1575 mHWData->mEmulatedUSBCardReaderEnabled = aEmulatedUSBCardReaderEnabled;
1576
1577 return S_OK;
1578#else
1579 NOREF(aEmulatedUSBCardReaderEnabled);
1580 return E_NOTIMPL;
1581#endif
1582}
1583
1584HRESULT Machine::getHPETEnabled(BOOL *aHPETEnabled)
1585{
1586 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1587
1588 *aHPETEnabled = mHWData->mHPETEnabled;
1589
1590 return S_OK;
1591}
1592
1593HRESULT Machine::setHPETEnabled(BOOL aHPETEnabled)
1594{
1595 HRESULT rc = S_OK;
1596
1597 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1598
1599 rc = i_checkStateDependency(MutableStateDep);
1600 if (FAILED(rc)) return rc;
1601
1602 i_setModified(IsModified_MachineData);
1603 mHWData.backup();
1604
1605 mHWData->mHPETEnabled = aHPETEnabled;
1606
1607 return rc;
1608}
1609
1610HRESULT Machine::getVideoCaptureEnabled(BOOL *aVideoCaptureEnabled)
1611{
1612 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1613
1614 *aVideoCaptureEnabled = mHWData->mVideoCaptureEnabled;
1615 return S_OK;
1616}
1617
1618HRESULT Machine::setVideoCaptureEnabled(BOOL aVideoCaptureEnabled)
1619{
1620 HRESULT rc = S_OK;
1621
1622 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1623
1624 i_setModified(IsModified_MachineData);
1625 mHWData.backup();
1626 mHWData->mVideoCaptureEnabled = aVideoCaptureEnabled;
1627
1628 alock.release();
1629 rc = i_onVideoCaptureChange();
1630 alock.acquire();
1631 if (FAILED(rc))
1632 {
1633 /*
1634 * Normally we would do the actual change _after_ i_onVideoCaptureChange() succeeded.
1635 * We cannot do this because that function uses Machine::GetVideoCaptureEnabled to
1636 * determine if it should start or stop capturing. Therefore we need to manually
1637 * undo change.
1638 */
1639 mHWData->mVideoCaptureEnabled = mHWData.backedUpData()->mVideoCaptureEnabled;
1640 return rc;
1641 }
1642
1643 /** Save settings if online - @todo why is this required? -- @bugref{6818} */
1644 if (Global::IsOnline(mData->mMachineState))
1645 i_saveSettings(NULL);
1646
1647 return rc;
1648}
1649
1650HRESULT Machine::getVideoCaptureScreens(std::vector<BOOL> &aVideoCaptureScreens)
1651{
1652 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1653 aVideoCaptureScreens.resize(mHWData->mMonitorCount);
1654 for (unsigned i = 0; i < mHWData->mMonitorCount; ++i)
1655 aVideoCaptureScreens[i] = mHWData->maVideoCaptureScreens[i];
1656 return S_OK;
1657}
1658
1659HRESULT Machine::setVideoCaptureScreens(const std::vector<BOOL> &aVideoCaptureScreens)
1660{
1661 SafeArray<BOOL> screens(aVideoCaptureScreens);
1662 AssertReturn(screens.size() <= RT_ELEMENTS(mHWData->maVideoCaptureScreens), E_INVALIDARG);
1663 bool fChanged = false;
1664
1665 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1666
1667 for (unsigned i = 0; i < screens.size(); ++i)
1668 {
1669 if (mHWData->maVideoCaptureScreens[i] != RT_BOOL(screens[i]))
1670 {
1671 mHWData->maVideoCaptureScreens[i] = RT_BOOL(screens[i]);
1672 fChanged = true;
1673 }
1674 }
1675 if (fChanged)
1676 {
1677 alock.release();
1678 HRESULT rc = i_onVideoCaptureChange();
1679 alock.acquire();
1680 if (FAILED(rc)) return rc;
1681 i_setModified(IsModified_MachineData);
1682
1683 /** Save settings if online - @todo why is this required? -- @bugref{6818} */
1684 if (Global::IsOnline(mData->mMachineState))
1685 i_saveSettings(NULL);
1686 }
1687
1688 return S_OK;
1689}
1690
1691HRESULT Machine::getVideoCaptureFile(com::Utf8Str &aVideoCaptureFile)
1692{
1693 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1694 if (mHWData->mVideoCaptureFile.isEmpty())
1695 i_getDefaultVideoCaptureFile(aVideoCaptureFile);
1696 else
1697 aVideoCaptureFile = mHWData->mVideoCaptureFile;
1698 return S_OK;
1699}
1700
1701HRESULT Machine::setVideoCaptureFile(const com::Utf8Str &aVideoCaptureFile)
1702{
1703 Utf8Str strFile(aVideoCaptureFile);
1704 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1705
1706 if ( Global::IsOnline(mData->mMachineState)
1707 && mHWData->mVideoCaptureEnabled)
1708 return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1709
1710 if (!RTPathStartsWithRoot(strFile.c_str()))
1711 return setError(E_INVALIDARG, tr("Video capture file name '%s' is not absolute"), strFile.c_str());
1712
1713 if (!strFile.isEmpty())
1714 {
1715 Utf8Str defaultFile;
1716 i_getDefaultVideoCaptureFile(defaultFile);
1717 if (!RTPathCompare(strFile.c_str(), defaultFile.c_str()))
1718 strFile.setNull();
1719 }
1720
1721 i_setModified(IsModified_MachineData);
1722 mHWData.backup();
1723 mHWData->mVideoCaptureFile = strFile;
1724
1725 return S_OK;
1726}
1727
1728HRESULT Machine::getVideoCaptureWidth(ULONG *aVideoCaptureWidth)
1729{
1730 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1731 *aVideoCaptureWidth = mHWData->mVideoCaptureWidth;
1732 return S_OK;
1733}
1734
1735HRESULT Machine::setVideoCaptureWidth(ULONG aVideoCaptureWidth)
1736{
1737 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1738
1739 if ( Global::IsOnline(mData->mMachineState)
1740 && mHWData->mVideoCaptureEnabled)
1741 return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1742
1743 i_setModified(IsModified_MachineData);
1744 mHWData.backup();
1745 mHWData->mVideoCaptureWidth = aVideoCaptureWidth;
1746
1747 return S_OK;
1748}
1749
1750HRESULT Machine::getVideoCaptureHeight(ULONG *aVideoCaptureHeight)
1751{
1752 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1753 *aVideoCaptureHeight = mHWData->mVideoCaptureHeight;
1754 return S_OK;
1755}
1756
1757HRESULT Machine::setVideoCaptureHeight(ULONG aVideoCaptureHeight)
1758{
1759 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1760
1761 if ( Global::IsOnline(mData->mMachineState)
1762 && mHWData->mVideoCaptureEnabled)
1763 return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1764
1765 i_setModified(IsModified_MachineData);
1766 mHWData.backup();
1767 mHWData->mVideoCaptureHeight = aVideoCaptureHeight;
1768
1769 return S_OK;
1770}
1771
1772HRESULT Machine::getVideoCaptureRate(ULONG *aVideoCaptureRate)
1773{
1774 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1775 *aVideoCaptureRate = mHWData->mVideoCaptureRate;
1776 return S_OK;
1777}
1778
1779HRESULT Machine::setVideoCaptureRate(ULONG aVideoCaptureRate)
1780{
1781 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1782
1783 if ( Global::IsOnline(mData->mMachineState)
1784 && mHWData->mVideoCaptureEnabled)
1785 return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1786
1787 i_setModified(IsModified_MachineData);
1788 mHWData.backup();
1789 mHWData->mVideoCaptureRate = aVideoCaptureRate;
1790
1791 return S_OK;
1792}
1793
1794HRESULT Machine::getVideoCaptureFPS(ULONG *aVideoCaptureFPS)
1795{
1796 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1797 *aVideoCaptureFPS = mHWData->mVideoCaptureFPS;
1798 return S_OK;
1799}
1800
1801HRESULT Machine::setVideoCaptureFPS(ULONG aVideoCaptureFPS)
1802{
1803 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1804
1805 if ( Global::IsOnline(mData->mMachineState)
1806 && mHWData->mVideoCaptureEnabled)
1807 return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
1808
1809 i_setModified(IsModified_MachineData);
1810 mHWData.backup();
1811 mHWData->mVideoCaptureFPS = aVideoCaptureFPS;
1812
1813 return S_OK;
1814}
1815
1816HRESULT Machine::getGraphicsControllerType(GraphicsControllerType_T *aGraphicsControllerType)
1817{
1818 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1819
1820 *aGraphicsControllerType = mHWData->mGraphicsControllerType;
1821
1822 return S_OK;
1823}
1824
1825HRESULT Machine::setGraphicsControllerType(GraphicsControllerType_T aGraphicsControllerType)
1826{
1827 switch (aGraphicsControllerType)
1828 {
1829 case GraphicsControllerType_Null:
1830 case GraphicsControllerType_VBoxVGA:
1831#ifdef VBOX_WITH_VMSVGA
1832 case GraphicsControllerType_VMSVGA:
1833#endif
1834 break;
1835 default:
1836 return setError(E_INVALIDARG, tr("The graphics controller type (%d) is invalid"), aGraphicsControllerType);
1837 }
1838
1839 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1840
1841 HRESULT rc = i_checkStateDependency(MutableStateDep);
1842 if (FAILED(rc)) return rc;
1843
1844 i_setModified(IsModified_MachineData);
1845 mHWData.backup();
1846 mHWData->mGraphicsControllerType = aGraphicsControllerType;
1847
1848 return S_OK;
1849}
1850
1851HRESULT Machine::getVRAMSize(ULONG *aVRAMSize)
1852{
1853 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1854
1855 *aVRAMSize = mHWData->mVRAMSize;
1856
1857 return S_OK;
1858}
1859
1860HRESULT Machine::setVRAMSize(ULONG aVRAMSize)
1861{
1862 /* check VRAM limits */
1863 if (aVRAMSize < SchemaDefs::MinGuestVRAM ||
1864 aVRAMSize > SchemaDefs::MaxGuestVRAM)
1865 return setError(E_INVALIDARG,
1866 tr("Invalid VRAM size: %lu MB (must be in range [%lu, %lu] MB)"),
1867 aVRAMSize, SchemaDefs::MinGuestVRAM, SchemaDefs::MaxGuestVRAM);
1868
1869 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1870
1871 HRESULT rc = i_checkStateDependency(MutableStateDep);
1872 if (FAILED(rc)) return rc;
1873
1874 i_setModified(IsModified_MachineData);
1875 mHWData.backup();
1876 mHWData->mVRAMSize = aVRAMSize;
1877
1878 return S_OK;
1879}
1880
1881/** @todo this method should not be public */
1882HRESULT Machine::getMemoryBalloonSize(ULONG *aMemoryBalloonSize)
1883{
1884 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1885
1886 *aMemoryBalloonSize = mHWData->mMemoryBalloonSize;
1887
1888 return S_OK;
1889}
1890
1891/**
1892 * Set the memory balloon size.
1893 *
1894 * This method is also called from IGuest::COMSETTER(MemoryBalloonSize) so
1895 * we have to make sure that we never call IGuest from here.
1896 */
1897HRESULT Machine::setMemoryBalloonSize(ULONG aMemoryBalloonSize)
1898{
1899 /* This must match GMMR0Init; currently we only support memory ballooning on all 64-bit hosts except Mac OS X */
1900#if HC_ARCH_BITS == 64 && (defined(RT_OS_WINDOWS) || defined(RT_OS_SOLARIS) || defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD))
1901 /* check limits */
1902 if (aMemoryBalloonSize >= VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize))
1903 return setError(E_INVALIDARG,
1904 tr("Invalid memory balloon size: %lu MB (must be in range [%lu, %lu] MB)"),
1905 aMemoryBalloonSize, 0, VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize));
1906
1907 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1908
1909 i_setModified(IsModified_MachineData);
1910 mHWData.backup();
1911 mHWData->mMemoryBalloonSize = aMemoryBalloonSize;
1912
1913 return S_OK;
1914#else
1915 NOREF(aMemoryBalloonSize);
1916 return setError(E_NOTIMPL, tr("Memory ballooning is only supported on 64-bit hosts"));
1917#endif
1918}
1919
1920HRESULT Machine::getPageFusionEnabled(BOOL *aPageFusionEnabled)
1921{
1922 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1923
1924 *aPageFusionEnabled = mHWData->mPageFusionEnabled;
1925 return S_OK;
1926}
1927
1928HRESULT Machine::setPageFusionEnabled(BOOL aPageFusionEnabled)
1929{
1930#ifdef VBOX_WITH_PAGE_SHARING
1931 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1932
1933 /** @todo must support changes for running vms and keep this in sync with IGuest. */
1934 i_setModified(IsModified_MachineData);
1935 mHWData.backup();
1936 mHWData->mPageFusionEnabled = aPageFusionEnabled;
1937 return S_OK;
1938#else
1939 NOREF(aPageFusionEnabled);
1940 return setError(E_NOTIMPL, tr("Page fusion is only supported on 64-bit hosts"));
1941#endif
1942}
1943
1944HRESULT Machine::getAccelerate3DEnabled(BOOL *aAccelerate3DEnabled)
1945{
1946 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1947
1948 *aAccelerate3DEnabled = mHWData->mAccelerate3DEnabled;
1949
1950 return S_OK;
1951}
1952
1953HRESULT Machine::setAccelerate3DEnabled(BOOL aAccelerate3DEnabled)
1954{
1955 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1956
1957 HRESULT rc = i_checkStateDependency(MutableStateDep);
1958 if (FAILED(rc)) return rc;
1959
1960 /** @todo check validity! */
1961
1962 i_setModified(IsModified_MachineData);
1963 mHWData.backup();
1964 mHWData->mAccelerate3DEnabled = aAccelerate3DEnabled;
1965
1966 return S_OK;
1967}
1968
1969
1970HRESULT Machine::getAccelerate2DVideoEnabled(BOOL *aAccelerate2DVideoEnabled)
1971{
1972 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1973
1974 *aAccelerate2DVideoEnabled = mHWData->mAccelerate2DVideoEnabled;
1975
1976 return S_OK;
1977}
1978
1979HRESULT Machine::setAccelerate2DVideoEnabled(BOOL aAccelerate2DVideoEnabled)
1980{
1981 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1982
1983 HRESULT rc = i_checkStateDependency(MutableStateDep);
1984 if (FAILED(rc)) return rc;
1985
1986 /** @todo check validity! */
1987 i_setModified(IsModified_MachineData);
1988 mHWData.backup();
1989 mHWData->mAccelerate2DVideoEnabled = aAccelerate2DVideoEnabled;
1990
1991 return S_OK;
1992}
1993
1994HRESULT Machine::getMonitorCount(ULONG *aMonitorCount)
1995{
1996 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1997
1998 *aMonitorCount = mHWData->mMonitorCount;
1999
2000 return S_OK;
2001}
2002
2003HRESULT Machine::setMonitorCount(ULONG aMonitorCount)
2004{
2005 /* make sure monitor count is a sensible number */
2006 if (aMonitorCount < 1 || aMonitorCount > SchemaDefs::MaxGuestMonitors)
2007 return setError(E_INVALIDARG,
2008 tr("Invalid monitor count: %lu (must be in range [%lu, %lu])"),
2009 aMonitorCount, 1, SchemaDefs::MaxGuestMonitors);
2010
2011 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2012
2013 HRESULT rc = i_checkStateDependency(MutableStateDep);
2014 if (FAILED(rc)) return rc;
2015
2016 i_setModified(IsModified_MachineData);
2017 mHWData.backup();
2018 mHWData->mMonitorCount = aMonitorCount;
2019
2020 return S_OK;
2021}
2022
2023HRESULT Machine::getBIOSSettings(ComPtr<IBIOSSettings> &aBIOSSettings)
2024{
2025 /* mBIOSSettings is constant during life time, no need to lock */
2026 mBIOSSettings.queryInterfaceTo(aBIOSSettings.asOutParam());
2027
2028 return S_OK;
2029}
2030
2031HRESULT Machine::getCPUProperty(CPUPropertyType_T aProperty, BOOL *aValue)
2032{
2033 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2034
2035 switch (aProperty)
2036 {
2037 case CPUPropertyType_PAE:
2038 *aValue = mHWData->mPAEEnabled;
2039 break;
2040
2041 case CPUPropertyType_Synthetic:
2042 *aValue = mHWData->mSyntheticCpu;
2043 break;
2044
2045 case CPUPropertyType_LongMode:
2046 if (mHWData->mLongMode == settings::Hardware::LongMode_Enabled)
2047 *aValue = TRUE;
2048 else if (mHWData->mLongMode == settings::Hardware::LongMode_Disabled)
2049 *aValue = FALSE;
2050#if HC_ARCH_BITS == 64
2051 else
2052 *aValue = TRUE;
2053#else
2054 else
2055 {
2056 *aValue = FALSE;
2057
2058 ComPtr<IGuestOSType> ptrGuestOSType;
2059 HRESULT hrc2 = mParent->GetGuestOSType(Bstr(mUserData->s.strOsType).raw(), ptrGuestOSType.asOutParam());
2060 if (SUCCEEDED(hrc2))
2061 {
2062 BOOL fIs64Bit = FALSE;
2063 hrc2 = ptrGuestOSType->COMGETTER(Is64Bit)(&fIs64Bit); AssertComRC(hrc2);
2064 if (SUCCEEDED(hrc2) && fIs64Bit)
2065 {
2066 ComObjPtr<Host> ptrHost = mParent->i_host();
2067 alock.release();
2068
2069 hrc2 = ptrHost->GetProcessorFeature(ProcessorFeature_LongMode, aValue); AssertComRC(hrc2);
2070 if (FAILED(hrc2))
2071 *aValue = FALSE;
2072 }
2073 }
2074 }
2075#endif
2076 break;
2077
2078 case CPUPropertyType_TripleFaultReset:
2079 *aValue = mHWData->mTripleFaultReset;
2080 break;
2081
2082 default:
2083 return E_INVALIDARG;
2084 }
2085 return S_OK;
2086}
2087
2088HRESULT Machine::setCPUProperty(CPUPropertyType_T aProperty, BOOL aValue)
2089{
2090 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2091
2092 HRESULT rc = i_checkStateDependency(MutableStateDep);
2093 if (FAILED(rc)) return rc;
2094
2095 switch (aProperty)
2096 {
2097 case CPUPropertyType_PAE:
2098 i_setModified(IsModified_MachineData);
2099 mHWData.backup();
2100 mHWData->mPAEEnabled = !!aValue;
2101 break;
2102
2103 case CPUPropertyType_Synthetic:
2104 i_setModified(IsModified_MachineData);
2105 mHWData.backup();
2106 mHWData->mSyntheticCpu = !!aValue;
2107 break;
2108
2109 case CPUPropertyType_LongMode:
2110 i_setModified(IsModified_MachineData);
2111 mHWData.backup();
2112 mHWData->mLongMode = !aValue ? settings::Hardware::LongMode_Disabled : settings::Hardware::LongMode_Enabled;
2113 break;
2114
2115 case CPUPropertyType_TripleFaultReset:
2116 i_setModified(IsModified_MachineData);
2117 mHWData.backup();
2118 mHWData->mTripleFaultReset = !!aValue;
2119 break;
2120
2121 default:
2122 return E_INVALIDARG;
2123 }
2124 return S_OK;
2125}
2126
2127HRESULT Machine::getCPUIDLeaf(ULONG aId, ULONG *aValEax, ULONG *aValEbx, ULONG *aValEcx, ULONG *aValEdx)
2128{
2129 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2130
2131 switch(aId)
2132 {
2133 case 0x0:
2134 case 0x1:
2135 case 0x2:
2136 case 0x3:
2137 case 0x4:
2138 case 0x5:
2139 case 0x6:
2140 case 0x7:
2141 case 0x8:
2142 case 0x9:
2143 case 0xA:
2144 if (mHWData->mCpuIdStdLeafs[aId].ulId != aId)
2145 return E_INVALIDARG;
2146
2147 *aValEax = mHWData->mCpuIdStdLeafs[aId].ulEax;
2148 *aValEbx = mHWData->mCpuIdStdLeafs[aId].ulEbx;
2149 *aValEcx = mHWData->mCpuIdStdLeafs[aId].ulEcx;
2150 *aValEdx = mHWData->mCpuIdStdLeafs[aId].ulEdx;
2151 break;
2152
2153 case 0x80000000:
2154 case 0x80000001:
2155 case 0x80000002:
2156 case 0x80000003:
2157 case 0x80000004:
2158 case 0x80000005:
2159 case 0x80000006:
2160 case 0x80000007:
2161 case 0x80000008:
2162 case 0x80000009:
2163 case 0x8000000A:
2164 if (mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId != aId)
2165 return E_INVALIDARG;
2166
2167 *aValEax = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax;
2168 *aValEbx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx;
2169 *aValEcx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx;
2170 *aValEdx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx;
2171 break;
2172
2173 default:
2174 return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
2175 }
2176 return S_OK;
2177}
2178
2179
2180HRESULT Machine::setCPUIDLeaf(ULONG aId, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
2181{
2182 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2183
2184 HRESULT rc = i_checkStateDependency(MutableStateDep);
2185 if (FAILED(rc)) return rc;
2186
2187 switch(aId)
2188 {
2189 case 0x0:
2190 case 0x1:
2191 case 0x2:
2192 case 0x3:
2193 case 0x4:
2194 case 0x5:
2195 case 0x6:
2196 case 0x7:
2197 case 0x8:
2198 case 0x9:
2199 case 0xA:
2200 AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xB);
2201 AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
2202 i_setModified(IsModified_MachineData);
2203 mHWData.backup();
2204 mHWData->mCpuIdStdLeafs[aId].ulId = aId;
2205 mHWData->mCpuIdStdLeafs[aId].ulEax = aValEax;
2206 mHWData->mCpuIdStdLeafs[aId].ulEbx = aValEbx;
2207 mHWData->mCpuIdStdLeafs[aId].ulEcx = aValEcx;
2208 mHWData->mCpuIdStdLeafs[aId].ulEdx = aValEdx;
2209 break;
2210
2211 case 0x80000000:
2212 case 0x80000001:
2213 case 0x80000002:
2214 case 0x80000003:
2215 case 0x80000004:
2216 case 0x80000005:
2217 case 0x80000006:
2218 case 0x80000007:
2219 case 0x80000008:
2220 case 0x80000009:
2221 case 0x8000000A:
2222 AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xB);
2223 AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
2224 i_setModified(IsModified_MachineData);
2225 mHWData.backup();
2226 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId = aId;
2227 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax = aValEax;
2228 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx = aValEbx;
2229 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx = aValEcx;
2230 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx = aValEdx;
2231 break;
2232
2233 default:
2234 return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
2235 }
2236 return S_OK;
2237}
2238
2239HRESULT Machine::removeCPUIDLeaf(ULONG aId)
2240{
2241 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2242
2243 HRESULT rc = i_checkStateDependency(MutableStateDep);
2244 if (FAILED(rc)) return rc;
2245
2246 switch(aId)
2247 {
2248 case 0x0:
2249 case 0x1:
2250 case 0x2:
2251 case 0x3:
2252 case 0x4:
2253 case 0x5:
2254 case 0x6:
2255 case 0x7:
2256 case 0x8:
2257 case 0x9:
2258 case 0xA:
2259 AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xB);
2260 AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
2261 i_setModified(IsModified_MachineData);
2262 mHWData.backup();
2263 /* Invalidate leaf. */
2264 mHWData->mCpuIdStdLeafs[aId].ulId = UINT32_MAX;
2265 break;
2266
2267 case 0x80000000:
2268 case 0x80000001:
2269 case 0x80000002:
2270 case 0x80000003:
2271 case 0x80000004:
2272 case 0x80000005:
2273 case 0x80000006:
2274 case 0x80000007:
2275 case 0x80000008:
2276 case 0x80000009:
2277 case 0x8000000A:
2278 AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xB);
2279 AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
2280 i_setModified(IsModified_MachineData);
2281 mHWData.backup();
2282 /* Invalidate leaf. */
2283 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId = UINT32_MAX;
2284 break;
2285
2286 default:
2287 return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
2288 }
2289 return S_OK;
2290}
2291
2292HRESULT Machine::removeAllCPUIDLeaves()
2293{
2294 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2295
2296 HRESULT rc = i_checkStateDependency(MutableStateDep);
2297 if (FAILED(rc)) return rc;
2298
2299 i_setModified(IsModified_MachineData);
2300 mHWData.backup();
2301
2302 /* Invalidate all standard leafs. */
2303 for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mCpuIdStdLeafs); ++i)
2304 mHWData->mCpuIdStdLeafs[i].ulId = UINT32_MAX;
2305
2306 /* Invalidate all extended leafs. */
2307 for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mCpuIdExtLeafs); ++i)
2308 mHWData->mCpuIdExtLeafs[i].ulId = UINT32_MAX;
2309
2310 return S_OK;
2311}
2312HRESULT Machine::getHWVirtExProperty(HWVirtExPropertyType_T aProperty, BOOL *aValue)
2313{
2314 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2315
2316 switch(aProperty)
2317 {
2318 case HWVirtExPropertyType_Enabled:
2319 *aValue = mHWData->mHWVirtExEnabled;
2320 break;
2321
2322 case HWVirtExPropertyType_VPID:
2323 *aValue = mHWData->mHWVirtExVPIDEnabled;
2324 break;
2325
2326 case HWVirtExPropertyType_NestedPaging:
2327 *aValue = mHWData->mHWVirtExNestedPagingEnabled;
2328 break;
2329
2330 case HWVirtExPropertyType_UnrestrictedExecution:
2331 *aValue = mHWData->mHWVirtExUXEnabled;
2332 break;
2333
2334 case HWVirtExPropertyType_LargePages:
2335 *aValue = mHWData->mHWVirtExLargePagesEnabled;
2336#if defined(DEBUG_bird) && defined(RT_OS_LINUX) /* This feature is deadly here */
2337 *aValue = FALSE;
2338#endif
2339 break;
2340
2341 case HWVirtExPropertyType_Force:
2342 *aValue = mHWData->mHWVirtExForceEnabled;
2343 break;
2344
2345 default:
2346 return E_INVALIDARG;
2347 }
2348 return S_OK;
2349}
2350
2351HRESULT Machine::setHWVirtExProperty(HWVirtExPropertyType_T aProperty, BOOL aValue)
2352{
2353 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2354
2355 HRESULT rc = i_checkStateDependency(MutableStateDep);
2356 if (FAILED(rc)) return rc;
2357
2358 switch(aProperty)
2359 {
2360 case HWVirtExPropertyType_Enabled:
2361 i_setModified(IsModified_MachineData);
2362 mHWData.backup();
2363 mHWData->mHWVirtExEnabled = !!aValue;
2364 break;
2365
2366 case HWVirtExPropertyType_VPID:
2367 i_setModified(IsModified_MachineData);
2368 mHWData.backup();
2369 mHWData->mHWVirtExVPIDEnabled = !!aValue;
2370 break;
2371
2372 case HWVirtExPropertyType_NestedPaging:
2373 i_setModified(IsModified_MachineData);
2374 mHWData.backup();
2375 mHWData->mHWVirtExNestedPagingEnabled = !!aValue;
2376 break;
2377
2378 case HWVirtExPropertyType_UnrestrictedExecution:
2379 i_setModified(IsModified_MachineData);
2380 mHWData.backup();
2381 mHWData->mHWVirtExUXEnabled = !!aValue;
2382 break;
2383
2384 case HWVirtExPropertyType_LargePages:
2385 i_setModified(IsModified_MachineData);
2386 mHWData.backup();
2387 mHWData->mHWVirtExLargePagesEnabled = !!aValue;
2388 break;
2389
2390 case HWVirtExPropertyType_Force:
2391 i_setModified(IsModified_MachineData);
2392 mHWData.backup();
2393 mHWData->mHWVirtExForceEnabled = !!aValue;
2394 break;
2395
2396 default:
2397 return E_INVALIDARG;
2398 }
2399
2400 return S_OK;
2401}
2402
2403HRESULT Machine::getSnapshotFolder(com::Utf8Str &aSnapshotFolder)
2404{
2405 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2406
2407 i_calculateFullPath(mUserData->s.strSnapshotFolder, aSnapshotFolder);
2408
2409 return S_OK;
2410}
2411
2412HRESULT Machine::setSnapshotFolder(const com::Utf8Str &aSnapshotFolder)
2413{
2414 /* @todo (r=dmik):
2415 * 1. Allow to change the name of the snapshot folder containing snapshots
2416 * 2. Rename the folder on disk instead of just changing the property
2417 * value (to be smart and not to leave garbage). Note that it cannot be
2418 * done here because the change may be rolled back. Thus, the right
2419 * place is #saveSettings().
2420 */
2421
2422 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2423
2424 HRESULT rc = i_checkStateDependency(MutableStateDep);
2425 if (FAILED(rc)) return rc;
2426
2427 if (!mData->mCurrentSnapshot.isNull())
2428 return setError(E_FAIL,
2429 tr("The snapshot folder of a machine with snapshots cannot be changed (please delete all snapshots first)"));
2430
2431 Utf8Str strSnapshotFolder(aSnapshotFolder); // keep original
2432
2433 if (strSnapshotFolder.isEmpty())
2434 strSnapshotFolder = "Snapshots";
2435 int vrc = i_calculateFullPath(strSnapshotFolder,
2436 strSnapshotFolder);
2437 if (RT_FAILURE(vrc))
2438 return setError(E_FAIL,
2439 tr("Invalid snapshot folder '%s' (%Rrc)"),
2440 strSnapshotFolder.c_str(), vrc);
2441
2442 i_setModified(IsModified_MachineData);
2443 mUserData.backup();
2444
2445 i_copyPathRelativeToMachine(strSnapshotFolder, mUserData->s.strSnapshotFolder);
2446
2447 return S_OK;
2448}
2449
2450HRESULT Machine::getMediumAttachments(std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments)
2451{
2452 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2453
2454 aMediumAttachments.resize(mMediaData->mAttachments.size());
2455 size_t i = 0;
2456 for (MediaData::AttachmentList::iterator it = mMediaData->mAttachments.begin();
2457 it != mMediaData->mAttachments.end(); ++it, ++i)
2458 (*it).queryInterfaceTo(aMediumAttachments[i].asOutParam());
2459
2460 return S_OK;
2461}
2462
2463HRESULT Machine::getVRDEServer(ComPtr<IVRDEServer> &aVRDEServer)
2464{
2465 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2466
2467 Assert(!!mVRDEServer);
2468
2469 mVRDEServer.queryInterfaceTo(aVRDEServer.asOutParam());
2470
2471 return S_OK;
2472}
2473
2474HRESULT Machine::getAudioAdapter(ComPtr<IAudioAdapter> &aAudioAdapter)
2475{
2476 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2477
2478 mAudioAdapter.queryInterfaceTo(aAudioAdapter.asOutParam());
2479
2480 return S_OK;
2481}
2482
2483HRESULT Machine::getUSBControllers(std::vector<ComPtr<IUSBController> > &aUSBControllers)
2484{
2485#ifdef VBOX_WITH_VUSB
2486 clearError();
2487 MultiResult rc(S_OK);
2488
2489# ifdef VBOX_WITH_USB
2490 rc = mParent->i_host()->i_checkUSBProxyService();
2491 if (FAILED(rc)) return rc;
2492# endif
2493
2494 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2495
2496 USBControllerList data = *mUSBControllers.data();
2497 aUSBControllers.resize(data.size());
2498 size_t i = 0;
2499 for (USBControllerList::iterator it = data.begin(); it != data.end(); ++i, ++it)
2500 (*it).queryInterfaceTo(aUSBControllers[i].asOutParam());
2501
2502 return S_OK;
2503#else
2504 /* Note: The GUI depends on this method returning E_NOTIMPL with no
2505 * extended error info to indicate that USB is simply not available
2506 * (w/o treating it as a failure), for example, as in OSE */
2507 NOREF(aUSBControllers);
2508 ReturnComNotImplemented();
2509#endif /* VBOX_WITH_VUSB */
2510}
2511
2512HRESULT Machine::getUSBDeviceFilters(ComPtr<IUSBDeviceFilters> &aUSBDeviceFilters)
2513{
2514#ifdef VBOX_WITH_VUSB
2515 clearError();
2516 MultiResult rc(S_OK);
2517
2518# ifdef VBOX_WITH_USB
2519 rc = mParent->i_host()->i_checkUSBProxyService();
2520 if (FAILED(rc)) return rc;
2521# endif
2522
2523 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2524
2525 return rc = mUSBDeviceFilters.queryInterfaceTo(aUSBDeviceFilters.asOutParam());
2526#else
2527 /* Note: The GUI depends on this method returning E_NOTIMPL with no
2528 * extended error info to indicate that USB is simply not available
2529 * (w/o treating it as a failure), for example, as in OSE */
2530 NOREF(aUSBDeviceFilters);
2531 ReturnComNotImplemented();
2532#endif /* VBOX_WITH_VUSB */
2533}
2534
2535HRESULT Machine::getSettingsFilePath(com::Utf8Str &aSettingsFilePath)
2536{
2537 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2538
2539 aSettingsFilePath = mData->m_strConfigFileFull;
2540
2541 return S_OK;
2542}
2543
2544HRESULT Machine::getSettingsModified(BOOL *aSettingsModified)
2545{
2546 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2547
2548 HRESULT rc = i_checkStateDependency(MutableStateDep);
2549 if (FAILED(rc)) return rc;
2550
2551 if (!mData->pMachineConfigFile->fileExists())
2552 // this is a new machine, and no config file exists yet:
2553 *aSettingsModified = TRUE;
2554 else
2555 *aSettingsModified = (mData->flModifications != 0);
2556
2557 return S_OK;
2558}
2559
2560HRESULT Machine::getSessionState(SessionState_T *aSessionState)
2561{
2562
2563 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2564
2565 *aSessionState = mData->mSession.mState;
2566
2567 return S_OK;
2568}
2569
2570HRESULT Machine::getSessionType(com::Utf8Str &aSessionType)
2571{
2572 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2573
2574 aSessionType = mData->mSession.mType;
2575
2576 return S_OK;
2577}
2578
2579HRESULT Machine::getSessionPID(ULONG *aSessionPID)
2580{
2581 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2582
2583 *aSessionPID = mData->mSession.mPID;
2584
2585 return S_OK;
2586}
2587
2588HRESULT Machine::getState(MachineState_T *aState)
2589{
2590 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2591
2592 *aState = mData->mMachineState;
2593
2594 return S_OK;
2595}
2596
2597HRESULT Machine::getLastStateChange(LONG64 *aLastStateChange)
2598{
2599 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2600
2601 *aLastStateChange = RTTimeSpecGetMilli(&mData->mLastStateChange);
2602
2603 return S_OK;
2604}
2605
2606HRESULT Machine::getStateFilePath(com::Utf8Str &aStateFilePath)
2607{
2608 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2609
2610 aStateFilePath = mSSData->strStateFilePath;
2611
2612 return S_OK;
2613}
2614
2615HRESULT Machine::getLogFolder(com::Utf8Str &aLogFolder)
2616{
2617 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2618
2619 i_getLogFolder(aLogFolder);
2620
2621 return S_OK;
2622}
2623
2624HRESULT Machine::getCurrentSnapshot(ComPtr<ISnapshot> &aCurrentSnapshot)
2625{
2626 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2627
2628 mData->mCurrentSnapshot.queryInterfaceTo(aCurrentSnapshot.asOutParam());
2629
2630 return S_OK;
2631}
2632
2633HRESULT Machine::getSnapshotCount(ULONG *aSnapshotCount)
2634{
2635 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2636
2637 *aSnapshotCount = mData->mFirstSnapshot.isNull()
2638 ? 0
2639 : mData->mFirstSnapshot->i_getAllChildrenCount() + 1;
2640
2641 return S_OK;
2642}
2643
2644HRESULT Machine::getCurrentStateModified(BOOL *aCurrentStateModified)
2645{
2646 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2647
2648 /* Note: for machines with no snapshots, we always return FALSE
2649 * (mData->mCurrentStateModified will be TRUE in this case, for historical
2650 * reasons :) */
2651
2652 *aCurrentStateModified = mData->mFirstSnapshot.isNull()
2653 ? FALSE
2654 : mData->mCurrentStateModified;
2655
2656 return S_OK;
2657}
2658
2659HRESULT Machine::getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders)
2660{
2661 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2662
2663 aSharedFolders.resize(mHWData->mSharedFolders.size());
2664 size_t i = 0;
2665 for (std::list<ComObjPtr<SharedFolder> >::iterator it = mHWData->mSharedFolders.begin();
2666 it != mHWData->mSharedFolders.end(); ++i, ++it)
2667 (*it).queryInterfaceTo(aSharedFolders[i].asOutParam());
2668
2669 return S_OK;
2670}
2671
2672HRESULT Machine::getClipboardMode(ClipboardMode_T *aClipboardMode)
2673{
2674 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2675
2676 *aClipboardMode = mHWData->mClipboardMode;
2677
2678 return S_OK;
2679}
2680
2681HRESULT Machine::setClipboardMode(ClipboardMode_T aClipboardMode)
2682{
2683 HRESULT rc = S_OK;
2684
2685 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2686
2687 alock.release();
2688 rc = i_onClipboardModeChange(aClipboardMode);
2689 alock.acquire();
2690 if (FAILED(rc)) return rc;
2691
2692 i_setModified(IsModified_MachineData);
2693 mHWData.backup();
2694 mHWData->mClipboardMode = aClipboardMode;
2695
2696 /** Save settings if online - @todo why is this required? -- @bugref{6818} */
2697 if (Global::IsOnline(mData->mMachineState))
2698 i_saveSettings(NULL);
2699
2700 return S_OK;
2701}
2702
2703HRESULT Machine::getDnDMode(DnDMode_T *aDnDMode)
2704{
2705 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2706
2707 *aDnDMode = mHWData->mDnDMode;
2708
2709 return S_OK;
2710}
2711
2712HRESULT Machine::setDnDMode(DnDMode_T aDnDMode)
2713{
2714 HRESULT rc = S_OK;
2715
2716 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2717
2718 alock.release();
2719 rc = i_onDnDModeChange(aDnDMode);
2720
2721 alock.acquire();
2722 if (FAILED(rc)) return rc;
2723
2724 i_setModified(IsModified_MachineData);
2725 mHWData.backup();
2726 mHWData->mDnDMode = aDnDMode;
2727
2728 /** Save settings if online - @todo why is this required? -- @bugref{6818} */
2729 if (Global::IsOnline(mData->mMachineState))
2730 i_saveSettings(NULL);
2731
2732 return S_OK;
2733}
2734
2735HRESULT Machine::getGuestPropertyNotificationPatterns(com::Utf8Str &aGuestPropertyNotificationPatterns)
2736{
2737 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2738
2739 try
2740 {
2741 aGuestPropertyNotificationPatterns = mHWData->mGuestPropertyNotificationPatterns;
2742 }
2743 catch (...)
2744 {
2745 return VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
2746 }
2747
2748 return S_OK;
2749}
2750
2751HRESULT Machine::setGuestPropertyNotificationPatterns(const com::Utf8Str &aGuestPropertyNotificationPatterns)
2752{
2753 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2754
2755 HRESULT rc = i_checkStateDependency(MutableStateDep);
2756 if (FAILED(rc)) return rc;
2757
2758 i_setModified(IsModified_MachineData);
2759 mHWData.backup();
2760 mHWData->mGuestPropertyNotificationPatterns = aGuestPropertyNotificationPatterns;
2761 return rc;
2762}
2763
2764HRESULT Machine::getStorageControllers(std::vector<ComPtr<IStorageController> > &aStorageControllers)
2765{
2766 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2767 StorageControllerList data = *mStorageControllers.data();
2768 size_t i = 0;
2769 aStorageControllers.resize(data.size());
2770 for (StorageControllerList::iterator it = data.begin(); it != data.end(); ++it, ++i)
2771 (*it).queryInterfaceTo(aStorageControllers[i].asOutParam());
2772 return S_OK;
2773}
2774
2775HRESULT Machine::getTeleporterEnabled(BOOL *aEnabled)
2776{
2777 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2778
2779 *aEnabled = mUserData->s.fTeleporterEnabled;
2780
2781 return S_OK;
2782}
2783
2784HRESULT Machine::setTeleporterEnabled(BOOL aTeleporterEnabled)
2785{
2786 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2787
2788 /* Only allow it to be set to true when PoweredOff or Aborted.
2789 (Clearing it is always permitted.) */
2790 if ( aTeleporterEnabled
2791 && mData->mRegistered
2792 && ( !i_isSessionMachine()
2793 || ( mData->mMachineState != MachineState_PoweredOff
2794 && mData->mMachineState != MachineState_Teleported
2795 && mData->mMachineState != MachineState_Aborted
2796 )
2797 )
2798 )
2799 return setError(VBOX_E_INVALID_VM_STATE,
2800 tr("The machine is not powered off (state is %s)"),
2801 Global::stringifyMachineState(mData->mMachineState));
2802
2803 i_setModified(IsModified_MachineData);
2804 mUserData.backup();
2805 mUserData->s.fTeleporterEnabled = !! aTeleporterEnabled;
2806
2807 return S_OK;
2808}
2809
2810HRESULT Machine::getTeleporterPort(ULONG *aTeleporterPort)
2811{
2812 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2813
2814 *aTeleporterPort = (ULONG)mUserData->s.uTeleporterPort;
2815
2816 return S_OK;
2817}
2818
2819HRESULT Machine::setTeleporterPort(ULONG aTeleporterPort)
2820{
2821 if (aTeleporterPort >= _64K)
2822 return setError(E_INVALIDARG, tr("Invalid port number %d"), aTeleporterPort);
2823
2824 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2825
2826 HRESULT rc = i_checkStateDependency(MutableStateDep);
2827 if (FAILED(rc)) return rc;
2828
2829 i_setModified(IsModified_MachineData);
2830 mUserData.backup();
2831 mUserData->s.uTeleporterPort = (uint32_t)aTeleporterPort;
2832
2833 return S_OK;
2834}
2835
2836HRESULT Machine::getTeleporterAddress(com::Utf8Str &aTeleporterAddress)
2837{
2838 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2839
2840 aTeleporterAddress = mUserData->s.strTeleporterAddress;
2841
2842 return S_OK;
2843}
2844
2845HRESULT Machine::setTeleporterAddress(const com::Utf8Str &aTeleporterAddress)
2846{
2847 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2848
2849 HRESULT rc = i_checkStateDependency(MutableStateDep);
2850 if (FAILED(rc)) return rc;
2851
2852 i_setModified(IsModified_MachineData);
2853 mUserData.backup();
2854 mUserData->s.strTeleporterAddress = aTeleporterAddress;
2855
2856 return S_OK;
2857}
2858
2859HRESULT Machine::getTeleporterPassword(com::Utf8Str &aTeleporterPassword)
2860{
2861 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2862 aTeleporterPassword = mUserData->s.strTeleporterPassword;
2863
2864 return S_OK;
2865}
2866
2867HRESULT Machine::setTeleporterPassword(const com::Utf8Str &aTeleporterPassword)
2868{
2869 /*
2870 * Hash the password first.
2871 */
2872 com::Utf8Str aT = aTeleporterPassword;
2873
2874 if (!aT.isEmpty())
2875 {
2876 if (VBoxIsPasswordHashed(&aT))
2877 return setError(E_INVALIDARG, tr("Cannot set an already hashed password, only plain text password please"));
2878 VBoxHashPassword(&aT);
2879 }
2880
2881 /*
2882 * Do the update.
2883 */
2884 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2885 HRESULT hrc = i_checkStateDependency(MutableStateDep);
2886 if (SUCCEEDED(hrc))
2887 {
2888 i_setModified(IsModified_MachineData);
2889 mUserData.backup();
2890 mUserData->s.strTeleporterPassword = aT;
2891 }
2892
2893 return hrc;
2894}
2895
2896HRESULT Machine::getFaultToleranceState(FaultToleranceState_T *aFaultToleranceState)
2897{
2898 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2899
2900 *aFaultToleranceState = mUserData->s.enmFaultToleranceState;
2901 return S_OK;
2902}
2903
2904HRESULT Machine::setFaultToleranceState(FaultToleranceState_T aFaultToleranceState)
2905{
2906 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2907
2908 /* @todo deal with running state change. */
2909 HRESULT rc = i_checkStateDependency(MutableStateDep);
2910 if (FAILED(rc)) return rc;
2911
2912 i_setModified(IsModified_MachineData);
2913 mUserData.backup();
2914 mUserData->s.enmFaultToleranceState = aFaultToleranceState;
2915 return S_OK;
2916}
2917
2918HRESULT Machine::getFaultToleranceAddress(com::Utf8Str &aFaultToleranceAddress)
2919{
2920 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2921
2922 aFaultToleranceAddress = mUserData->s.strFaultToleranceAddress;
2923 return S_OK;
2924}
2925
2926HRESULT Machine::setFaultToleranceAddress(const com::Utf8Str &aFaultToleranceAddress)
2927{
2928 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2929
2930 /* @todo deal with running state change. */
2931 HRESULT rc = i_checkStateDependency(MutableStateDep);
2932 if (FAILED(rc)) return rc;
2933
2934 i_setModified(IsModified_MachineData);
2935 mUserData.backup();
2936 mUserData->s.strFaultToleranceAddress = aFaultToleranceAddress;
2937 return S_OK;
2938}
2939
2940HRESULT Machine::getFaultTolerancePort(ULONG *aFaultTolerancePort)
2941{
2942 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2943
2944 *aFaultTolerancePort = mUserData->s.uFaultTolerancePort;
2945 return S_OK;
2946}
2947
2948HRESULT Machine::setFaultTolerancePort(ULONG aFaultTolerancePort)
2949{
2950 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2951
2952 /* @todo deal with running state change. */
2953 HRESULT rc = i_checkStateDependency(MutableStateDep);
2954 if (FAILED(rc)) return rc;
2955
2956 i_setModified(IsModified_MachineData);
2957 mUserData.backup();
2958 mUserData->s.uFaultTolerancePort = aFaultTolerancePort;
2959 return S_OK;
2960}
2961
2962HRESULT Machine::getFaultTolerancePassword(com::Utf8Str &aFaultTolerancePassword)
2963{
2964 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2965
2966 aFaultTolerancePassword = mUserData->s.strFaultTolerancePassword;
2967
2968 return S_OK;
2969}
2970
2971HRESULT Machine::setFaultTolerancePassword(const com::Utf8Str &aFaultTolerancePassword)
2972{
2973 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2974
2975 /* @todo deal with running state change. */
2976 HRESULT rc = i_checkStateDependency(MutableStateDep);
2977 if (FAILED(rc)) return rc;
2978
2979 i_setModified(IsModified_MachineData);
2980 mUserData.backup();
2981 mUserData->s.strFaultTolerancePassword = aFaultTolerancePassword;
2982
2983 return S_OK;
2984}
2985
2986HRESULT Machine::getFaultToleranceSyncInterval(ULONG *aFaultToleranceSyncInterval)
2987{
2988 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2989
2990 *aFaultToleranceSyncInterval = mUserData->s.uFaultToleranceInterval;
2991 return S_OK;
2992}
2993
2994HRESULT Machine::setFaultToleranceSyncInterval(ULONG aFaultToleranceSyncInterval)
2995{
2996 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2997
2998 /* @todo deal with running state change. */
2999 HRESULT rc = i_checkStateDependency(MutableStateDep);
3000 if (FAILED(rc)) return rc;
3001
3002 i_setModified(IsModified_MachineData);
3003 mUserData.backup();
3004 mUserData->s.uFaultToleranceInterval = aFaultToleranceSyncInterval;
3005 return S_OK;
3006}
3007
3008HRESULT Machine::getRTCUseUTC(BOOL *aRTCUseUTC)
3009{
3010 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3011
3012 *aRTCUseUTC = mUserData->s.fRTCUseUTC;
3013
3014 return S_OK;
3015}
3016
3017HRESULT Machine::setRTCUseUTC(BOOL aRTCUseUTC)
3018{
3019 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3020
3021 /* Only allow it to be set to true when PoweredOff or Aborted.
3022 (Clearing it is always permitted.) */
3023 if ( aRTCUseUTC
3024 && mData->mRegistered
3025 && ( !i_isSessionMachine()
3026 || ( mData->mMachineState != MachineState_PoweredOff
3027 && mData->mMachineState != MachineState_Teleported
3028 && mData->mMachineState != MachineState_Aborted
3029 )
3030 )
3031 )
3032 return setError(VBOX_E_INVALID_VM_STATE,
3033 tr("The machine is not powered off (state is %s)"),
3034 Global::stringifyMachineState(mData->mMachineState));
3035
3036 i_setModified(IsModified_MachineData);
3037 mUserData.backup();
3038 mUserData->s.fRTCUseUTC = !!aRTCUseUTC;
3039
3040 return S_OK;
3041}
3042
3043HRESULT Machine::getIOCacheEnabled(BOOL *aIOCacheEnabled)
3044{
3045 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3046
3047 *aIOCacheEnabled = mHWData->mIOCacheEnabled;
3048
3049 return S_OK;
3050}
3051
3052HRESULT Machine::setIOCacheEnabled(BOOL aIOCacheEnabled)
3053{
3054 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3055
3056 HRESULT rc = i_checkStateDependency(MutableStateDep);
3057 if (FAILED(rc)) return rc;
3058
3059 i_setModified(IsModified_MachineData);
3060 mHWData.backup();
3061 mHWData->mIOCacheEnabled = aIOCacheEnabled;
3062
3063 return S_OK;
3064}
3065
3066HRESULT Machine::getIOCacheSize(ULONG *aIOCacheSize)
3067{
3068 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3069
3070 *aIOCacheSize = mHWData->mIOCacheSize;
3071
3072 return S_OK;
3073}
3074
3075HRESULT Machine::setIOCacheSize(ULONG aIOCacheSize)
3076{
3077 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3078
3079 HRESULT rc = i_checkStateDependency(MutableStateDep);
3080 if (FAILED(rc)) return rc;
3081
3082 i_setModified(IsModified_MachineData);
3083 mHWData.backup();
3084 mHWData->mIOCacheSize = aIOCacheSize;
3085
3086 return S_OK;
3087}
3088
3089
3090/**
3091 * @note Locks objects!
3092 */
3093HRESULT Machine::lockMachine(const ComPtr<ISession> &aSession,
3094 LockType_T aLockType)
3095
3096{
3097 /* check the session state */
3098 SessionState_T state;
3099 HRESULT rc = aSession->COMGETTER(State)(&state);
3100 if (FAILED(rc)) return rc;
3101
3102 if (state != SessionState_Unlocked)
3103 return setError(VBOX_E_INVALID_OBJECT_STATE,
3104 tr("The given session is busy"));
3105
3106 // get the client's IInternalSessionControl interface
3107 ComPtr<IInternalSessionControl> pSessionControl = aSession;
3108 ComAssertMsgRet(!!pSessionControl, ("No IInternalSessionControl interface"),
3109 E_INVALIDARG);
3110
3111 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3112
3113 if (!mData->mRegistered)
3114 return setError(E_UNEXPECTED,
3115 tr("The machine '%s' is not registered"),
3116 mUserData->s.strName.c_str());
3117
3118 LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
3119
3120 SessionState_T oldState = mData->mSession.mState;
3121 /* Hack: in case the session is closing and there is a progress object
3122 * which allows waiting for the session to be closed, take the opportunity
3123 * and do a limited wait (max. 1 second). This helps a lot when the system
3124 * is busy and thus session closing can take a little while. */
3125 if ( mData->mSession.mState == SessionState_Unlocking
3126 && mData->mSession.mProgress)
3127 {
3128 alock.release();
3129 mData->mSession.mProgress->WaitForCompletion(1000);
3130 alock.acquire();
3131 LogFlowThisFunc(("after waiting: mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
3132 }
3133
3134 // try again now
3135 if ( (mData->mSession.mState == SessionState_Locked) // machine is write-locked already
3136 // (i.e. session machine exists)
3137 && (aLockType == LockType_Shared) // caller wants a shared link to the
3138 // existing session that holds the write lock:
3139 )
3140 {
3141 // OK, share the session... we are now dealing with three processes:
3142 // 1) VBoxSVC (where this code runs);
3143 // 2) process C: the caller's client process (who wants a shared session);
3144 // 3) process W: the process which already holds the write lock on the machine (write-locking session)
3145
3146 // copy pointers to W (the write-locking session) before leaving lock (these must not be NULL)
3147 ComPtr<IInternalSessionControl> pSessionW = mData->mSession.mDirectControl;
3148 ComAssertRet(!pSessionW.isNull(), E_FAIL);
3149 ComObjPtr<SessionMachine> pSessionMachine = mData->mSession.mMachine;
3150 AssertReturn(!pSessionMachine.isNull(), E_FAIL);
3151
3152 /*
3153 * Release the lock before calling the client process. It's safe here
3154 * since the only thing to do after we get the lock again is to add
3155 * the remote control to the list (which doesn't directly influence
3156 * anything).
3157 */
3158 alock.release();
3159
3160 // get the console of the session holding the write lock (this is a remote call)
3161 ComPtr<IConsole> pConsoleW;
3162 LogFlowThisFunc(("Calling GetRemoteConsole()...\n"));
3163 rc = pSessionW->GetRemoteConsole(pConsoleW.asOutParam());
3164 LogFlowThisFunc(("GetRemoteConsole() returned %08X\n", rc));
3165 if (FAILED(rc))
3166 // the failure may occur w/o any error info (from RPC), so provide one
3167 return setError(VBOX_E_VM_ERROR,
3168 tr("Failed to get a console object from the direct session (%Rhrc)"), rc);
3169
3170 ComAssertRet(!pConsoleW.isNull(), E_FAIL);
3171
3172 // share the session machine and W's console with the caller's session
3173 LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
3174 rc = pSessionControl->AssignRemoteMachine(pSessionMachine, pConsoleW);
3175 LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
3176
3177 if (FAILED(rc))
3178 // the failure may occur w/o any error info (from RPC), so provide one
3179 return setError(VBOX_E_VM_ERROR,
3180 tr("Failed to assign the machine to the session (%Rhrc)"), rc);
3181 alock.acquire();
3182
3183 // need to revalidate the state after acquiring the lock again
3184 if (mData->mSession.mState != SessionState_Locked)
3185 {
3186 pSessionControl->Uninitialize();
3187 return setError(VBOX_E_INVALID_SESSION_STATE,
3188 tr("The machine '%s' was unlocked unexpectedly while attempting to share its session"),
3189 mUserData->s.strName.c_str());
3190 }
3191
3192 // add the caller's session to the list
3193 mData->mSession.mRemoteControls.push_back(pSessionControl);
3194 }
3195 else if ( mData->mSession.mState == SessionState_Locked
3196 || mData->mSession.mState == SessionState_Unlocking
3197 )
3198 {
3199 // sharing not permitted, or machine still unlocking:
3200 return setError(VBOX_E_INVALID_OBJECT_STATE,
3201 tr("The machine '%s' is already locked for a session (or being unlocked)"),
3202 mUserData->s.strName.c_str());
3203 }
3204 else
3205 {
3206 // machine is not locked: then write-lock the machine (create the session machine)
3207
3208 // must not be busy
3209 AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
3210
3211 // get the caller's session PID
3212 RTPROCESS pid = NIL_RTPROCESS;
3213 AssertCompile(sizeof(ULONG) == sizeof(RTPROCESS));
3214 pSessionControl->GetPID((ULONG*)&pid);
3215 Assert(pid != NIL_RTPROCESS);
3216
3217 bool fLaunchingVMProcess = (mData->mSession.mState == SessionState_Spawning);
3218
3219 if (fLaunchingVMProcess)
3220 {
3221 if (mData->mSession.mPID == NIL_RTPROCESS)
3222 {
3223 // two or more clients racing for a lock, the one which set the
3224 // session state to Spawning will win, the others will get an
3225 // error as we can't decide here if waiting a little would help
3226 // (only for shared locks this would avoid an error)
3227 return setError(VBOX_E_INVALID_OBJECT_STATE,
3228 tr("The machine '%s' already has a lock request pending"),
3229 mUserData->s.strName.c_str());
3230 }
3231
3232 // this machine is awaiting for a spawning session to be opened:
3233 // then the calling process must be the one that got started by
3234 // LaunchVMProcess()
3235
3236 LogFlowThisFunc(("mSession.mPID=%d(0x%x)\n", mData->mSession.mPID, mData->mSession.mPID));
3237 LogFlowThisFunc(("session.pid=%d(0x%x)\n", pid, pid));
3238
3239#if defined(VBOX_WITH_HARDENING) && defined(RT_OS_WINDOWS)
3240 /* Hardened windows builds spawns three processes when a VM is
3241 launched, the 3rd one is the one that will end up here. */
3242 RTPROCESS ppid;
3243 int rc = RTProcQueryParent(pid, &ppid);
3244 if (RT_SUCCESS(rc))
3245 rc = RTProcQueryParent(ppid, &ppid);
3246 if ( (RT_SUCCESS(rc) && mData->mSession.mPID == ppid)
3247 || rc == VERR_ACCESS_DENIED)
3248 {
3249 LogFlowThisFunc(("mSession.mPID => %d(%#x) - windows hardening stub\n", mData->mSession.mPID, pid));
3250 mData->mSession.mPID = pid;
3251 }
3252#endif
3253
3254 if (mData->mSession.mPID != pid)
3255 return setError(E_ACCESSDENIED,
3256 tr("An unexpected process (PID=0x%08X) has tried to lock the "
3257 "machine '%s', while only the process started by LaunchVMProcess (PID=0x%08X) is allowed"),
3258 pid, mUserData->s.strName.c_str(), mData->mSession.mPID);
3259 }
3260
3261 // create the mutable SessionMachine from the current machine
3262 ComObjPtr<SessionMachine> sessionMachine;
3263 sessionMachine.createObject();
3264 rc = sessionMachine->init(this);
3265 AssertComRC(rc);
3266
3267 /* NOTE: doing return from this function after this point but
3268 * before the end is forbidden since it may call SessionMachine::uninit()
3269 * (through the ComObjPtr's destructor) which requests the VirtualBox write
3270 * lock while still holding the Machine lock in alock so that a deadlock
3271 * is possible due to the wrong lock order. */
3272
3273 if (SUCCEEDED(rc))
3274 {
3275 /*
3276 * Set the session state to Spawning to protect against subsequent
3277 * attempts to open a session and to unregister the machine after
3278 * we release the lock.
3279 */
3280 SessionState_T origState = mData->mSession.mState;
3281 mData->mSession.mState = SessionState_Spawning;
3282
3283#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
3284 /* Get the client token ID to be passed to the client process */
3285 Utf8Str strTokenId;
3286 sessionMachine->i_getTokenId(strTokenId);
3287 Assert(!strTokenId.isEmpty());
3288#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3289 /* Get the client token to be passed to the client process */
3290 ComPtr<IToken> pToken(sessionMachine->i_getToken());
3291 /* The token is now "owned" by pToken, fix refcount */
3292 if (!pToken.isNull())
3293 pToken->Release();
3294#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3295
3296 /*
3297 * Release the lock before calling the client process -- it will call
3298 * Machine/SessionMachine methods. Releasing the lock here is quite safe
3299 * because the state is Spawning, so that LaunchVMProcess() and
3300 * LockMachine() calls will fail. This method, called before we
3301 * acquire the lock again, will fail because of the wrong PID.
3302 *
3303 * Note that mData->mSession.mRemoteControls accessed outside
3304 * the lock may not be modified when state is Spawning, so it's safe.
3305 */
3306 alock.release();
3307
3308 LogFlowThisFunc(("Calling AssignMachine()...\n"));
3309#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
3310 rc = pSessionControl->AssignMachine(sessionMachine, aLockType, Bstr(strTokenId).raw());
3311#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3312 rc = pSessionControl->AssignMachine(sessionMachine, aLockType, pToken);
3313 /* Now the token is owned by the client process. */
3314 pToken.setNull();
3315#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
3316 LogFlowThisFunc(("AssignMachine() returned %08X\n", rc));
3317
3318 /* The failure may occur w/o any error info (from RPC), so provide one */
3319 if (FAILED(rc))
3320 setError(VBOX_E_VM_ERROR,
3321 tr("Failed to assign the machine to the session (%Rhrc)"), rc);
3322
3323 if ( SUCCEEDED(rc)
3324 && fLaunchingVMProcess
3325 )
3326 {
3327 /* complete the remote session initialization */
3328
3329 /* get the console from the direct session */
3330 ComPtr<IConsole> console;
3331 rc = pSessionControl->GetRemoteConsole(console.asOutParam());
3332 ComAssertComRC(rc);
3333
3334 if (SUCCEEDED(rc) && !console)
3335 {
3336 ComAssert(!!console);
3337 rc = E_FAIL;
3338 }
3339
3340 /* assign machine & console to the remote session */
3341 if (SUCCEEDED(rc))
3342 {
3343 /*
3344 * after LaunchVMProcess(), the first and the only
3345 * entry in remoteControls is that remote session
3346 */
3347 LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
3348 rc = mData->mSession.mRemoteControls.front()->AssignRemoteMachine(sessionMachine, console);
3349 LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
3350
3351 /* The failure may occur w/o any error info (from RPC), so provide one */
3352 if (FAILED(rc))
3353 setError(VBOX_E_VM_ERROR,
3354 tr("Failed to assign the machine to the remote session (%Rhrc)"), rc);
3355 }
3356
3357 if (FAILED(rc))
3358 pSessionControl->Uninitialize();
3359 }
3360
3361 /* acquire the lock again */
3362 alock.acquire();
3363
3364 /* Restore the session state */
3365 mData->mSession.mState = origState;
3366 }
3367
3368 // finalize spawning anyway (this is why we don't return on errors above)
3369 if (fLaunchingVMProcess)
3370 {
3371 /* Note that the progress object is finalized later */
3372 /** @todo Consider checking mData->mSession.mProgress for cancellation
3373 * around here. */
3374
3375 /* We don't reset mSession.mPID here because it is necessary for
3376 * SessionMachine::uninit() to reap the child process later. */
3377
3378 if (FAILED(rc))
3379 {
3380 /* Close the remote session, remove the remote control from the list
3381 * and reset session state to Closed (@note keep the code in sync
3382 * with the relevant part in checkForSpawnFailure()). */
3383
3384 Assert(mData->mSession.mRemoteControls.size() == 1);
3385 if (mData->mSession.mRemoteControls.size() == 1)
3386 {
3387 ErrorInfoKeeper eik;
3388 mData->mSession.mRemoteControls.front()->Uninitialize();
3389 }
3390
3391 mData->mSession.mRemoteControls.clear();
3392 mData->mSession.mState = SessionState_Unlocked;
3393 }
3394 }
3395 else
3396 {
3397 /* memorize PID of the directly opened session */
3398 if (SUCCEEDED(rc))
3399 mData->mSession.mPID = pid;
3400 }
3401
3402 if (SUCCEEDED(rc))
3403 {
3404 /* memorize the direct session control and cache IUnknown for it */
3405 mData->mSession.mDirectControl = pSessionControl;
3406 mData->mSession.mState = SessionState_Locked;
3407 /* associate the SessionMachine with this Machine */
3408 mData->mSession.mMachine = sessionMachine;
3409
3410 /* request an IUnknown pointer early from the remote party for later
3411 * identity checks (it will be internally cached within mDirectControl
3412 * at least on XPCOM) */
3413 ComPtr<IUnknown> unk = mData->mSession.mDirectControl;
3414 NOREF(unk);
3415 }
3416
3417 /* Release the lock since SessionMachine::uninit() locks VirtualBox which
3418 * would break the lock order */
3419 alock.release();
3420
3421 /* uninitialize the created session machine on failure */
3422 if (FAILED(rc))
3423 sessionMachine->uninit();
3424
3425 }
3426
3427 if (SUCCEEDED(rc))
3428 {
3429 /*
3430 * tell the client watcher thread to update the set of
3431 * machines that have open sessions
3432 */
3433 mParent->i_updateClientWatcher();
3434
3435 if (oldState != SessionState_Locked)
3436 /* fire an event */
3437 mParent->i_onSessionStateChange(i_getId(), SessionState_Locked);
3438 }
3439
3440 return rc;
3441}
3442
3443/**
3444 * @note Locks objects!
3445 */
3446HRESULT Machine::launchVMProcess(const ComPtr<ISession> &aSession,
3447 const com::Utf8Str &aType,
3448 const com::Utf8Str &aEnvironment,
3449 ComPtr<IProgress> &aProgress)
3450{
3451 Utf8Str strFrontend(aType);
3452 Utf8Str strEnvironment(aEnvironment);
3453 /* "emergencystop" doesn't need the session, so skip the checks/interface
3454 * retrieval. This code doesn't quite fit in here, but introducing a
3455 * special API method would be even more effort, and would require explicit
3456 * support by every API client. It's better to hide the feature a bit. */
3457 if (strFrontend != "emergencystop")
3458 CheckComArgNotNull(aSession);
3459
3460 HRESULT rc = S_OK;
3461 if (strFrontend.isEmpty())
3462 {
3463 Bstr bstrFrontend;
3464 rc = COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
3465 if (FAILED(rc))
3466 return rc;
3467 strFrontend = bstrFrontend;
3468 if (strFrontend.isEmpty())
3469 {
3470 ComPtr<ISystemProperties> systemProperties;
3471 rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
3472 if (FAILED(rc))
3473 return rc;
3474 rc = systemProperties->COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
3475 if (FAILED(rc))
3476 return rc;
3477 strFrontend = bstrFrontend;
3478 }
3479 /* paranoia - emergencystop is not a valid default */
3480 if (strFrontend == "emergencystop")
3481 strFrontend = Utf8Str::Empty;
3482 }
3483 /* default frontend: Qt GUI */
3484 if (strFrontend.isEmpty())
3485 strFrontend = "GUI/Qt";
3486
3487 if (strFrontend != "emergencystop")
3488 {
3489 /* check the session state */
3490 SessionState_T state;
3491 rc = aSession->COMGETTER(State)(&state);
3492 if (FAILED(rc))
3493 return rc;
3494
3495 if (state != SessionState_Unlocked)
3496 return setError(VBOX_E_INVALID_OBJECT_STATE,
3497 tr("The given session is busy"));
3498
3499 /* get the IInternalSessionControl interface */
3500 ComPtr<IInternalSessionControl> control(aSession);
3501 ComAssertMsgRet(!control.isNull(),
3502 ("No IInternalSessionControl interface"),
3503 E_INVALIDARG);
3504
3505 /* get the teleporter enable state for the progress object init. */
3506 BOOL fTeleporterEnabled;
3507 rc = COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
3508 if (FAILED(rc))
3509 return rc;
3510
3511 /* create a progress object */
3512 ComObjPtr<ProgressProxy> progress;
3513 progress.createObject();
3514 rc = progress->init(mParent,
3515 static_cast<IMachine*>(this),
3516 Bstr(tr("Starting VM")).raw(),
3517 TRUE /* aCancelable */,
3518 fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
3519 BstrFmt(tr("Creating process for virtual machine \"%s\" (%s)"),
3520 mUserData->s.strName.c_str(), strFrontend.c_str()).raw(),
3521 2 /* uFirstOperationWeight */,
3522 fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
3523
3524 if (SUCCEEDED(rc))
3525 {
3526 rc = i_launchVMProcess(control, strFrontend, strEnvironment, progress);
3527 if (SUCCEEDED(rc))
3528 {
3529 progress.queryInterfaceTo(aProgress.asOutParam());
3530
3531 /* signal the client watcher thread */
3532 mParent->i_updateClientWatcher();
3533
3534 /* fire an event */
3535 mParent->i_onSessionStateChange(i_getId(), SessionState_Spawning);
3536 }
3537 }
3538 }
3539 else
3540 {
3541 /* no progress object - either instant success or failure */
3542 aProgress = NULL;
3543
3544 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3545
3546 if (mData->mSession.mState != SessionState_Locked)
3547 return setError(VBOX_E_INVALID_OBJECT_STATE,
3548 tr("The machine '%s' is not locked by a session"),
3549 mUserData->s.strName.c_str());
3550
3551 /* must have a VM process associated - do not kill normal API clients
3552 * with an open session */
3553 if (!Global::IsOnline(mData->mMachineState))
3554 return setError(VBOX_E_INVALID_OBJECT_STATE,
3555 tr("The machine '%s' does not have a VM process"),
3556 mUserData->s.strName.c_str());
3557
3558 /* forcibly terminate the VM process */
3559 if (mData->mSession.mPID != NIL_RTPROCESS)
3560 RTProcTerminate(mData->mSession.mPID);
3561
3562 /* signal the client watcher thread, as most likely the client has
3563 * been terminated */
3564 mParent->i_updateClientWatcher();
3565 }
3566
3567 return rc;
3568}
3569
3570HRESULT Machine::setBootOrder(ULONG aPosition, DeviceType_T aDevice)
3571{
3572 if (aPosition < 1 || aPosition > SchemaDefs::MaxBootPosition)
3573 return setError(E_INVALIDARG,
3574 tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3575 aPosition, SchemaDefs::MaxBootPosition);
3576
3577 if (aDevice == DeviceType_USB)
3578 return setError(E_NOTIMPL,
3579 tr("Booting from USB device is currently not supported"));
3580
3581 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3582
3583 HRESULT rc = i_checkStateDependency(MutableStateDep);
3584 if (FAILED(rc)) return rc;
3585
3586 i_setModified(IsModified_MachineData);
3587 mHWData.backup();
3588 mHWData->mBootOrder[aPosition - 1] = aDevice;
3589
3590 return S_OK;
3591}
3592
3593HRESULT Machine::getBootOrder(ULONG aPosition, DeviceType_T *aDevice)
3594{
3595 if (aPosition < 1 || aPosition > SchemaDefs::MaxBootPosition)
3596 return setError(E_INVALIDARG,
3597 tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3598 aPosition, SchemaDefs::MaxBootPosition);
3599
3600 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3601
3602 *aDevice = mHWData->mBootOrder[aPosition - 1];
3603
3604 return S_OK;
3605}
3606
3607HRESULT Machine::attachDevice(const com::Utf8Str &aName,
3608 LONG aControllerPort,
3609 LONG aDevice,
3610 DeviceType_T aType,
3611 const ComPtr<IMedium> &aMedium)
3612{
3613 IMedium *aM = aMedium;
3614 LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d aType=%d aMedium=%p\n",
3615 aName.c_str(), aControllerPort, aDevice, aType, aM));
3616
3617 // request the host lock first, since might be calling Host methods for getting host drives;
3618 // next, protect the media tree all the while we're in here, as well as our member variables
3619 AutoMultiWriteLock2 alock(mParent->i_host(), this COMMA_LOCKVAL_SRC_POS);
3620 AutoWriteLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
3621
3622 HRESULT rc = i_checkStateDependency(MutableStateDep);
3623 if (FAILED(rc)) return rc;
3624
3625 /// @todo NEWMEDIA implicit machine registration
3626 if (!mData->mRegistered)
3627 return setError(VBOX_E_INVALID_OBJECT_STATE,
3628 tr("Cannot attach storage devices to an unregistered machine"));
3629
3630 AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3631
3632 /* Check for an existing controller. */
3633 ComObjPtr<StorageController> ctl;
3634 rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
3635 if (FAILED(rc)) return rc;
3636
3637 StorageControllerType_T ctrlType;
3638 rc = ctl->COMGETTER(ControllerType)(&ctrlType);
3639 if (FAILED(rc))
3640 return setError(E_FAIL,
3641 tr("Could not get type of controller '%s'"),
3642 aName.c_str());
3643
3644 bool fSilent = false;
3645 Utf8Str strReconfig;
3646
3647 /* Check whether the flag to allow silent storage attachment reconfiguration is set. */
3648 strReconfig = i_getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
3649 if ( mData->mMachineState == MachineState_Paused
3650 && strReconfig == "1")
3651 fSilent = true;
3652
3653 /* Check that the controller can do hotplugging if we detach the device while the VM is running. */
3654 bool fHotplug = false;
3655 if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
3656 fHotplug = true;
3657
3658 if (fHotplug && !i_isControllerHotplugCapable(ctrlType))
3659 return setError(VBOX_E_INVALID_VM_STATE,
3660 tr("Controller '%s' does not support hotplugging"),
3661 aName.c_str());
3662
3663 // check that the port and device are not out of range
3664 rc = ctl->i_checkPortAndDeviceValid(aControllerPort, aDevice);
3665 if (FAILED(rc)) return rc;
3666
3667 /* check if the device slot is already busy */
3668 MediumAttachment *pAttachTemp;
3669 if ((pAttachTemp = i_findAttachment(mMediaData->mAttachments,
3670 Bstr(aName).raw(),
3671 aControllerPort,
3672 aDevice)))
3673 {
3674 Medium *pMedium = pAttachTemp->i_getMedium();
3675 if (pMedium)
3676 {
3677 AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
3678 return setError(VBOX_E_OBJECT_IN_USE,
3679 tr("Medium '%s' is already attached to port %d, device %d of controller '%s' of this virtual machine"),
3680 pMedium->i_getLocationFull().c_str(),
3681 aControllerPort,
3682 aDevice,
3683 aName.c_str());
3684 }
3685 else
3686 return setError(VBOX_E_OBJECT_IN_USE,
3687 tr("Device is already attached to port %d, device %d of controller '%s' of this virtual machine"),
3688 aControllerPort, aDevice, aName.c_str());
3689 }
3690
3691 ComObjPtr<Medium> medium = static_cast<Medium*>(aM);
3692 if (aMedium && medium.isNull())
3693 return setError(E_INVALIDARG, "The given medium pointer is invalid");
3694
3695 AutoCaller mediumCaller(medium);
3696 if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3697
3698 AutoWriteLock mediumLock(medium COMMA_LOCKVAL_SRC_POS);
3699
3700 if ( (pAttachTemp = i_findAttachment(mMediaData->mAttachments, medium))
3701 && !medium.isNull()
3702 )
3703 return setError(VBOX_E_OBJECT_IN_USE,
3704 tr("Medium '%s' is already attached to this virtual machine"),
3705 medium->i_getLocationFull().c_str());
3706
3707 if (!medium.isNull())
3708 {
3709 MediumType_T mtype = medium->i_getType();
3710 // MediumType_Readonly is also new, but only applies to DVDs and floppies.
3711 // For DVDs it's not written to the config file, so needs no global config
3712 // version bump. For floppies it's a new attribute "type", which is ignored
3713 // by older VirtualBox version, so needs no global config version bump either.
3714 // For hard disks this type is not accepted.
3715 if (mtype == MediumType_MultiAttach)
3716 {
3717 // This type is new with VirtualBox 4.0 and therefore requires settings
3718 // version 1.11 in the settings backend. Unfortunately it is not enough to do
3719 // the usual routine in MachineConfigFile::bumpSettingsVersionIfNeeded() for
3720 // two reasons: The medium type is a property of the media registry tree, which
3721 // can reside in the global config file (for pre-4.0 media); we would therefore
3722 // possibly need to bump the global config version. We don't want to do that though
3723 // because that might make downgrading to pre-4.0 impossible.
3724 // As a result, we can only use these two new types if the medium is NOT in the
3725 // global registry:
3726 const Guid &uuidGlobalRegistry = mParent->i_getGlobalRegistryId();
3727 if ( medium->i_isInRegistry(uuidGlobalRegistry)
3728 || !mData->pMachineConfigFile->canHaveOwnMediaRegistry()
3729 )
3730 return setError(VBOX_E_INVALID_OBJECT_STATE,
3731 tr("Cannot attach medium '%s': the media type 'MultiAttach' can only be attached "
3732 "to machines that were created with VirtualBox 4.0 or later"),
3733 medium->i_getLocationFull().c_str());
3734 }
3735 }
3736
3737 bool fIndirect = false;
3738 if (!medium.isNull())
3739 fIndirect = medium->i_isReadOnly();
3740 bool associate = true;
3741
3742 do
3743 {
3744 if ( aType == DeviceType_HardDisk
3745 && mMediaData.isBackedUp())
3746 {
3747 const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
3748
3749 /* check if the medium was attached to the VM before we started
3750 * changing attachments in which case the attachment just needs to
3751 * be restored */
3752 if ((pAttachTemp = i_findAttachment(oldAtts, medium)))
3753 {
3754 AssertReturn(!fIndirect, E_FAIL);
3755
3756 /* see if it's the same bus/channel/device */
3757 if (pAttachTemp->i_matches(Bstr(aName).raw(), aControllerPort, aDevice))
3758 {
3759 /* the simplest case: restore the whole attachment
3760 * and return, nothing else to do */
3761 mMediaData->mAttachments.push_back(pAttachTemp);
3762
3763 /* Reattach the medium to the VM. */
3764 if (fHotplug || fSilent)
3765 {
3766 mediumLock.release();
3767 treeLock.release();
3768 alock.release();
3769
3770 MediumLockList *pMediumLockList(new MediumLockList());
3771
3772 rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
3773 true /* fMediumLockWrite */,
3774 NULL,
3775 *pMediumLockList);
3776 alock.acquire();
3777 if (FAILED(rc))
3778 delete pMediumLockList;
3779 else
3780 {
3781 mData->mSession.mLockedMedia.Unlock();
3782 alock.release();
3783 rc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
3784 mData->mSession.mLockedMedia.Lock();
3785 alock.acquire();
3786 }
3787 alock.release();
3788
3789 if (SUCCEEDED(rc))
3790 {
3791 rc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
3792 /* Remove lock list in case of error. */
3793 if (FAILED(rc))
3794 {
3795 mData->mSession.mLockedMedia.Unlock();
3796 mData->mSession.mLockedMedia.Remove(pAttachTemp);
3797 mData->mSession.mLockedMedia.Lock();
3798 }
3799 }
3800 }
3801
3802 return S_OK;
3803 }
3804
3805 /* bus/channel/device differ; we need a new attachment object,
3806 * but don't try to associate it again */
3807 associate = false;
3808 break;
3809 }
3810 }
3811
3812 /* go further only if the attachment is to be indirect */
3813 if (!fIndirect)
3814 break;
3815
3816 /* perform the so called smart attachment logic for indirect
3817 * attachments. Note that smart attachment is only applicable to base
3818 * hard disks. */
3819
3820 if (medium->i_getParent().isNull())
3821 {
3822 /* first, investigate the backup copy of the current hard disk
3823 * attachments to make it possible to re-attach existing diffs to
3824 * another device slot w/o losing their contents */
3825 if (mMediaData.isBackedUp())
3826 {
3827 const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
3828
3829 MediaData::AttachmentList::const_iterator foundIt = oldAtts.end();
3830 uint32_t foundLevel = 0;
3831
3832 for (MediaData::AttachmentList::const_iterator it = oldAtts.begin(); it != oldAtts.end(); ++it)
3833 {
3834 uint32_t level = 0;
3835 MediumAttachment *pAttach = *it;
3836 ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
3837 Assert(!pMedium.isNull() || pAttach->i_getType() != DeviceType_HardDisk);
3838 if (pMedium.isNull())
3839 continue;
3840
3841 if (pMedium->i_getBase(&level) == medium)
3842 {
3843 /* skip the hard disk if its currently attached (we
3844 * cannot attach the same hard disk twice) */
3845 if (i_findAttachment(mMediaData->mAttachments,
3846 pMedium))
3847 continue;
3848
3849 /* matched device, channel and bus (i.e. attached to the
3850 * same place) will win and immediately stop the search;
3851 * otherwise the attachment that has the youngest
3852 * descendant of medium will be used
3853 */
3854 if (pAttach->i_matches(Bstr(aName).raw(), aControllerPort, aDevice))
3855 {
3856 /* the simplest case: restore the whole attachment
3857 * and return, nothing else to do */
3858 mMediaData->mAttachments.push_back(*it);
3859
3860 /* Reattach the medium to the VM. */
3861 if (fHotplug || fSilent)
3862 {
3863 mediumLock.release();
3864 treeLock.release();
3865 alock.release();
3866
3867 MediumLockList *pMediumLockList(new MediumLockList());
3868
3869 rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
3870 true /* fMediumLockWrite */,
3871 NULL,
3872 *pMediumLockList);
3873 alock.acquire();
3874 if (FAILED(rc))
3875 delete pMediumLockList;
3876 else
3877 {
3878 mData->mSession.mLockedMedia.Unlock();
3879 alock.release();
3880 rc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
3881 mData->mSession.mLockedMedia.Lock();
3882 alock.acquire();
3883 }
3884 alock.release();
3885
3886 if (SUCCEEDED(rc))
3887 {
3888 rc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
3889 /* Remove lock list in case of error. */
3890 if (FAILED(rc))
3891 {
3892 mData->mSession.mLockedMedia.Unlock();
3893 mData->mSession.mLockedMedia.Remove(pAttachTemp);
3894 mData->mSession.mLockedMedia.Lock();
3895 }
3896 }
3897 }
3898
3899 return S_OK;
3900 }
3901 else if ( foundIt == oldAtts.end()
3902 || level > foundLevel /* prefer younger */
3903 )
3904 {
3905 foundIt = it;
3906 foundLevel = level;
3907 }
3908 }
3909 }
3910
3911 if (foundIt != oldAtts.end())
3912 {
3913 /* use the previously attached hard disk */
3914 medium = (*foundIt)->i_getMedium();
3915 mediumCaller.attach(medium);
3916 if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3917 mediumLock.attach(medium);
3918 /* not implicit, doesn't require association with this VM */
3919 fIndirect = false;
3920 associate = false;
3921 /* go right to the MediumAttachment creation */
3922 break;
3923 }
3924 }
3925
3926 /* must give up the medium lock and medium tree lock as below we
3927 * go over snapshots, which needs a lock with higher lock order. */
3928 mediumLock.release();
3929 treeLock.release();
3930
3931 /* then, search through snapshots for the best diff in the given
3932 * hard disk's chain to base the new diff on */
3933
3934 ComObjPtr<Medium> base;
3935 ComObjPtr<Snapshot> snap = mData->mCurrentSnapshot;
3936 while (snap)
3937 {
3938 AutoReadLock snapLock(snap COMMA_LOCKVAL_SRC_POS);
3939
3940 const MediaData::AttachmentList &snapAtts = snap->i_getSnapshotMachine()->mMediaData->mAttachments;
3941
3942 MediumAttachment *pAttachFound = NULL;
3943 uint32_t foundLevel = 0;
3944
3945 for (MediaData::AttachmentList::const_iterator it = snapAtts.begin(); it != snapAtts.end(); ++it)
3946 {
3947 MediumAttachment *pAttach = *it;
3948 ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
3949 Assert(!pMedium.isNull() || pAttach->i_getType() != DeviceType_HardDisk);
3950 if (pMedium.isNull())
3951 continue;
3952
3953 uint32_t level = 0;
3954 if (pMedium->i_getBase(&level) == medium)
3955 {
3956 /* matched device, channel and bus (i.e. attached to the
3957 * same place) will win and immediately stop the search;
3958 * otherwise the attachment that has the youngest
3959 * descendant of medium will be used
3960 */
3961 if ( pAttach->i_getDevice() == aDevice
3962 && pAttach->i_getPort() == aControllerPort
3963 && pAttach->i_getControllerName() == aName
3964 )
3965 {
3966 pAttachFound = pAttach;
3967 break;
3968 }
3969 else if ( !pAttachFound
3970 || level > foundLevel /* prefer younger */
3971 )
3972 {
3973 pAttachFound = pAttach;
3974 foundLevel = level;
3975 }
3976 }
3977 }
3978
3979 if (pAttachFound)
3980 {
3981 base = pAttachFound->i_getMedium();
3982 break;
3983 }
3984
3985 snap = snap->i_getParent();
3986 }
3987
3988 /* re-lock medium tree and the medium, as we need it below */
3989 treeLock.acquire();
3990 mediumLock.acquire();
3991
3992 /* found a suitable diff, use it as a base */
3993 if (!base.isNull())
3994 {
3995 medium = base;
3996 mediumCaller.attach(medium);
3997 if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3998 mediumLock.attach(medium);
3999 }
4000 }
4001
4002 Utf8Str strFullSnapshotFolder;
4003 i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
4004
4005 ComObjPtr<Medium> diff;
4006 diff.createObject();
4007 // store this diff in the same registry as the parent
4008 Guid uuidRegistryParent;
4009 if (!medium->i_getFirstRegistryMachineId(uuidRegistryParent))
4010 {
4011 // parent image has no registry: this can happen if we're attaching a new immutable
4012 // image that has not yet been attached (medium then points to the base and we're
4013 // creating the diff image for the immutable, and the parent is not yet registered);
4014 // put the parent in the machine registry then
4015 mediumLock.release();
4016 treeLock.release();
4017 alock.release();
4018 i_addMediumToRegistry(medium);
4019 alock.acquire();
4020 treeLock.acquire();
4021 mediumLock.acquire();
4022 medium->i_getFirstRegistryMachineId(uuidRegistryParent);
4023 }
4024 rc = diff->init(mParent,
4025 medium->i_getPreferredDiffFormat(),
4026 strFullSnapshotFolder.append(RTPATH_SLASH_STR),
4027 uuidRegistryParent);
4028 if (FAILED(rc)) return rc;
4029
4030 /* Apply the normal locking logic to the entire chain. */
4031 MediumLockList *pMediumLockList(new MediumLockList());
4032 mediumLock.release();
4033 treeLock.release();
4034 rc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
4035 true /* fMediumLockWrite */,
4036 medium,
4037 *pMediumLockList);
4038 treeLock.acquire();
4039 mediumLock.acquire();
4040 if (SUCCEEDED(rc))
4041 {
4042 mediumLock.release();
4043 treeLock.release();
4044 rc = pMediumLockList->Lock();
4045 treeLock.acquire();
4046 mediumLock.acquire();
4047 if (FAILED(rc))
4048 setError(rc,
4049 tr("Could not lock medium when creating diff '%s'"),
4050 diff->i_getLocationFull().c_str());
4051 else
4052 {
4053 /* will release the lock before the potentially lengthy
4054 * operation, so protect with the special state */
4055 MachineState_T oldState = mData->mMachineState;
4056 i_setMachineState(MachineState_SettingUp);
4057
4058 mediumLock.release();
4059 treeLock.release();
4060 alock.release();
4061
4062 rc = medium->i_createDiffStorage(diff,
4063 MediumVariant_Standard,
4064 pMediumLockList,
4065 NULL /* aProgress */,
4066 true /* aWait */);
4067
4068 alock.acquire();
4069 treeLock.acquire();
4070 mediumLock.acquire();
4071
4072 i_setMachineState(oldState);
4073 }
4074 }
4075
4076 /* Unlock the media and free the associated memory. */
4077 delete pMediumLockList;
4078
4079 if (FAILED(rc)) return rc;
4080
4081 /* use the created diff for the actual attachment */
4082 medium = diff;
4083 mediumCaller.attach(medium);
4084 if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
4085 mediumLock.attach(medium);
4086 }
4087 while (0);
4088
4089 ComObjPtr<MediumAttachment> attachment;
4090 attachment.createObject();
4091 rc = attachment->init(this,
4092 medium,
4093 aName,
4094 aControllerPort,
4095 aDevice,
4096 aType,
4097 fIndirect,
4098 false /* fPassthrough */,
4099 false /* fTempEject */,
4100 false /* fNonRotational */,
4101 false /* fDiscard */,
4102 fHotplug /* fHotPluggable */,
4103 Utf8Str::Empty);
4104 if (FAILED(rc)) return rc;
4105
4106 if (associate && !medium.isNull())
4107 {
4108 // as the last step, associate the medium to the VM
4109 rc = medium->i_addBackReference(mData->mUuid);
4110 // here we can fail because of Deleting, or being in process of creating a Diff
4111 if (FAILED(rc)) return rc;
4112
4113 mediumLock.release();
4114 treeLock.release();
4115 alock.release();
4116 i_addMediumToRegistry(medium);
4117 alock.acquire();
4118 treeLock.acquire();
4119 mediumLock.acquire();
4120 }
4121
4122 /* success: finally remember the attachment */
4123 i_setModified(IsModified_Storage);
4124 mMediaData.backup();
4125 mMediaData->mAttachments.push_back(attachment);
4126
4127 mediumLock.release();
4128 treeLock.release();
4129 alock.release();
4130
4131 if (fHotplug || fSilent)
4132 {
4133 if (!medium.isNull())
4134 {
4135 MediumLockList *pMediumLockList(new MediumLockList());
4136
4137 rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
4138 true /* fMediumLockWrite */,
4139 NULL,
4140 *pMediumLockList);
4141 alock.acquire();
4142 if (FAILED(rc))
4143 delete pMediumLockList;
4144 else
4145 {
4146 mData->mSession.mLockedMedia.Unlock();
4147 alock.release();
4148 rc = mData->mSession.mLockedMedia.Insert(attachment, pMediumLockList);
4149 mData->mSession.mLockedMedia.Lock();
4150 alock.acquire();
4151 }
4152 alock.release();
4153 }
4154
4155 if (SUCCEEDED(rc))
4156 {
4157 rc = i_onStorageDeviceChange(attachment, FALSE /* aRemove */, fSilent);
4158 /* Remove lock list in case of error. */
4159 if (FAILED(rc))
4160 {
4161 mData->mSession.mLockedMedia.Unlock();
4162 mData->mSession.mLockedMedia.Remove(attachment);
4163 mData->mSession.mLockedMedia.Lock();
4164 }
4165 }
4166 }
4167
4168 mParent->i_saveModifiedRegistries();
4169
4170 return rc;
4171}
4172
4173HRESULT Machine::detachDevice(const com::Utf8Str &aName, LONG aControllerPort,
4174 LONG aDevice)
4175{
4176 LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d\n",
4177 aName.c_str(), aControllerPort, aDevice));
4178
4179 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4180
4181 HRESULT rc = i_checkStateDependency(MutableStateDep);
4182 if (FAILED(rc)) return rc;
4183
4184 AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4185
4186 /* Check for an existing controller. */
4187 ComObjPtr<StorageController> ctl;
4188 rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
4189 if (FAILED(rc)) return rc;
4190
4191 StorageControllerType_T ctrlType;
4192 rc = ctl->COMGETTER(ControllerType)(&ctrlType);
4193 if (FAILED(rc))
4194 return setError(E_FAIL,
4195 tr("Could not get type of controller '%s'"),
4196 aName.c_str());
4197
4198 bool fSilent = false;
4199 Utf8Str strReconfig;
4200
4201 /* Check whether the flag to allow silent storage attachment reconfiguration is set. */
4202 strReconfig = i_getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
4203 if ( mData->mMachineState == MachineState_Paused
4204 && strReconfig == "1")
4205 fSilent = true;
4206
4207 /* Check that the controller can do hotplugging if we detach the device while the VM is running. */
4208 bool fHotplug = false;
4209 if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
4210 fHotplug = true;
4211
4212 if (fHotplug && !i_isControllerHotplugCapable(ctrlType))
4213 return setError(VBOX_E_INVALID_VM_STATE,
4214 tr("Controller '%s' does not support hotplugging"),
4215 aName.c_str());
4216
4217 MediumAttachment *pAttach = i_findAttachment(mMediaData->mAttachments,
4218 Bstr(aName).raw(),
4219 aControllerPort,
4220 aDevice);
4221 if (!pAttach)
4222 return setError(VBOX_E_OBJECT_NOT_FOUND,
4223 tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4224 aDevice, aControllerPort, aName.c_str());
4225
4226 if (fHotplug && !pAttach->i_getHotPluggable())
4227 return setError(VBOX_E_NOT_SUPPORTED,
4228 tr("The device slot %d on port %d of controller '%s' does not support hotplugging"),
4229 aDevice, aControllerPort, aName.c_str());
4230
4231 /*
4232 * The VM has to detach the device before we delete any implicit diffs.
4233 * If this fails we can roll back without loosing data.
4234 */
4235 if (fHotplug || fSilent)
4236 {
4237 alock.release();
4238 rc = i_onStorageDeviceChange(pAttach, TRUE /* aRemove */, fSilent);
4239 alock.acquire();
4240 }
4241 if (FAILED(rc)) return rc;
4242
4243 /* If we are here everything went well and we can delete the implicit now. */
4244 rc = i_detachDevice(pAttach, alock, NULL /* pSnapshot */);
4245
4246 alock.release();
4247
4248 mParent->i_saveModifiedRegistries();
4249
4250 return rc;
4251}
4252
4253HRESULT Machine::passthroughDevice(const com::Utf8Str &aName, LONG aControllerPort,
4254 LONG aDevice, BOOL aPassthrough)
4255{
4256 LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aPassthrough=%d\n",
4257 aName.c_str(), aControllerPort, aDevice, aPassthrough));
4258
4259 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4260
4261 HRESULT rc = i_checkStateDependency(MutableStateDep);
4262 if (FAILED(rc)) return rc;
4263
4264 AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4265
4266 if (Global::IsOnlineOrTransient(mData->mMachineState))
4267 return setError(VBOX_E_INVALID_VM_STATE,
4268 tr("Invalid machine state: %s"),
4269 Global::stringifyMachineState(mData->mMachineState));
4270
4271 MediumAttachment *pAttach = i_findAttachment(mMediaData->mAttachments,
4272 Bstr(aName).raw(),
4273 aControllerPort,
4274 aDevice);
4275 if (!pAttach)
4276 return setError(VBOX_E_OBJECT_NOT_FOUND,
4277 tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4278 aDevice, aControllerPort, aName.c_str());
4279
4280
4281 i_setModified(IsModified_Storage);
4282 mMediaData.backup();
4283
4284 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4285
4286 if (pAttach->i_getType() != DeviceType_DVD)
4287 return setError(E_INVALIDARG,
4288 tr("Setting passthrough rejected as the device attached to device slot %d on port %d of controller '%s' is not a DVD"),
4289 aDevice, aControllerPort, aName.c_str());
4290 pAttach->i_updatePassthrough(!!aPassthrough);
4291
4292 return S_OK;
4293}
4294
4295HRESULT Machine::temporaryEjectDevice(const com::Utf8Str &aName, LONG aControllerPort,
4296 LONG aDevice, BOOL aTemporaryEject)
4297{
4298
4299 LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aTemporaryEject=%d\n",
4300 aName.c_str(), aControllerPort, aDevice, aTemporaryEject));
4301
4302 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4303
4304 HRESULT rc = i_checkStateDependency(MutableStateDep);
4305 if (FAILED(rc)) return rc;
4306
4307 MediumAttachment *pAttach = i_findAttachment(mMediaData->mAttachments,
4308 Bstr(aName).raw(),
4309 aControllerPort,
4310 aDevice);
4311 if (!pAttach)
4312 return setError(VBOX_E_OBJECT_NOT_FOUND,
4313 tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4314 aDevice, aControllerPort, aName.c_str());
4315
4316
4317 i_setModified(IsModified_Storage);
4318 mMediaData.backup();
4319
4320 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4321
4322 if (pAttach->i_getType() != DeviceType_DVD)
4323 return setError(E_INVALIDARG,
4324 tr("Setting temporary eject flag rejected as the device attached to device slot %d on port %d of controller '%s' is not a DVD"),
4325 aDevice, aControllerPort, aName.c_str());
4326 pAttach->i_updateTempEject(!!aTemporaryEject);
4327
4328 return S_OK;
4329}
4330
4331HRESULT Machine::nonRotationalDevice(const com::Utf8Str &aName, LONG aControllerPort,
4332 LONG aDevice, BOOL aNonRotational)
4333{
4334
4335 LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aNonRotational=%d\n",
4336 aName.c_str(), aControllerPort, aDevice, aNonRotational));
4337
4338 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4339
4340 HRESULT rc = i_checkStateDependency(MutableStateDep);
4341 if (FAILED(rc)) return rc;
4342
4343 AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4344
4345 if (Global::IsOnlineOrTransient(mData->mMachineState))
4346 return setError(VBOX_E_INVALID_VM_STATE,
4347 tr("Invalid machine state: %s"),
4348 Global::stringifyMachineState(mData->mMachineState));
4349
4350 MediumAttachment *pAttach = i_findAttachment(mMediaData->mAttachments,
4351 Bstr(aName).raw(),
4352 aControllerPort,
4353 aDevice);
4354 if (!pAttach)
4355 return setError(VBOX_E_OBJECT_NOT_FOUND,
4356 tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4357 aDevice, aControllerPort, aName.c_str());
4358
4359
4360 i_setModified(IsModified_Storage);
4361 mMediaData.backup();
4362
4363 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4364
4365 if (pAttach->i_getType() != DeviceType_HardDisk)
4366 return setError(E_INVALIDARG,
4367 tr("Setting the non-rotational medium flag rejected as the device attached to device slot %d on port %d of controller '%s' is not a hard disk"),
4368 aDevice, aControllerPort, aName.c_str());
4369 pAttach->i_updateNonRotational(!!aNonRotational);
4370
4371 return S_OK;
4372}
4373
4374HRESULT Machine::setAutoDiscardForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4375 LONG aDevice, BOOL aDiscard)
4376{
4377
4378 LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aDiscard=%d\n",
4379 aName.c_str(), aControllerPort, aDevice, aDiscard));
4380
4381 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4382
4383 HRESULT rc = i_checkStateDependency(MutableStateDep);
4384 if (FAILED(rc)) return rc;
4385
4386 AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4387
4388 if (Global::IsOnlineOrTransient(mData->mMachineState))
4389 return setError(VBOX_E_INVALID_VM_STATE,
4390 tr("Invalid machine state: %s"),
4391 Global::stringifyMachineState(mData->mMachineState));
4392
4393 MediumAttachment *pAttach = i_findAttachment(mMediaData->mAttachments,
4394 Bstr(aName).raw(),
4395 aControllerPort,
4396 aDevice);
4397 if (!pAttach)
4398 return setError(VBOX_E_OBJECT_NOT_FOUND,
4399 tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4400 aDevice, aControllerPort, aName.c_str());
4401
4402
4403 i_setModified(IsModified_Storage);
4404 mMediaData.backup();
4405
4406 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4407
4408 if (pAttach->i_getType() != DeviceType_HardDisk)
4409 return setError(E_INVALIDARG,
4410 tr("Setting the discard medium flag rejected as the device attached to device slot %d on port %d of controller '%s' is not a hard disk"),
4411 aDevice, aControllerPort, aName.c_str());
4412 pAttach->i_updateDiscard(!!aDiscard);
4413
4414 return S_OK;
4415}
4416
4417HRESULT Machine::setHotPluggableForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4418 LONG aDevice, BOOL aHotPluggable)
4419{
4420 LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aHotPluggable=%d\n",
4421 aName.c_str(), aControllerPort, aDevice, aHotPluggable));
4422
4423 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4424
4425 HRESULT rc = i_checkStateDependency(MutableStateDep);
4426 if (FAILED(rc)) return rc;
4427
4428 AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4429
4430 if (Global::IsOnlineOrTransient(mData->mMachineState))
4431 return setError(VBOX_E_INVALID_VM_STATE,
4432 tr("Invalid machine state: %s"),
4433 Global::stringifyMachineState(mData->mMachineState));
4434
4435 MediumAttachment *pAttach = i_findAttachment(mMediaData->mAttachments,
4436 Bstr(aName).raw(),
4437 aControllerPort,
4438 aDevice);
4439 if (!pAttach)
4440 return setError(VBOX_E_OBJECT_NOT_FOUND,
4441 tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4442 aDevice, aControllerPort, aName.c_str());
4443
4444 /* Check for an existing controller. */
4445 ComObjPtr<StorageController> ctl;
4446 rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
4447 if (FAILED(rc)) return rc;
4448
4449 StorageControllerType_T ctrlType;
4450 rc = ctl->COMGETTER(ControllerType)(&ctrlType);
4451 if (FAILED(rc))
4452 return setError(E_FAIL,
4453 tr("Could not get type of controller '%s'"),
4454 aName.c_str());
4455
4456 if (!i_isControllerHotplugCapable(ctrlType))
4457 return setError(VBOX_E_NOT_SUPPORTED,
4458 tr("Controller '%s' does not support changing the hot-pluggable device flag"),
4459 aName.c_str());
4460
4461 i_setModified(IsModified_Storage);
4462 mMediaData.backup();
4463
4464 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4465
4466 if (pAttach->i_getType() == DeviceType_Floppy)
4467 return setError(E_INVALIDARG,
4468 tr("Setting the hot-pluggable device flag rejected as the device attached to device slot %d on port %d of controller '%s' is a floppy drive"),
4469 aDevice, aControllerPort, aName.c_str());
4470 pAttach->i_updateHotPluggable(!!aHotPluggable);
4471
4472 return S_OK;
4473}
4474
4475HRESULT Machine::setNoBandwidthGroupForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4476 LONG aDevice)
4477{
4478 int rc = S_OK;
4479 LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4480 aName.c_str(), aControllerPort, aDevice));
4481
4482 rc = setBandwidthGroupForDevice(aName, aControllerPort, aDevice, NULL);
4483
4484 return rc;
4485}
4486
4487HRESULT Machine::setBandwidthGroupForDevice(const com::Utf8Str &aName, LONG aControllerPort,
4488 LONG aDevice, const ComPtr<IBandwidthGroup> &aBandwidthGroup)
4489{
4490 LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4491 aName.c_str(), aControllerPort, aDevice));
4492
4493 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4494
4495 HRESULT rc = i_checkStateDependency(MutableStateDep);
4496 if (FAILED(rc)) return rc;
4497
4498 AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
4499
4500 if (Global::IsOnlineOrTransient(mData->mMachineState))
4501 return setError(VBOX_E_INVALID_VM_STATE,
4502 tr("Invalid machine state: %s"),
4503 Global::stringifyMachineState(mData->mMachineState));
4504
4505 MediumAttachment *pAttach = i_findAttachment(mMediaData->mAttachments,
4506 Bstr(aName).raw(),
4507 aControllerPort,
4508 aDevice);
4509 if (!pAttach)
4510 return setError(VBOX_E_OBJECT_NOT_FOUND,
4511 tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4512 aDevice, aControllerPort, aName.c_str());
4513
4514
4515 i_setModified(IsModified_Storage);
4516 mMediaData.backup();
4517
4518 IBandwidthGroup *iB = aBandwidthGroup;
4519 ComObjPtr<BandwidthGroup> group = static_cast<BandwidthGroup*>(iB);
4520 if (aBandwidthGroup && group.isNull())
4521 return setError(E_INVALIDARG, "The given bandwidth group pointer is invalid");
4522
4523 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4524
4525 const Utf8Str strBandwidthGroupOld = pAttach->i_getBandwidthGroup();
4526 if (strBandwidthGroupOld.isNotEmpty())
4527 {
4528 /* Get the bandwidth group object and release it - this must not fail. */
4529 ComObjPtr<BandwidthGroup> pBandwidthGroupOld;
4530 rc = i_getBandwidthGroup(strBandwidthGroupOld, pBandwidthGroupOld, false);
4531 Assert(SUCCEEDED(rc));
4532
4533 pBandwidthGroupOld->i_release();
4534 pAttach->i_updateBandwidthGroup(Utf8Str::Empty);
4535 }
4536
4537 if (!group.isNull())
4538 {
4539 group->i_reference();
4540 pAttach->i_updateBandwidthGroup(group->i_getName());
4541 }
4542
4543 return S_OK;
4544}
4545
4546HRESULT Machine::attachDeviceWithoutMedium(const com::Utf8Str &aName,
4547 LONG aControllerPort,
4548 LONG aDevice,
4549 DeviceType_T aType)
4550{
4551 HRESULT rc = S_OK;
4552
4553 LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aType=%d aMedium=%p\n",
4554 aName.c_str(), aControllerPort, aDevice, aType));
4555
4556 rc = AttachDevice(Bstr(aName).raw(), aControllerPort, aDevice, aType, NULL);
4557
4558 return rc;
4559}
4560
4561
4562HRESULT Machine::unmountMedium(const com::Utf8Str &aName,
4563 LONG aControllerPort,
4564 LONG aDevice,
4565 BOOL aForce)
4566{
4567 int rc = S_OK;
4568 LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d",
4569 aName.c_str(), aControllerPort, aForce));
4570
4571 rc = mountMedium(aName, aControllerPort, aDevice, NULL, aForce);
4572
4573 return rc;
4574}
4575
4576HRESULT Machine::mountMedium(const com::Utf8Str &aName,
4577 LONG aControllerPort,
4578 LONG aDevice,
4579 const ComPtr<IMedium> &aMedium,
4580 BOOL aForce)
4581{
4582 int rc = S_OK;
4583 LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d aForce=%d\n",
4584 aName.c_str(), aControllerPort, aDevice, aForce));
4585
4586 // request the host lock first, since might be calling Host methods for getting host drives;
4587 // next, protect the media tree all the while we're in here, as well as our member variables
4588 AutoMultiWriteLock3 multiLock(mParent->i_host()->lockHandle(),
4589 this->lockHandle(),
4590 &mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
4591
4592 ComObjPtr<MediumAttachment> pAttach = i_findAttachment(mMediaData->mAttachments,
4593 Bstr(aName).raw(),
4594 aControllerPort,
4595 aDevice);
4596 if (pAttach.isNull())
4597 return setError(VBOX_E_OBJECT_NOT_FOUND,
4598 tr("No drive attached to device slot %d on port %d of controller '%s'"),
4599 aDevice, aControllerPort, aName.c_str());
4600
4601 /* Remember previously mounted medium. The medium before taking the
4602 * backup is not necessarily the same thing. */
4603 ComObjPtr<Medium> oldmedium;
4604 oldmedium = pAttach->i_getMedium();
4605
4606 IMedium *iM = aMedium;
4607 ComObjPtr<Medium> pMedium = static_cast<Medium*>(iM);
4608 if (aMedium && pMedium.isNull())
4609 return setError(E_INVALIDARG, "The given medium pointer is invalid");
4610
4611 AutoCaller mediumCaller(pMedium);
4612 if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
4613
4614 AutoWriteLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
4615 if (pMedium)
4616 {
4617 DeviceType_T mediumType = pAttach->i_getType();
4618 switch (mediumType)
4619 {
4620 case DeviceType_DVD:
4621 case DeviceType_Floppy:
4622 break;
4623
4624 default:
4625 return setError(VBOX_E_INVALID_OBJECT_STATE,
4626 tr("The device at port %d, device %d of controller '%s' of this virtual machine is not removeable"),
4627 aControllerPort,
4628 aDevice,
4629 aName.c_str());
4630 }
4631 }
4632
4633 i_setModified(IsModified_Storage);
4634 mMediaData.backup();
4635
4636 {
4637 // The backup operation makes the pAttach reference point to the
4638 // old settings. Re-get the correct reference.
4639 pAttach = i_findAttachment(mMediaData->mAttachments,
4640 Bstr(aName).raw(),
4641 aControllerPort,
4642 aDevice);
4643 if (!oldmedium.isNull())
4644 oldmedium->i_removeBackReference(mData->mUuid);
4645 if (!pMedium.isNull())
4646 {
4647 pMedium->i_addBackReference(mData->mUuid);
4648
4649 mediumLock.release();
4650 multiLock.release();
4651 i_addMediumToRegistry(pMedium);
4652 multiLock.acquire();
4653 mediumLock.acquire();
4654 }
4655
4656 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4657 pAttach->i_updateMedium(pMedium);
4658 }
4659
4660 i_setModified(IsModified_Storage);
4661
4662 mediumLock.release();
4663 multiLock.release();
4664 rc = i_onMediumChange(pAttach, aForce);
4665 multiLock.acquire();
4666 mediumLock.acquire();
4667
4668 /* On error roll back this change only. */
4669 if (FAILED(rc))
4670 {
4671 if (!pMedium.isNull())
4672 pMedium->i_removeBackReference(mData->mUuid);
4673 pAttach = i_findAttachment(mMediaData->mAttachments,
4674 Bstr(aName).raw(),
4675 aControllerPort,
4676 aDevice);
4677 /* If the attachment is gone in the meantime, bail out. */
4678 if (pAttach.isNull())
4679 return rc;
4680 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
4681 if (!oldmedium.isNull())
4682 oldmedium->i_addBackReference(mData->mUuid);
4683 pAttach->i_updateMedium(oldmedium);
4684 }
4685
4686 mediumLock.release();
4687 multiLock.release();
4688
4689 mParent->i_saveModifiedRegistries();
4690
4691 return rc;
4692}
4693HRESULT Machine::getMedium(const com::Utf8Str &aName,
4694 LONG aControllerPort,
4695 LONG aDevice,
4696 ComPtr<IMedium> &aMedium)
4697{
4698 LogFlowThisFunc(("aName=\"%s\" aControllerPort=%d aDevice=%d\n",
4699 aName.c_str(), aControllerPort, aDevice));
4700
4701 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4702
4703 aMedium = NULL;
4704
4705 ComObjPtr<MediumAttachment> pAttach = i_findAttachment(mMediaData->mAttachments,
4706 Bstr(aName).raw(),
4707 aControllerPort,
4708 aDevice);
4709 if (pAttach.isNull())
4710 return setError(VBOX_E_OBJECT_NOT_FOUND,
4711 tr("No storage device attached to device slot %d on port %d of controller '%s'"),
4712 aDevice, aControllerPort, aName.c_str());
4713
4714 pAttach->i_getMedium().queryInterfaceTo(aMedium.asOutParam());
4715
4716 return S_OK;
4717}
4718
4719HRESULT Machine::getSerialPort(ULONG aSlot, ComPtr<ISerialPort> &aPort)
4720{
4721
4722 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4723
4724 mSerialPorts[aSlot].queryInterfaceTo(aPort.asOutParam());
4725
4726 return S_OK;
4727}
4728
4729HRESULT Machine::getParallelPort(ULONG aSlot, ComPtr<IParallelPort> &aPort)
4730{
4731 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4732
4733 mParallelPorts[aSlot].queryInterfaceTo(aPort.asOutParam());
4734
4735 return S_OK;
4736}
4737
4738HRESULT Machine::getNetworkAdapter(ULONG aSlot, ComPtr<INetworkAdapter> &aAdapter)
4739{
4740 /* Do not assert if slot is out of range, just return the advertised
4741 status. testdriver/vbox.py triggers this in logVmInfo. */
4742 if (aSlot >= mNetworkAdapters.size())
4743 return setError(E_INVALIDARG,
4744 tr("No network adapter in slot %RU32 (total %RU32 adapters)"),
4745 aSlot, mNetworkAdapters.size());
4746
4747 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4748
4749 mNetworkAdapters[aSlot].queryInterfaceTo(aAdapter.asOutParam());
4750
4751 return S_OK;
4752}
4753
4754HRESULT Machine::getExtraDataKeys(std::vector<com::Utf8Str> &aKeys)
4755{
4756 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4757
4758 com::SafeArray<BSTR> saKeys(mData->pMachineConfigFile->mapExtraDataItems.size());
4759 aKeys.resize(mData->pMachineConfigFile->mapExtraDataItems.size());
4760 size_t i = 0;
4761 for (settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.begin();
4762 it != mData->pMachineConfigFile->mapExtraDataItems.end();
4763 ++it, ++i)
4764 aKeys[i] = it->first;
4765
4766 return S_OK;
4767}
4768
4769 /**
4770 * @note Locks this object for reading.
4771 */
4772HRESULT Machine::getExtraData(const com::Utf8Str &aKey,
4773 com::Utf8Str &aValue)
4774{
4775 /* start with nothing found */
4776 aValue = "";
4777
4778 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4779
4780 settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(aKey);
4781 if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4782 // found:
4783 aValue = it->second; // source is a Utf8Str
4784
4785 /* return the result to caller (may be empty) */
4786 return S_OK;
4787}
4788
4789 /**
4790 * @note Locks mParent for writing + this object for writing.
4791 */
4792HRESULT Machine::setExtraData(const com::Utf8Str &aKey, const com::Utf8Str &aValue)
4793{
4794 Utf8Str strOldValue; // empty
4795
4796 // locking note: we only hold the read lock briefly to look up the old value,
4797 // then release it and call the onExtraCanChange callbacks. There is a small
4798 // chance of a race insofar as the callback might be called twice if two callers
4799 // change the same key at the same time, but that's a much better solution
4800 // than the deadlock we had here before. The actual changing of the extradata
4801 // is then performed under the write lock and race-free.
4802
4803 // look up the old value first; if nothing has changed then we need not do anything
4804 {
4805 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); // hold read lock only while looking up
4806 settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(aKey);
4807 if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4808 strOldValue = it->second;
4809 }
4810
4811 bool fChanged;
4812 if ((fChanged = (strOldValue != aValue)))
4813 {
4814 // ask for permission from all listeners outside the locks;
4815 // i_onExtraDataCanChange() only briefly requests the VirtualBox
4816 // lock to copy the list of callbacks to invoke
4817 Bstr error;
4818 Bstr bstrValue(aValue);
4819
4820 if (!mParent->i_onExtraDataCanChange(mData->mUuid, Bstr(aKey).raw(), bstrValue.raw(), error))
4821 {
4822 const char *sep = error.isEmpty() ? "" : ": ";
4823 CBSTR err = error.raw();
4824 LogWarningFunc(("Someone vetoed! Change refused%s%ls\n",
4825 sep, err));
4826 return setError(E_ACCESSDENIED,
4827 tr("Could not set extra data because someone refused the requested change of '%s' to '%s'%s%ls"),
4828 aKey.c_str(),
4829 aValue.c_str(),
4830 sep,
4831 err);
4832 }
4833
4834 // data is changing and change not vetoed: then write it out under the lock
4835 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4836
4837 if (i_isSnapshotMachine())
4838 {
4839 HRESULT rc = i_checkStateDependency(MutableStateDep);
4840 if (FAILED(rc)) return rc;
4841 }
4842
4843 if (aValue.isEmpty())
4844 mData->pMachineConfigFile->mapExtraDataItems.erase(aKey);
4845 else
4846 mData->pMachineConfigFile->mapExtraDataItems[aKey] = aValue;
4847 // creates a new key if needed
4848
4849 bool fNeedsGlobalSaveSettings = false;
4850 i_saveSettings(&fNeedsGlobalSaveSettings);
4851
4852 if (fNeedsGlobalSaveSettings)
4853 {
4854 // save the global settings; for that we should hold only the VirtualBox lock
4855 alock.release();
4856 AutoWriteLock vboxlock(mParent COMMA_LOCKVAL_SRC_POS);
4857 mParent->i_saveSettings();
4858 }
4859 }
4860
4861 // fire notification outside the lock
4862 if (fChanged)
4863 mParent->i_onExtraDataChange(mData->mUuid, Bstr(aKey).raw(), Bstr(aValue).raw());
4864
4865 return S_OK;
4866}
4867
4868HRESULT Machine::setSettingsFilePath(const com::Utf8Str &aSettingsFilePath, ComPtr<IProgress> &aProgress)
4869{
4870 aProgress = NULL;
4871 NOREF(aSettingsFilePath);
4872 ReturnComNotImplemented();
4873}
4874
4875HRESULT Machine::saveSettings()
4876{
4877 AutoWriteLock mlock(this COMMA_LOCKVAL_SRC_POS);
4878
4879 /* when there was auto-conversion, we want to save the file even if
4880 * the VM is saved */
4881 HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
4882 if (FAILED(rc)) return rc;
4883
4884 /* the settings file path may never be null */
4885 ComAssertRet(!mData->m_strConfigFileFull.isEmpty(), E_FAIL);
4886
4887 /* save all VM data excluding snapshots */
4888 bool fNeedsGlobalSaveSettings = false;
4889 rc = i_saveSettings(&fNeedsGlobalSaveSettings);
4890 mlock.release();
4891
4892 if (SUCCEEDED(rc) && fNeedsGlobalSaveSettings)
4893 {
4894 // save the global settings; for that we should hold only the VirtualBox lock
4895 AutoWriteLock vlock(mParent COMMA_LOCKVAL_SRC_POS);
4896 rc = mParent->i_saveSettings();
4897 }
4898
4899 return rc;
4900}
4901
4902
4903HRESULT Machine::discardSettings()
4904{
4905 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4906
4907 HRESULT rc = i_checkStateDependency(MutableStateDep);
4908 if (FAILED(rc)) return rc;
4909
4910 /*
4911 * during this rollback, the session will be notified if data has
4912 * been actually changed
4913 */
4914 i_rollback(true /* aNotify */);
4915
4916 return S_OK;
4917}
4918
4919/** @note Locks objects! */
4920HRESULT Machine::unregister(CleanupMode_T aCleanupMode,
4921 std::vector<ComPtr<IMedium> > &aMedia)
4922{
4923 // use AutoLimitedCaller because this call is valid on inaccessible machines as well
4924 AutoLimitedCaller autoCaller(this);
4925 AssertComRCReturnRC(autoCaller.rc());
4926
4927 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4928
4929 Guid id(i_getId());
4930
4931 if (mData->mSession.mState != SessionState_Unlocked)
4932 return setError(VBOX_E_INVALID_OBJECT_STATE,
4933 tr("Cannot unregister the machine '%s' while it is locked"),
4934 mUserData->s.strName.c_str());
4935
4936 // wait for state dependents to drop to zero
4937 i_ensureNoStateDependencies();
4938
4939 if (!mData->mAccessible)
4940 {
4941 // inaccessible maschines can only be unregistered; uninitialize ourselves
4942 // here because currently there may be no unregistered that are inaccessible
4943 // (this state combination is not supported). Note releasing the caller and
4944 // leaving the lock before calling uninit()
4945 alock.release();
4946 autoCaller.release();
4947
4948 uninit();
4949
4950 mParent->i_unregisterMachine(this, id);
4951 // calls VirtualBox::i_saveSettings()
4952
4953 return S_OK;
4954 }
4955
4956 HRESULT rc = S_OK;
4957
4958 // discard saved state
4959 if (mData->mMachineState == MachineState_Saved)
4960 {
4961 // add the saved state file to the list of files the caller should delete
4962 Assert(!mSSData->strStateFilePath.isEmpty());
4963 mData->llFilesToDelete.push_back(mSSData->strStateFilePath);
4964
4965 mSSData->strStateFilePath.setNull();
4966
4967 // unconditionally set the machine state to powered off, we now
4968 // know no session has locked the machine
4969 mData->mMachineState = MachineState_PoweredOff;
4970 }
4971
4972 size_t cSnapshots = 0;
4973 if (mData->mFirstSnapshot)
4974 cSnapshots = mData->mFirstSnapshot->i_getAllChildrenCount() + 1;
4975 if (cSnapshots && aCleanupMode == CleanupMode_UnregisterOnly)
4976 // fail now before we start detaching media
4977 return setError(VBOX_E_INVALID_OBJECT_STATE,
4978 tr("Cannot unregister the machine '%s' because it has %d snapshots"),
4979 mUserData->s.strName.c_str(), cSnapshots);
4980
4981 // This list collects the medium objects from all medium attachments
4982 // which we will detach from the machine and its snapshots, in a specific
4983 // order which allows for closing all media without getting "media in use"
4984 // errors, simply by going through the list from the front to the back:
4985 // 1) first media from machine attachments (these have the "leaf" attachments with snapshots
4986 // and must be closed before the parent media from the snapshots, or closing the parents
4987 // will fail because they still have children);
4988 // 2) media from the youngest snapshots followed by those from the parent snapshots until
4989 // the root ("first") snapshot of the machine.
4990 MediaList llMedia;
4991
4992 if ( !mMediaData.isNull() // can be NULL if machine is inaccessible
4993 && mMediaData->mAttachments.size()
4994 )
4995 {
4996 // we have media attachments: detach them all and add the Medium objects to our list
4997 if (aCleanupMode != CleanupMode_UnregisterOnly)
4998 i_detachAllMedia(alock, NULL /* pSnapshot */, aCleanupMode, llMedia);
4999 else
5000 return setError(VBOX_E_INVALID_OBJECT_STATE,
5001 tr("Cannot unregister the machine '%s' because it has %d media attachments"),
5002 mUserData->s.strName.c_str(), mMediaData->mAttachments.size());
5003 }
5004
5005 if (cSnapshots)
5006 {
5007 // autoCleanup must be true here, or we would have failed above
5008
5009 // add the media from the medium attachments of the snapshots to llMedia
5010 // as well, after the "main" machine media; Snapshot::uninitRecursively()
5011 // calls Machine::detachAllMedia() for the snapshot machine, recursing
5012 // into the children first
5013
5014 // Snapshot::beginDeletingSnapshot() asserts if the machine state is not this
5015 MachineState_T oldState = mData->mMachineState;
5016 mData->mMachineState = MachineState_DeletingSnapshot;
5017
5018 // make a copy of the first snapshot so the refcount does not drop to 0
5019 // in beginDeletingSnapshot, which sets pFirstSnapshot to 0 (that hangs
5020 // because of the AutoCaller voodoo)
5021 ComObjPtr<Snapshot> pFirstSnapshot = mData->mFirstSnapshot;
5022
5023 // GO!
5024 pFirstSnapshot->i_uninitRecursively(alock, aCleanupMode, llMedia, mData->llFilesToDelete);
5025
5026 mData->mMachineState = oldState;
5027 }
5028
5029 if (FAILED(rc))
5030 {
5031 i_rollbackMedia();
5032 return rc;
5033 }
5034
5035 // commit all the media changes made above
5036 i_commitMedia();
5037
5038 mData->mRegistered = false;
5039
5040 // machine lock no longer needed
5041 alock.release();
5042
5043 // return media to caller
5044 size_t i = 0;
5045 aMedia.resize(llMedia.size());
5046 for (MediaList::iterator it = llMedia.begin(); it != llMedia.end(); ++it, ++i)
5047 (*it).queryInterfaceTo(aMedia[i].asOutParam());
5048
5049 mParent->i_unregisterMachine(this, id);
5050 // calls VirtualBox::i_saveSettings() and VirtualBox::saveModifiedRegistries()
5051
5052 return S_OK;
5053}
5054
5055struct Machine::DeleteTask
5056{
5057 ComObjPtr<Machine> pMachine;
5058 RTCList<ComPtr<IMedium> > llMediums;
5059 StringsList llFilesToDelete;
5060 ComObjPtr<Progress> pProgress;
5061};
5062
5063HRESULT Machine::deleteConfig(const std::vector<ComPtr<IMedium> > &aMedia, ComPtr<IProgress> &aProgress)
5064{
5065 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5066
5067 HRESULT rc = i_checkStateDependency(MutableStateDep);
5068 if (FAILED(rc)) return rc;
5069
5070 if (mData->mRegistered)
5071 return setError(VBOX_E_INVALID_VM_STATE,
5072 tr("Cannot delete settings of a registered machine"));
5073
5074 DeleteTask *pTask = new DeleteTask;
5075 pTask->pMachine = this;
5076
5077 // collect files to delete
5078 pTask->llFilesToDelete = mData->llFilesToDelete; // saved states pushed here by Unregister()
5079
5080 for (size_t i = 0; i < aMedia.size(); ++i)
5081 {
5082 IMedium *pIMedium(aMedia[i]);
5083 ComObjPtr<Medium> pMedium = static_cast<Medium*>(pIMedium);
5084 if (pMedium.isNull())
5085 return setError(E_INVALIDARG, "The given medium pointer with index %d is invalid", i);
5086 SafeArray<BSTR> ids;
5087 rc = pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids));
5088 if (FAILED(rc)) return rc;
5089 /* At this point the medium should not have any back references
5090 * anymore. If it has it is attached to another VM and *must* not
5091 * deleted. */
5092 if (ids.size() < 1)
5093 pTask->llMediums.append(pMedium);
5094 }
5095 if (mData->pMachineConfigFile->fileExists())
5096 pTask->llFilesToDelete.push_back(mData->m_strConfigFileFull);
5097
5098 pTask->pProgress.createObject();
5099 pTask->pProgress->init(i_getVirtualBox(),
5100 static_cast<IMachine*>(this) /* aInitiator */,
5101 Bstr(tr("Deleting files")).raw(),
5102 true /* fCancellable */,
5103 pTask->llFilesToDelete.size() + pTask->llMediums.size() + 1, // cOperations
5104 BstrFmt(tr("Deleting '%s'"), pTask->llFilesToDelete.front().c_str()).raw());
5105
5106 int vrc = RTThreadCreate(NULL,
5107 Machine::deleteThread,
5108 (void*)pTask,
5109 0,
5110 RTTHREADTYPE_MAIN_WORKER,
5111 0,
5112 "MachineDelete");
5113
5114 pTask->pProgress.queryInterfaceTo(aProgress.asOutParam());
5115
5116 if (RT_FAILURE(vrc))
5117 {
5118 delete pTask;
5119 return setError(E_FAIL, "Could not create MachineDelete thread (%Rrc)", vrc);
5120 }
5121
5122 LogFlowFuncLeave();
5123
5124 return S_OK;
5125}
5126
5127/**
5128 * Static task wrapper passed to RTThreadCreate() in Machine::Delete() which then
5129 * calls Machine::deleteTaskWorker() on the actual machine object.
5130 * @param Thread
5131 * @param pvUser
5132 * @return
5133 */
5134/*static*/
5135DECLCALLBACK(int) Machine::deleteThread(RTTHREAD Thread, void *pvUser)
5136{
5137 LogFlowFuncEnter();
5138
5139 DeleteTask *pTask = (DeleteTask*)pvUser;
5140 Assert(pTask);
5141 Assert(pTask->pMachine);
5142 Assert(pTask->pProgress);
5143
5144 HRESULT rc = pTask->pMachine->i_deleteTaskWorker(*pTask);
5145 pTask->pProgress->i_notifyComplete(rc);
5146
5147 delete pTask;
5148
5149 LogFlowFuncLeave();
5150
5151 NOREF(Thread);
5152
5153 return VINF_SUCCESS;
5154}
5155
5156/**
5157 * Task thread implementation for Machine::Delete(), called from Machine::deleteThread().
5158 * @param task
5159 * @return
5160 */
5161HRESULT Machine::i_deleteTaskWorker(DeleteTask &task)
5162{
5163 AutoCaller autoCaller(this);
5164 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5165
5166 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5167
5168 HRESULT rc = S_OK;
5169
5170 try
5171 {
5172 ULONG uLogHistoryCount = 3;
5173 ComPtr<ISystemProperties> systemProperties;
5174 rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
5175 if (FAILED(rc)) throw rc;
5176
5177 if (!systemProperties.isNull())
5178 {
5179 rc = systemProperties->COMGETTER(LogHistoryCount)(&uLogHistoryCount);
5180 if (FAILED(rc)) throw rc;
5181 }
5182
5183 MachineState_T oldState = mData->mMachineState;
5184 i_setMachineState(MachineState_SettingUp);
5185 alock.release();
5186 for (size_t i = 0; i < task.llMediums.size(); ++i)
5187 {
5188 ComObjPtr<Medium> pMedium = (Medium*)(IMedium*)task.llMediums.at(i);
5189 {
5190 AutoCaller mac(pMedium);
5191 if (FAILED(mac.rc())) throw mac.rc();
5192 Utf8Str strLocation = pMedium->i_getLocationFull();
5193 rc = task.pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), strLocation.c_str()).raw(), 1);
5194 if (FAILED(rc)) throw rc;
5195 LogFunc(("Deleting file %s\n", strLocation.c_str()));
5196 }
5197 ComPtr<IProgress> pProgress2;
5198 rc = pMedium->DeleteStorage(pProgress2.asOutParam());
5199 if (FAILED(rc)) throw rc;
5200 rc = task.pProgress->WaitForAsyncProgressCompletion(pProgress2);
5201 if (FAILED(rc)) throw rc;
5202 /* Check the result of the asynchronous process. */
5203 LONG iRc;
5204 rc = pProgress2->COMGETTER(ResultCode)(&iRc);
5205 if (FAILED(rc)) throw rc;
5206 /* If the thread of the progress object has an error, then
5207 * retrieve the error info from there, or it'll be lost. */
5208 if (FAILED(iRc))
5209 throw setError(ProgressErrorInfo(pProgress2));
5210
5211 /* Close the medium, deliberately without checking the return
5212- * code, and without leaving any trace in the error info, as
5213- * a failure here is a very minor issue, which shouldn't happen
5214- * as above we even managed to delete the medium. */
5215 {
5216 ErrorInfoKeeper eik;
5217 pMedium->Close();
5218 }
5219 }
5220 i_setMachineState(oldState);
5221 alock.acquire();
5222
5223 // delete the files pushed on the task list by Machine::Delete()
5224 // (this includes saved states of the machine and snapshots and
5225 // medium storage files from the IMedium list passed in, and the
5226 // machine XML file)
5227 StringsList::const_iterator it = task.llFilesToDelete.begin();
5228 while (it != task.llFilesToDelete.end())
5229 {
5230 const Utf8Str &strFile = *it;
5231 LogFunc(("Deleting file %s\n", strFile.c_str()));
5232 int vrc = RTFileDelete(strFile.c_str());
5233 if (RT_FAILURE(vrc))
5234 throw setError(VBOX_E_IPRT_ERROR,
5235 tr("Could not delete file '%s' (%Rrc)"), strFile.c_str(), vrc);
5236
5237 ++it;
5238 if (it == task.llFilesToDelete.end())
5239 {
5240 rc = task.pProgress->SetNextOperation(Bstr(tr("Cleaning up machine directory")).raw(), 1);
5241 if (FAILED(rc)) throw rc;
5242 break;
5243 }
5244
5245 rc = task.pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), it->c_str()).raw(), 1);
5246 if (FAILED(rc)) throw rc;
5247 }
5248
5249 /* delete the settings only when the file actually exists */
5250 if (mData->pMachineConfigFile->fileExists())
5251 {
5252 /* Delete any backup or uncommitted XML files. Ignore failures.
5253 See the fSafe parameter of xml::XmlFileWriter::write for details. */
5254 /** @todo Find a way to avoid referring directly to iprt/xml.h here. */
5255 Utf8Str otherXml = Utf8StrFmt("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszTmpSuff);
5256 RTFileDelete(otherXml.c_str());
5257 otherXml = Utf8StrFmt("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszPrevSuff);
5258 RTFileDelete(otherXml.c_str());
5259
5260 /* delete the Logs folder, nothing important should be left
5261 * there (we don't check for errors because the user might have
5262 * some private files there that we don't want to delete) */
5263 Utf8Str logFolder;
5264 getLogFolder(logFolder);
5265 Assert(logFolder.length());
5266 if (RTDirExists(logFolder.c_str()))
5267 {
5268 /* Delete all VBox.log[.N] files from the Logs folder
5269 * (this must be in sync with the rotation logic in
5270 * Console::powerUpThread()). Also, delete the VBox.png[.N]
5271 * files that may have been created by the GUI. */
5272 Utf8Str log = Utf8StrFmt("%s%cVBox.log",
5273 logFolder.c_str(), RTPATH_DELIMITER);
5274 RTFileDelete(log.c_str());
5275 log = Utf8StrFmt("%s%cVBox.png",
5276 logFolder.c_str(), RTPATH_DELIMITER);
5277 RTFileDelete(log.c_str());
5278 for (int i = uLogHistoryCount; i > 0; i--)
5279 {
5280 log = Utf8StrFmt("%s%cVBox.log.%d",
5281 logFolder.c_str(), RTPATH_DELIMITER, i);
5282 RTFileDelete(log.c_str());
5283 log = Utf8StrFmt("%s%cVBox.png.%d",
5284 logFolder.c_str(), RTPATH_DELIMITER, i);
5285 RTFileDelete(log.c_str());
5286 }
5287
5288 RTDirRemove(logFolder.c_str());
5289 }
5290
5291 /* delete the Snapshots folder, nothing important should be left
5292 * there (we don't check for errors because the user might have
5293 * some private files there that we don't want to delete) */
5294 Utf8Str strFullSnapshotFolder;
5295 i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
5296 Assert(!strFullSnapshotFolder.isEmpty());
5297 if (RTDirExists(strFullSnapshotFolder.c_str()))
5298 RTDirRemove(strFullSnapshotFolder.c_str());
5299
5300 // delete the directory that contains the settings file, but only
5301 // if it matches the VM name
5302 Utf8Str settingsDir;
5303 if (i_isInOwnDir(&settingsDir))
5304 RTDirRemove(settingsDir.c_str());
5305 }
5306
5307 alock.release();
5308
5309 mParent->i_saveModifiedRegistries();
5310 }
5311 catch (HRESULT aRC) { rc = aRC; }
5312
5313 return rc;
5314}
5315
5316HRESULT Machine::findSnapshot(const com::Utf8Str &aNameOrId, ComPtr<ISnapshot> &aSnapshot)
5317{
5318 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5319
5320 ComObjPtr<Snapshot> pSnapshot;
5321 HRESULT rc;
5322
5323 if (aNameOrId.isEmpty())
5324 // null case (caller wants root snapshot): i_findSnapshotById() handles this
5325 rc = i_findSnapshotById(Guid(), pSnapshot, true /* aSetError */);
5326 else
5327 {
5328 Guid uuid(aNameOrId);
5329 if (uuid.isValid())
5330 rc = i_findSnapshotById(uuid, pSnapshot, true /* aSetError */);
5331 else
5332 rc = i_findSnapshotByName(aNameOrId, pSnapshot, true /* aSetError */);
5333 }
5334 pSnapshot.queryInterfaceTo(aSnapshot.asOutParam());
5335
5336 return rc;
5337}
5338
5339HRESULT Machine::createSharedFolder(const com::Utf8Str &aName, const com::Utf8Str &aHostPath, BOOL aWritable, BOOL aAutomount)
5340{
5341 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5342
5343 HRESULT rc = i_checkStateDependency(MutableStateDep);
5344 if (FAILED(rc)) return rc;
5345
5346 ComObjPtr<SharedFolder> sharedFolder;
5347 rc = i_findSharedFolder(aName, sharedFolder, false /* aSetError */);
5348 if (SUCCEEDED(rc))
5349 return setError(VBOX_E_OBJECT_IN_USE,
5350 tr("Shared folder named '%s' already exists"),
5351 aName.c_str());
5352
5353 sharedFolder.createObject();
5354 rc = sharedFolder->init(i_getMachine(),
5355 aName,
5356 aHostPath,
5357 !!aWritable,
5358 !!aAutomount,
5359 true /* fFailOnError */);
5360 if (FAILED(rc)) return rc;
5361
5362 i_setModified(IsModified_SharedFolders);
5363 mHWData.backup();
5364 mHWData->mSharedFolders.push_back(sharedFolder);
5365
5366 /* inform the direct session if any */
5367 alock.release();
5368 i_onSharedFolderChange();
5369
5370 return S_OK;
5371}
5372
5373HRESULT Machine::removeSharedFolder(const com::Utf8Str &aName)
5374{
5375 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5376
5377 HRESULT rc = i_checkStateDependency(MutableStateDep);
5378 if (FAILED(rc)) return rc;
5379
5380 ComObjPtr<SharedFolder> sharedFolder;
5381 rc = i_findSharedFolder(aName, sharedFolder, true /* aSetError */);
5382 if (FAILED(rc)) return rc;
5383
5384 i_setModified(IsModified_SharedFolders);
5385 mHWData.backup();
5386 mHWData->mSharedFolders.remove(sharedFolder);
5387
5388 /* inform the direct session if any */
5389 alock.release();
5390 i_onSharedFolderChange();
5391
5392 return S_OK;
5393}
5394
5395HRESULT Machine::canShowConsoleWindow(BOOL *aCanShow)
5396{
5397 /* start with No */
5398 *aCanShow = FALSE;
5399
5400 ComPtr<IInternalSessionControl> directControl;
5401 {
5402 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5403
5404 if (mData->mSession.mState != SessionState_Locked)
5405 return setError(VBOX_E_INVALID_VM_STATE,
5406 tr("Machine is not locked for session (session state: %s)"),
5407 Global::stringifySessionState(mData->mSession.mState));
5408
5409 directControl = mData->mSession.mDirectControl;
5410 }
5411
5412 /* ignore calls made after #OnSessionEnd() is called */
5413 if (!directControl)
5414 return S_OK;
5415
5416 LONG64 dummy;
5417 return directControl->OnShowWindow(TRUE /* aCheck */, aCanShow, &dummy);
5418}
5419
5420HRESULT Machine::showConsoleWindow(LONG64 *aWinId)
5421{
5422 ComPtr<IInternalSessionControl> directControl;
5423 {
5424 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5425
5426 if (mData->mSession.mState != SessionState_Locked)
5427 return setError(E_FAIL,
5428 tr("Machine is not locked for session (session state: %s)"),
5429 Global::stringifySessionState(mData->mSession.mState));
5430
5431 directControl = mData->mSession.mDirectControl;
5432 }
5433
5434 /* ignore calls made after #OnSessionEnd() is called */
5435 if (!directControl)
5436 return S_OK;
5437
5438 BOOL dummy;
5439 return directControl->OnShowWindow(FALSE /* aCheck */, &dummy, aWinId);
5440}
5441
5442#ifdef VBOX_WITH_GUEST_PROPS
5443/**
5444 * Look up a guest property in VBoxSVC's internal structures.
5445 */
5446HRESULT Machine::i_getGuestPropertyFromService(const com::Utf8Str &aName,
5447 com::Utf8Str &aValue,
5448 LONG64 *aTimestamp,
5449 com::Utf8Str &aFlags) const
5450{
5451 using namespace guestProp;
5452
5453 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5454 HWData::GuestPropertyMap::const_iterator it = mHWData->mGuestProperties.find(aName);
5455
5456 if (it != mHWData->mGuestProperties.end())
5457 {
5458 char szFlags[MAX_FLAGS_LEN + 1];
5459 aValue = it->second.strValue;
5460 *aTimestamp = it->second.mTimestamp;
5461 writeFlags(it->second.mFlags, szFlags);
5462 aFlags = Utf8Str(szFlags);
5463 }
5464
5465 return S_OK;
5466}
5467
5468/**
5469 * Query the VM that a guest property belongs to for the property.
5470 * @returns E_ACCESSDENIED if the VM process is not available or not
5471 * currently handling queries and the lookup should then be done in
5472 * VBoxSVC.
5473 */
5474HRESULT Machine::i_getGuestPropertyFromVM(const com::Utf8Str &aName,
5475 com::Utf8Str &aValue,
5476 LONG64 *aTimestamp,
5477 com::Utf8Str &aFlags) const
5478{
5479 HRESULT rc = S_OK;
5480 BSTR bValue = NULL;
5481 BSTR bFlags = NULL;
5482
5483 ComPtr<IInternalSessionControl> directControl;
5484 directControl = mData->mSession.mDirectControl;
5485
5486 /* fail if we were called after #OnSessionEnd() is called. This is a
5487 * silly race condition. */
5488
5489 /** @todo This code is bothering API clients (like python script clients) with
5490 * the AccessGuestProperty call, creating unncessary IPC. Need to
5491 * have a way of figuring out which kind of direct session it is... */
5492 if (!directControl)
5493 rc = E_ACCESSDENIED;
5494 else
5495 rc = directControl->AccessGuestProperty(Bstr(aName).raw(), NULL, NULL,
5496 false /* isSetter */,
5497 &bValue, aTimestamp, &bFlags);
5498
5499 aValue = bValue;
5500 aFlags = bFlags;
5501
5502 return rc;
5503}
5504#endif // VBOX_WITH_GUEST_PROPS
5505
5506HRESULT Machine::getGuestProperty(const com::Utf8Str &aName,
5507 com::Utf8Str &aValue,
5508 LONG64 *aTimestamp,
5509 com::Utf8Str &aFlags)
5510{
5511#ifndef VBOX_WITH_GUEST_PROPS
5512 ReturnComNotImplemented();
5513#else // VBOX_WITH_GUEST_PROPS
5514
5515 HRESULT rc = i_getGuestPropertyFromVM(aName, aValue, aTimestamp, aFlags);
5516
5517 if (rc == E_ACCESSDENIED)
5518 /* The VM is not running or the service is not (yet) accessible */
5519 rc = i_getGuestPropertyFromService(aName, aValue, aTimestamp, aFlags);
5520 return rc;
5521#endif // VBOX_WITH_GUEST_PROPS
5522}
5523
5524HRESULT Machine::getGuestPropertyValue(const com::Utf8Str &aProperty, com::Utf8Str &aValue)
5525{
5526 LONG64 dummyTimestamp;
5527 com::Utf8Str dummyFlags;
5528 HRESULT rc = getGuestProperty(aProperty, aValue, &dummyTimestamp, dummyFlags);
5529 return rc;
5530
5531}
5532HRESULT Machine::getGuestPropertyTimestamp(const com::Utf8Str &aProperty, LONG64 *aValue)
5533{
5534 com::Utf8Str dummyFlags;
5535 com::Utf8Str dummyValue;
5536 HRESULT rc = getGuestProperty(aProperty, dummyValue, aValue, dummyFlags);
5537 return rc;
5538}
5539
5540#ifdef VBOX_WITH_GUEST_PROPS
5541/**
5542 * Set a guest property in VBoxSVC's internal structures.
5543 */
5544HRESULT Machine::i_setGuestPropertyToService(const com::Utf8Str &aName, const com::Utf8Str &aValue,
5545 const com::Utf8Str &aFlags)
5546{
5547 using namespace guestProp;
5548
5549 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5550 HRESULT rc = S_OK;
5551
5552 rc = i_checkStateDependency(MutableStateDep);
5553 if (FAILED(rc)) return rc;
5554
5555 try
5556 {
5557 uint32_t fFlags = NILFLAG;
5558 if (aFlags.length() && RT_FAILURE(validateFlags(aFlags.c_str(), &fFlags)))
5559 return setError(E_INVALIDARG, tr("Invalid guest property flag values: '%s'"), aFlags.c_str());
5560
5561 bool fDelete = aValue.isEmpty();
5562 HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.find(aName);
5563 if (it == mHWData->mGuestProperties.end())
5564 {
5565 if (!fDelete)
5566 {
5567 i_setModified(IsModified_MachineData);
5568 mHWData.backupEx();
5569
5570 RTTIMESPEC time;
5571 HWData::GuestProperty prop;
5572 prop.strValue = Bstr(aValue).raw();
5573 prop.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
5574 prop.mFlags = fFlags;
5575 mHWData->mGuestProperties[aName] = prop;
5576 }
5577 }
5578 else
5579 {
5580 if (it->second.mFlags & (RDONLYHOST))
5581 {
5582 rc = setError(E_ACCESSDENIED, tr("The property '%s' cannot be changed by the host"), aName.c_str());
5583 }
5584 else
5585 {
5586 i_setModified(IsModified_MachineData);
5587 mHWData.backupEx();
5588
5589 /* The backupEx() operation invalidates our iterator,
5590 * so get a new one. */
5591 it = mHWData->mGuestProperties.find(aName);
5592 Assert(it != mHWData->mGuestProperties.end());
5593
5594 if (!fDelete)
5595 {
5596 RTTIMESPEC time;
5597 it->second.strValue = aValue;
5598 it->second.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
5599 it->second.mFlags = fFlags;
5600 }
5601 else
5602 mHWData->mGuestProperties.erase(it);
5603 }
5604 }
5605
5606 if ( SUCCEEDED(rc)
5607 && ( mHWData->mGuestPropertyNotificationPatterns.isEmpty()
5608 || RTStrSimplePatternMultiMatch(mHWData->mGuestPropertyNotificationPatterns.c_str(),
5609 RTSTR_MAX,
5610 aName.c_str(),
5611 RTSTR_MAX,
5612 NULL)
5613 )
5614 )
5615 {
5616 alock.release();
5617
5618 mParent->i_onGuestPropertyChange(mData->mUuid,
5619 Bstr(aName).raw(),
5620 Bstr(aValue).raw(),
5621 Bstr(aFlags).raw());
5622 }
5623 }
5624 catch (std::bad_alloc &)
5625 {
5626 rc = E_OUTOFMEMORY;
5627 }
5628
5629 return rc;
5630}
5631
5632/**
5633 * Set a property on the VM that that property belongs to.
5634 * @returns E_ACCESSDENIED if the VM process is not available or not
5635 * currently handling queries and the setting should then be done in
5636 * VBoxSVC.
5637 */
5638HRESULT Machine::i_setGuestPropertyToVM(const com::Utf8Str &aName, const com::Utf8Str &aValue,
5639 const com::Utf8Str &aFlags)
5640{
5641 HRESULT rc;
5642
5643 try
5644 {
5645 ComPtr<IInternalSessionControl> directControl = mData->mSession.mDirectControl;
5646
5647 BSTR dummy = NULL; /* will not be changed (setter) */
5648 LONG64 dummy64;
5649 if (!directControl)
5650 rc = E_ACCESSDENIED;
5651 else
5652 /** @todo Fix when adding DeleteGuestProperty(), see defect. */
5653 rc = directControl->AccessGuestProperty(Bstr(aName).raw(), Bstr(aValue).raw(), Bstr(aFlags).raw(),
5654 true /* isSetter */,
5655 &dummy, &dummy64, &dummy);
5656 }
5657 catch (std::bad_alloc &)
5658 {
5659 rc = E_OUTOFMEMORY;
5660 }
5661
5662 return rc;
5663}
5664#endif // VBOX_WITH_GUEST_PROPS
5665
5666HRESULT Machine::setGuestProperty(const com::Utf8Str &aProperty, const com::Utf8Str &aValue,
5667 const com::Utf8Str &aFlags)
5668{
5669#ifndef VBOX_WITH_GUEST_PROPS
5670 ReturnComNotImplemented();
5671#else // VBOX_WITH_GUEST_PROPS
5672 HRESULT rc = i_setGuestPropertyToVM(aProperty, aValue, aFlags);
5673 if (rc == E_ACCESSDENIED)
5674 /* The VM is not running or the service is not (yet) accessible */
5675 rc = i_setGuestPropertyToService(aProperty, aValue, aFlags);
5676 return rc;
5677#endif // VBOX_WITH_GUEST_PROPS
5678}
5679
5680HRESULT Machine::setGuestPropertyValue(const com::Utf8Str &aProperty, const com::Utf8Str &aValue)
5681{
5682 return setGuestProperty(aProperty, aValue, "");
5683}
5684
5685HRESULT Machine::deleteGuestProperty(const com::Utf8Str &aName)
5686{
5687 return setGuestProperty(aName, "", "");
5688}
5689
5690#ifdef VBOX_WITH_GUEST_PROPS
5691/**
5692 * Enumerate the guest properties in VBoxSVC's internal structures.
5693 */
5694HRESULT Machine::i_enumerateGuestPropertiesInService(const com::Utf8Str &aPatterns,
5695 std::vector<com::Utf8Str> &aNames,
5696 std::vector<com::Utf8Str> &aValues,
5697 std::vector<LONG64> &aTimestamps,
5698 std::vector<com::Utf8Str> &aFlags)
5699{
5700 using namespace guestProp;
5701
5702 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5703 Utf8Str strPatterns(aPatterns);
5704
5705 HWData::GuestPropertyMap propMap;
5706
5707 /*
5708 * Look for matching patterns and build up a list.
5709 */
5710 HWData::GuestPropertyMap::const_iterator it = mHWData->mGuestProperties.begin();
5711 while (it != mHWData->mGuestProperties.end())
5712 {
5713 if ( strPatterns.isEmpty()
5714 || RTStrSimplePatternMultiMatch(strPatterns.c_str(),
5715 RTSTR_MAX,
5716 it->first.c_str(),
5717 RTSTR_MAX,
5718 NULL)
5719 )
5720 propMap.insert(*it);
5721 it++;
5722 }
5723
5724 alock.release();
5725
5726 /*
5727 * And build up the arrays for returning the property information.
5728 */
5729 size_t cEntries = propMap.size();
5730
5731 aNames.resize(cEntries);
5732 aValues.resize(cEntries);
5733 aTimestamps.resize(cEntries);
5734 aFlags.resize(cEntries);
5735
5736 char szFlags[MAX_FLAGS_LEN + 1];
5737 size_t i= 0;
5738 for (it = propMap.begin(); it != propMap.end(); ++i, ++it)
5739 {
5740 aNames[i] = it->first;
5741 aValues[i] = it->second.strValue;
5742 aTimestamps[i] = it->second.mTimestamp;
5743 writeFlags(it->second.mFlags, szFlags);
5744 aFlags[i] = Utf8Str(szFlags);
5745 }
5746
5747 return S_OK;
5748}
5749
5750/**
5751 * Enumerate the properties managed by a VM.
5752 * @returns E_ACCESSDENIED if the VM process is not available or not
5753 * currently handling queries and the setting should then be done in
5754 * VBoxSVC.
5755 */
5756HRESULT Machine::i_enumerateGuestPropertiesOnVM(const com::Utf8Str &aPatterns,
5757 std::vector<com::Utf8Str> &aNames,
5758 std::vector<com::Utf8Str> &aValues,
5759 std::vector<LONG64> &aTimestamps,
5760 std::vector<com::Utf8Str> &aFlags)
5761{
5762 HRESULT rc;
5763 ComPtr<IInternalSessionControl> directControl;
5764 directControl = mData->mSession.mDirectControl;
5765
5766
5767 com::SafeArray<BSTR> bNames;
5768 com::SafeArray<BSTR> bValues;
5769 com::SafeArray<LONG64> bTimestamps;
5770 com::SafeArray<BSTR> bFlags;
5771
5772 if (!directControl)
5773 rc = E_ACCESSDENIED;
5774 else
5775 rc = directControl->EnumerateGuestProperties(Bstr(aPatterns).raw(),
5776 ComSafeArrayAsOutParam(bNames),
5777 ComSafeArrayAsOutParam(bValues),
5778 ComSafeArrayAsOutParam(bTimestamps),
5779 ComSafeArrayAsOutParam(bFlags));
5780 size_t i;
5781 aNames.resize(bNames.size());
5782 for (i = 0; i < bNames.size(); ++i)
5783 aNames[i] = Utf8Str(bNames[i]);
5784 aValues.resize(bValues.size());
5785 for (i = 0; i < bValues.size(); ++i)
5786 aValues[i] = Utf8Str(bValues[i]);
5787 aTimestamps.resize(bTimestamps.size());
5788 for (i = 0; i < bTimestamps.size(); ++i)
5789 aTimestamps[i] = bTimestamps[i];
5790 aFlags.resize(bFlags.size());
5791 for (i = 0; i < bFlags.size(); ++i)
5792 aFlags[i] = Utf8Str(bFlags[i]);
5793
5794 return rc;
5795}
5796#endif // VBOX_WITH_GUEST_PROPS
5797HRESULT Machine::enumerateGuestProperties(const com::Utf8Str &aPatterns,
5798 std::vector<com::Utf8Str> &aNames,
5799 std::vector<com::Utf8Str> &aValues,
5800 std::vector<LONG64> &aTimestamps,
5801 std::vector<com::Utf8Str> &aFlags)
5802{
5803#ifndef VBOX_WITH_GUEST_PROPS
5804 ReturnComNotImplemented();
5805#else // VBOX_WITH_GUEST_PROPS
5806
5807 HRESULT rc = i_enumerateGuestPropertiesOnVM(aPatterns, aNames, aValues, aTimestamps, aFlags);
5808
5809 if (rc == E_ACCESSDENIED)
5810 /* The VM is not running or the service is not (yet) accessible */
5811 rc = i_enumerateGuestPropertiesInService(aPatterns, aNames, aValues, aTimestamps, aFlags);
5812 return rc;
5813#endif // VBOX_WITH_GUEST_PROPS
5814}
5815
5816HRESULT Machine::getMediumAttachmentsOfController(const com::Utf8Str &aName,
5817 std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments)
5818{
5819 MediaData::AttachmentList atts;
5820
5821 HRESULT rc = i_getMediumAttachmentsOfController(aName, atts);
5822 if (FAILED(rc)) return rc;
5823
5824 size_t i = 0;
5825 aMediumAttachments.resize(atts.size());
5826 for (MediaData::AttachmentList::iterator it = atts.begin(); it != atts.end(); ++it, ++i)
5827 (*it).queryInterfaceTo(aMediumAttachments[i].asOutParam());
5828
5829 return S_OK;
5830}
5831
5832HRESULT Machine::getMediumAttachment(const com::Utf8Str &aName,
5833 LONG aControllerPort,
5834 LONG aDevice,
5835 ComPtr<IMediumAttachment> &aAttachment)
5836{
5837 LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d\n",
5838 aName.c_str(), aControllerPort, aDevice));
5839
5840 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5841
5842 aAttachment = NULL;
5843
5844 ComObjPtr<MediumAttachment> pAttach = i_findAttachment(mMediaData->mAttachments,
5845 Bstr(aName).raw(),
5846 aControllerPort,
5847 aDevice);
5848 if (pAttach.isNull())
5849 return setError(VBOX_E_OBJECT_NOT_FOUND,
5850 tr("No storage device attached to device slot %d on port %d of controller '%s'"),
5851 aDevice, aControllerPort, aName.c_str());
5852
5853 pAttach.queryInterfaceTo(aAttachment.asOutParam());
5854
5855 return S_OK;
5856}
5857
5858
5859HRESULT Machine::addStorageController(const com::Utf8Str &aName,
5860 StorageBus_T aConnectionType,
5861 ComPtr<IStorageController> &aController)
5862{
5863 if ( (aConnectionType <= StorageBus_Null)
5864 || (aConnectionType > StorageBus_USB))
5865 return setError(E_INVALIDARG,
5866 tr("Invalid connection type: %d"),
5867 aConnectionType);
5868
5869 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5870
5871 HRESULT rc = i_checkStateDependency(MutableStateDep);
5872 if (FAILED(rc)) return rc;
5873
5874 /* try to find one with the name first. */
5875 ComObjPtr<StorageController> ctrl;
5876
5877 rc = i_getStorageControllerByName(aName, ctrl, false /* aSetError */);
5878 if (SUCCEEDED(rc))
5879 return setError(VBOX_E_OBJECT_IN_USE,
5880 tr("Storage controller named '%s' already exists"),
5881 aName.c_str());
5882
5883 ctrl.createObject();
5884
5885 /* get a new instance number for the storage controller */
5886 ULONG ulInstance = 0;
5887 bool fBootable = true;
5888 for (StorageControllerList::const_iterator it = mStorageControllers->begin();
5889 it != mStorageControllers->end();
5890 ++it)
5891 {
5892 if ((*it)->i_getStorageBus() == aConnectionType)
5893 {
5894 ULONG ulCurInst = (*it)->i_getInstance();
5895
5896 if (ulCurInst >= ulInstance)
5897 ulInstance = ulCurInst + 1;
5898
5899 /* Only one controller of each type can be marked as bootable. */
5900 if ((*it)->i_getBootable())
5901 fBootable = false;
5902 }
5903 }
5904
5905 rc = ctrl->init(this, aName, aConnectionType, ulInstance, fBootable);
5906 if (FAILED(rc)) return rc;
5907
5908 i_setModified(IsModified_Storage);
5909 mStorageControllers.backup();
5910 mStorageControllers->push_back(ctrl);
5911
5912 ctrl.queryInterfaceTo(aController.asOutParam());
5913
5914 /* inform the direct session if any */
5915 alock.release();
5916 i_onStorageControllerChange();
5917
5918 return S_OK;
5919}
5920
5921HRESULT Machine::getStorageControllerByName(const com::Utf8Str &aName,
5922 ComPtr<IStorageController> &aStorageController)
5923{
5924 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5925
5926 ComObjPtr<StorageController> ctrl;
5927
5928 HRESULT rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
5929 if (SUCCEEDED(rc))
5930 ctrl.queryInterfaceTo(aStorageController.asOutParam());
5931
5932 return rc;
5933}
5934
5935HRESULT Machine::getStorageControllerByInstance(ULONG aInstance,
5936 ComPtr<IStorageController> &aStorageController)
5937{
5938 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5939
5940 for (StorageControllerList::const_iterator it = mStorageControllers->begin();
5941 it != mStorageControllers->end();
5942 ++it)
5943 {
5944 if ((*it)->i_getInstance() == aInstance)
5945 {
5946 (*it).queryInterfaceTo(aStorageController.asOutParam());
5947 return S_OK;
5948 }
5949 }
5950
5951 return setError(VBOX_E_OBJECT_NOT_FOUND,
5952 tr("Could not find a storage controller with instance number '%lu'"),
5953 aInstance);
5954}
5955
5956HRESULT Machine::setStorageControllerBootable(const com::Utf8Str &aName, BOOL aBootable)
5957{
5958 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5959
5960 HRESULT rc = i_checkStateDependency(MutableStateDep);
5961 if (FAILED(rc)) return rc;
5962
5963 ComObjPtr<StorageController> ctrl;
5964
5965 rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
5966 if (SUCCEEDED(rc))
5967 {
5968 /* Ensure that only one controller of each type is marked as bootable. */
5969 if (aBootable == TRUE)
5970 {
5971 for (StorageControllerList::const_iterator it = mStorageControllers->begin();
5972 it != mStorageControllers->end();
5973 ++it)
5974 {
5975 ComObjPtr<StorageController> aCtrl = (*it);
5976
5977 if ( (aCtrl->i_getName() != aName)
5978 && aCtrl->i_getBootable() == TRUE
5979 && aCtrl->i_getStorageBus() == ctrl->i_getStorageBus()
5980 && aCtrl->i_getControllerType() == ctrl->i_getControllerType())
5981 {
5982 aCtrl->i_setBootable(FALSE);
5983 break;
5984 }
5985 }
5986 }
5987
5988 if (SUCCEEDED(rc))
5989 {
5990 ctrl->i_setBootable(aBootable);
5991 i_setModified(IsModified_Storage);
5992 }
5993 }
5994
5995 if (SUCCEEDED(rc))
5996 {
5997 /* inform the direct session if any */
5998 alock.release();
5999 i_onStorageControllerChange();
6000 }
6001
6002 return rc;
6003}
6004
6005HRESULT Machine::removeStorageController(const com::Utf8Str &aName)
6006{
6007 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6008
6009 HRESULT rc = i_checkStateDependency(MutableStateDep);
6010 if (FAILED(rc)) return rc;
6011
6012 ComObjPtr<StorageController> ctrl;
6013 rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
6014 if (FAILED(rc)) return rc;
6015
6016 {
6017 /* find all attached devices to the appropriate storage controller and detach them all */
6018 // make a temporary list because detachDevice invalidates iterators into
6019 // mMediaData->mAttachments
6020 MediaData::AttachmentList llAttachments2 = mMediaData->mAttachments;
6021
6022 for (MediaData::AttachmentList::iterator it = llAttachments2.begin();
6023 it != llAttachments2.end();
6024 ++it)
6025 {
6026 MediumAttachment *pAttachTemp = *it;
6027
6028 AutoCaller localAutoCaller(pAttachTemp);
6029 if (FAILED(localAutoCaller.rc())) return localAutoCaller.rc();
6030
6031 AutoReadLock local_alock(pAttachTemp COMMA_LOCKVAL_SRC_POS);
6032
6033 if (pAttachTemp->i_getControllerName() == aName)
6034 {
6035 rc = i_detachDevice(pAttachTemp, alock, NULL);
6036 if (FAILED(rc)) return rc;
6037 }
6038 }
6039 }
6040
6041 /* We can remove it now. */
6042 i_setModified(IsModified_Storage);
6043 mStorageControllers.backup();
6044
6045 ctrl->i_unshare();
6046
6047 mStorageControllers->remove(ctrl);
6048
6049 /* inform the direct session if any */
6050 alock.release();
6051 i_onStorageControllerChange();
6052
6053 return S_OK;
6054}
6055
6056HRESULT Machine::addUSBController(const com::Utf8Str &aName, USBControllerType_T aType,
6057 ComPtr<IUSBController> &aController)
6058{
6059 if ( (aType <= USBControllerType_Null)
6060 || (aType >= USBControllerType_Last))
6061 return setError(E_INVALIDARG,
6062 tr("Invalid USB controller type: %d"),
6063 aType);
6064
6065 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6066
6067 HRESULT rc = i_checkStateDependency(MutableStateDep);
6068 if (FAILED(rc)) return rc;
6069
6070 /* try to find one with the same type first. */
6071 ComObjPtr<USBController> ctrl;
6072
6073 rc = i_getUSBControllerByName(aName, ctrl, false /* aSetError */);
6074 if (SUCCEEDED(rc))
6075 return setError(VBOX_E_OBJECT_IN_USE,
6076 tr("USB controller named '%s' already exists"),
6077 aName.c_str());
6078
6079 /* Check that we don't exceed the maximum number of USB controllers for the given type. */
6080 ULONG maxInstances;
6081 rc = mParent->i_getSystemProperties()->GetMaxInstancesOfUSBControllerType(mHWData->mChipsetType, aType, &maxInstances);
6082 if (FAILED(rc))
6083 return rc;
6084
6085 ULONG cInstances = i_getUSBControllerCountByType(aType);
6086 if (cInstances >= maxInstances)
6087 return setError(E_INVALIDARG,
6088 tr("Too many USB controllers of this type"));
6089
6090 ctrl.createObject();
6091
6092 rc = ctrl->init(this, aName, aType);
6093 if (FAILED(rc)) return rc;
6094
6095 i_setModified(IsModified_USB);
6096 mUSBControllers.backup();
6097 mUSBControllers->push_back(ctrl);
6098
6099 ctrl.queryInterfaceTo(aController.asOutParam());
6100
6101 /* inform the direct session if any */
6102 alock.release();
6103 i_onUSBControllerChange();
6104
6105 return S_OK;
6106}
6107
6108HRESULT Machine::getUSBControllerByName(const com::Utf8Str &aName, ComPtr<IUSBController> &aController)
6109{
6110 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6111
6112 ComObjPtr<USBController> ctrl;
6113
6114 HRESULT rc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
6115 if (SUCCEEDED(rc))
6116 ctrl.queryInterfaceTo(aController.asOutParam());
6117
6118 return rc;
6119}
6120
6121HRESULT Machine::getUSBControllerCountByType(USBControllerType_T aType,
6122 ULONG *aControllers)
6123{
6124 if ( (aType <= USBControllerType_Null)
6125 || (aType >= USBControllerType_Last))
6126 return setError(E_INVALIDARG,
6127 tr("Invalid USB controller type: %d"),
6128 aType);
6129
6130 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6131
6132 ComObjPtr<USBController> ctrl;
6133
6134 *aControllers = i_getUSBControllerCountByType(aType);
6135
6136 return S_OK;
6137}
6138
6139HRESULT Machine::removeUSBController(const com::Utf8Str &aName)
6140{
6141
6142 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6143
6144 HRESULT rc = i_checkStateDependency(MutableStateDep);
6145 if (FAILED(rc)) return rc;
6146
6147 ComObjPtr<USBController> ctrl;
6148 rc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
6149 if (FAILED(rc)) return rc;
6150
6151 i_setModified(IsModified_USB);
6152 mUSBControllers.backup();
6153
6154 ctrl->i_unshare();
6155
6156 mUSBControllers->remove(ctrl);
6157
6158 /* inform the direct session if any */
6159 alock.release();
6160 i_onUSBControllerChange();
6161
6162 return S_OK;
6163}
6164
6165HRESULT Machine::querySavedGuestScreenInfo(ULONG aScreenId,
6166 ULONG *aOriginX,
6167 ULONG *aOriginY,
6168 ULONG *aWidth,
6169 ULONG *aHeight,
6170 BOOL *aEnabled)
6171{
6172 uint32_t u32OriginX= 0;
6173 uint32_t u32OriginY= 0;
6174 uint32_t u32Width = 0;
6175 uint32_t u32Height = 0;
6176 uint16_t u16Flags = 0;
6177
6178 int vrc = readSavedGuestScreenInfo(mSSData->strStateFilePath, aScreenId,
6179 &u32OriginX, &u32OriginY, &u32Width, &u32Height, &u16Flags);
6180 if (RT_FAILURE(vrc))
6181 {
6182#ifdef RT_OS_WINDOWS
6183 /* HACK: GUI sets *pfEnabled to 'true' and expects it to stay so if the API fails.
6184 * This works with XPCOM. But Windows COM sets all output parameters to zero.
6185 * So just assign fEnable to TRUE again.
6186 * The right fix would be to change GUI API wrappers to make sure that parameters
6187 * are changed only if API succeeds.
6188 */
6189 *aEnabled = TRUE;
6190#endif
6191 return setError(VBOX_E_IPRT_ERROR,
6192 tr("Saved guest size is not available (%Rrc)"),
6193 vrc);
6194 }
6195
6196 *aOriginX = u32OriginX;
6197 *aOriginY = u32OriginY;
6198 *aWidth = u32Width;
6199 *aHeight = u32Height;
6200 *aEnabled = (u16Flags & VBVA_SCREEN_F_DISABLED) == 0;
6201
6202 return S_OK;
6203}
6204
6205HRESULT Machine::querySavedThumbnailSize(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight)
6206{
6207 if (aScreenId != 0)
6208 return E_NOTIMPL;
6209
6210 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6211
6212 uint8_t *pu8Data = NULL;
6213 uint32_t cbData = 0;
6214 uint32_t u32Width = 0;
6215 uint32_t u32Height = 0;
6216
6217 int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
6218
6219 if (RT_FAILURE(vrc))
6220 return setError(VBOX_E_IPRT_ERROR,
6221 tr("Saved screenshot data is not available (%Rrc)"),
6222 vrc);
6223
6224 *aSize = cbData;
6225 *aWidth = u32Width;
6226 *aHeight = u32Height;
6227
6228 freeSavedDisplayScreenshot(pu8Data);
6229
6230 return S_OK;
6231}
6232
6233
6234HRESULT Machine::readSavedThumbnailToArray(ULONG aScreenId, BOOL aBGR, ULONG *aWidth, ULONG *aHeight, std::vector<BYTE> &aData)
6235{
6236 if (aScreenId != 0)
6237 return E_NOTIMPL;
6238
6239 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6240
6241 uint8_t *pu8Data = NULL;
6242 uint32_t cbData = 0;
6243 uint32_t u32Width = 0;
6244 uint32_t u32Height = 0;
6245
6246 int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
6247
6248 if (RT_FAILURE(vrc))
6249 return setError(VBOX_E_IPRT_ERROR,
6250 tr("Saved screenshot data is not available (%Rrc)"),
6251 vrc);
6252
6253 *aWidth = u32Width;
6254 *aHeight = u32Height;
6255
6256 com::SafeArray<BYTE> bitmap(cbData);
6257 /* Convert pixels to format expected by the API caller. */
6258 if (aBGR)
6259 {
6260 /* [0] B, [1] G, [2] R, [3] A. */
6261 for (unsigned i = 0; i < cbData; i += 4)
6262 {
6263 bitmap[i] = pu8Data[i];
6264 bitmap[i + 1] = pu8Data[i + 1];
6265 bitmap[i + 2] = pu8Data[i + 2];
6266 bitmap[i + 3] = 0xff;
6267 }
6268 }
6269 else
6270 {
6271 /* [0] R, [1] G, [2] B, [3] A. */
6272 for (unsigned i = 0; i < cbData; i += 4)
6273 {
6274 bitmap[i] = pu8Data[i + 2];
6275 bitmap[i + 1] = pu8Data[i + 1];
6276 bitmap[i + 2] = pu8Data[i];
6277 bitmap[i + 3] = 0xff;
6278 }
6279 }
6280 aData.resize(bitmap.size());
6281 for (size_t i = 0; i < bitmap.size(); ++i)
6282 aData[i] = bitmap[i];
6283
6284 freeSavedDisplayScreenshot(pu8Data);
6285
6286 return S_OK;
6287}
6288
6289HRESULT Machine::readSavedThumbnailPNGToArray(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, std::vector<BYTE> &aData)
6290{
6291 if (aScreenId != 0)
6292 return E_NOTIMPL;
6293
6294 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6295
6296 uint8_t *pu8Data = NULL;
6297 uint32_t cbData = 0;
6298 uint32_t u32Width = 0;
6299 uint32_t u32Height = 0;
6300
6301 int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
6302
6303 if (RT_FAILURE(vrc))
6304 return setError(VBOX_E_IPRT_ERROR,
6305 tr("Saved screenshot data is not available (%Rrc)"),
6306 vrc);
6307
6308 *aWidth = u32Width;
6309 *aHeight = u32Height;
6310
6311 HRESULT rc = S_OK;
6312 uint8_t *pu8PNG = NULL;
6313 uint32_t cbPNG = 0;
6314 uint32_t cxPNG = 0;
6315 uint32_t cyPNG = 0;
6316
6317 vrc = DisplayMakePNG(pu8Data, u32Width, u32Height, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
6318
6319 if (RT_SUCCESS(vrc))
6320 {
6321 com::SafeArray<BYTE> screenData(cbPNG);
6322 screenData.initFrom(pu8PNG, cbPNG);
6323 if (pu8PNG)
6324 RTMemFree(pu8PNG);
6325 aData.resize(screenData.size());
6326 for (size_t i = 0; i < screenData.size(); ++i)
6327 aData[i] = screenData[i];
6328 }
6329 else
6330 {
6331 if (pu8PNG)
6332 RTMemFree(pu8PNG);
6333 return setError(VBOX_E_IPRT_ERROR,
6334 tr("Could not convert screenshot to PNG (%Rrc)"),
6335 vrc);
6336 }
6337
6338 freeSavedDisplayScreenshot(pu8Data);
6339
6340 return rc;
6341}
6342
6343HRESULT Machine::querySavedScreenshotPNGSize(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight)
6344{
6345 if (aScreenId != 0)
6346 return E_NOTIMPL;
6347
6348 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6349
6350 uint8_t *pu8Data = NULL;
6351 uint32_t cbData = 0;
6352 uint32_t u32Width = 0;
6353 uint32_t u32Height = 0;
6354
6355 int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
6356
6357 if (RT_FAILURE(vrc))
6358 return setError(VBOX_E_IPRT_ERROR,
6359 tr("Saved screenshot data is not available (%Rrc)"),
6360 vrc);
6361
6362 *aSize = cbData;
6363 *aWidth = u32Width;
6364 *aHeight = u32Height;
6365
6366 freeSavedDisplayScreenshot(pu8Data);
6367
6368 return S_OK;
6369}
6370
6371HRESULT Machine::readSavedScreenshotPNGToArray(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, std::vector<BYTE> &aData)
6372{
6373 if (aScreenId != 0)
6374 return E_NOTIMPL;
6375
6376 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6377
6378 uint8_t *pu8Data = NULL;
6379 uint32_t cbData = 0;
6380 uint32_t u32Width = 0;
6381 uint32_t u32Height = 0;
6382
6383 int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
6384
6385 if (RT_FAILURE(vrc))
6386 return setError(VBOX_E_IPRT_ERROR,
6387 tr("Saved screenshot thumbnail data is not available (%Rrc)"),
6388 vrc);
6389
6390 *aWidth = u32Width;
6391 *aHeight = u32Height;
6392
6393 com::SafeArray<BYTE> png(cbData);
6394 png.initFrom(pu8Data, cbData);
6395 aData.resize(png.size());
6396 for (size_t i = 0; i < png.size(); ++i)
6397 aData[i] = png[i];
6398
6399 freeSavedDisplayScreenshot(pu8Data);
6400
6401 return S_OK;
6402}
6403
6404HRESULT Machine::hotPlugCPU(ULONG aCpu)
6405{
6406 HRESULT rc = S_OK;
6407 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6408
6409 if (!mHWData->mCPUHotPlugEnabled)
6410 return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
6411
6412 if (aCpu >= mHWData->mCPUCount)
6413 return setError(E_INVALIDARG, tr("CPU id exceeds number of possible CPUs [0:%lu]"), mHWData->mCPUCount-1);
6414
6415 if (mHWData->mCPUAttached[aCpu])
6416 return setError(VBOX_E_OBJECT_IN_USE, tr("CPU %lu is already attached"), aCpu);
6417
6418 alock.release();
6419 rc = i_onCPUChange(aCpu, false);
6420 alock.acquire();
6421 if (FAILED(rc)) return rc;
6422
6423 i_setModified(IsModified_MachineData);
6424 mHWData.backup();
6425 mHWData->mCPUAttached[aCpu] = true;
6426
6427 /** Save settings if online - @todo why is this required? -- @bugref{6818} */
6428 if (Global::IsOnline(mData->mMachineState))
6429 i_saveSettings(NULL);
6430
6431 return S_OK;
6432}
6433
6434HRESULT Machine::hotUnplugCPU(ULONG aCpu)
6435{
6436 HRESULT rc = S_OK;
6437
6438 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6439
6440 if (!mHWData->mCPUHotPlugEnabled)
6441 return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
6442
6443 if (aCpu >= SchemaDefs::MaxCPUCount)
6444 return setError(E_INVALIDARG,
6445 tr("CPU index exceeds maximum CPU count (must be in range [0:%lu])"),
6446 SchemaDefs::MaxCPUCount);
6447
6448 if (!mHWData->mCPUAttached[aCpu])
6449 return setError(VBOX_E_OBJECT_NOT_FOUND, tr("CPU %lu is not attached"), aCpu);
6450
6451 /* CPU 0 can't be detached */
6452 if (aCpu == 0)
6453 return setError(E_INVALIDARG, tr("It is not possible to detach CPU 0"));
6454
6455 alock.release();
6456 rc = i_onCPUChange(aCpu, true);
6457 alock.acquire();
6458 if (FAILED(rc)) return rc;
6459
6460 i_setModified(IsModified_MachineData);
6461 mHWData.backup();
6462 mHWData->mCPUAttached[aCpu] = false;
6463
6464 /** Save settings if online - @todo why is this required? -- @bugref{6818} */
6465 if (Global::IsOnline(mData->mMachineState))
6466 i_saveSettings(NULL);
6467
6468 return S_OK;
6469}
6470
6471HRESULT Machine::getCPUStatus(ULONG aCpu, BOOL *aAttached)
6472{
6473 *aAttached = false;
6474
6475 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6476
6477 /* If hotplug is enabled the CPU is always enabled. */
6478 if (!mHWData->mCPUHotPlugEnabled)
6479 {
6480 if (aCpu < mHWData->mCPUCount)
6481 *aAttached = true;
6482 }
6483 else
6484 {
6485 if (aCpu < SchemaDefs::MaxCPUCount)
6486 *aAttached = mHWData->mCPUAttached[aCpu];
6487 }
6488
6489 return S_OK;
6490}
6491
6492HRESULT Machine::queryLogFilename(ULONG aIdx, com::Utf8Str &aFilename)
6493{
6494 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6495
6496 Utf8Str log = i_queryLogFilename(aIdx);
6497 if (!RTFileExists(log.c_str()))
6498 log.setNull();
6499 aFilename = log;
6500
6501 return S_OK;
6502}
6503
6504HRESULT Machine::readLog(ULONG aIdx, LONG64 aOffset, LONG64 aSize, std::vector<BYTE> &aData)
6505{
6506 if (aSize < 0)
6507 return setError(E_INVALIDARG, tr("The size argument (%lld) is negative"), aSize);
6508
6509 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6510
6511 HRESULT rc = S_OK;
6512 Utf8Str log = i_queryLogFilename(aIdx);
6513
6514 /* do not unnecessarily hold the lock while doing something which does
6515 * not need the lock and potentially takes a long time. */
6516 alock.release();
6517
6518 /* Limit the chunk size to 32K for now, as that gives better performance
6519 * over (XP)COM, and keeps the SOAP reply size under 1M for the webservice.
6520 * One byte expands to approx. 25 bytes of breathtaking XML. */
6521 size_t cbData = (size_t)RT_MIN(aSize, 32768);
6522 com::SafeArray<BYTE> logData(cbData);
6523
6524 RTFILE LogFile;
6525 int vrc = RTFileOpen(&LogFile, log.c_str(),
6526 RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE);
6527 if (RT_SUCCESS(vrc))
6528 {
6529 vrc = RTFileReadAt(LogFile, aOffset, logData.raw(), cbData, &cbData);
6530 if (RT_SUCCESS(vrc))
6531 logData.resize(cbData);
6532 else
6533 rc = setError(VBOX_E_IPRT_ERROR,
6534 tr("Could not read log file '%s' (%Rrc)"),
6535 log.c_str(), vrc);
6536 RTFileClose(LogFile);
6537 }
6538 else
6539 rc = setError(VBOX_E_IPRT_ERROR,
6540 tr("Could not open log file '%s' (%Rrc)"),
6541 log.c_str(), vrc);
6542
6543 if (FAILED(rc))
6544 logData.resize(0);
6545
6546 aData.resize(logData.size());
6547 for (size_t i = 0; i < logData.size(); ++i)
6548 aData[i] = logData[i];
6549
6550 return rc;
6551}
6552
6553
6554/**
6555 * Currently this method doesn't attach device to the running VM,
6556 * just makes sure it's plugged on next VM start.
6557 */
6558HRESULT Machine::attachHostPCIDevice(LONG aHostAddress, LONG aDesiredGuestAddress, BOOL /* aTryToUnbind */)
6559{
6560 // lock scope
6561 {
6562 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6563
6564 HRESULT rc = i_checkStateDependency(MutableStateDep);
6565 if (FAILED(rc)) return rc;
6566
6567 ChipsetType_T aChipset = ChipsetType_PIIX3;
6568 COMGETTER(ChipsetType)(&aChipset);
6569
6570 if (aChipset != ChipsetType_ICH9)
6571 {
6572 return setError(E_INVALIDARG,
6573 tr("Host PCI attachment only supported with ICH9 chipset"));
6574 }
6575
6576 // check if device with this host PCI address already attached
6577 for (HWData::PCIDeviceAssignmentList::iterator it = mHWData->mPCIDeviceAssignments.begin();
6578 it != mHWData->mPCIDeviceAssignments.end();
6579 ++it)
6580 {
6581 LONG iHostAddress = -1;
6582 ComPtr<PCIDeviceAttachment> pAttach;
6583 pAttach = *it;
6584 pAttach->COMGETTER(HostAddress)(&iHostAddress);
6585 if (iHostAddress == aHostAddress)
6586 return setError(E_INVALIDARG,
6587 tr("Device with host PCI address already attached to this VM"));
6588 }
6589
6590 ComObjPtr<PCIDeviceAttachment> pda;
6591 char name[32];
6592
6593 RTStrPrintf(name, sizeof(name), "host%02x:%02x.%x", (aHostAddress>>8) & 0xff,
6594 (aHostAddress & 0xf8) >> 3, aHostAddress & 7);
6595 Bstr bname(name);
6596 pda.createObject();
6597 pda->init(this, bname, aHostAddress, aDesiredGuestAddress, TRUE);
6598 i_setModified(IsModified_MachineData);
6599 mHWData.backup();
6600 mHWData->mPCIDeviceAssignments.push_back(pda);
6601 }
6602
6603 return S_OK;
6604}
6605
6606/**
6607 * Currently this method doesn't detach device from the running VM,
6608 * just makes sure it's not plugged on next VM start.
6609 */
6610HRESULT Machine::detachHostPCIDevice(LONG aHostAddress)
6611{
6612 ComObjPtr<PCIDeviceAttachment> pAttach;
6613 bool fRemoved = false;
6614 HRESULT rc;
6615
6616 // lock scope
6617 {
6618 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6619
6620 rc = i_checkStateDependency(MutableStateDep);
6621 if (FAILED(rc)) return rc;
6622
6623 for (HWData::PCIDeviceAssignmentList::iterator it = mHWData->mPCIDeviceAssignments.begin();
6624 it != mHWData->mPCIDeviceAssignments.end();
6625 ++it)
6626 {
6627 LONG iHostAddress = -1;
6628 pAttach = *it;
6629 pAttach->COMGETTER(HostAddress)(&iHostAddress);
6630 if (iHostAddress != -1 && iHostAddress == aHostAddress)
6631 {
6632 i_setModified(IsModified_MachineData);
6633 mHWData.backup();
6634 mHWData->mPCIDeviceAssignments.remove(pAttach);
6635 fRemoved = true;
6636 break;
6637 }
6638 }
6639 }
6640
6641
6642 /* Fire event outside of the lock */
6643 if (fRemoved)
6644 {
6645 Assert(!pAttach.isNull());
6646 ComPtr<IEventSource> es;
6647 rc = mParent->COMGETTER(EventSource)(es.asOutParam());
6648 Assert(SUCCEEDED(rc));
6649 Bstr mid;
6650 rc = this->COMGETTER(Id)(mid.asOutParam());
6651 Assert(SUCCEEDED(rc));
6652 fireHostPCIDevicePlugEvent(es, mid.raw(), false /* unplugged */, true /* success */, pAttach, NULL);
6653 }
6654
6655 return fRemoved ? S_OK : setError(VBOX_E_OBJECT_NOT_FOUND,
6656 tr("No host PCI device %08x attached"),
6657 aHostAddress
6658 );
6659}
6660
6661HRESULT Machine::getPCIDeviceAssignments(std::vector<ComPtr<IPCIDeviceAttachment> > &aPCIDeviceAssignments)
6662{
6663 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6664
6665 aPCIDeviceAssignments.resize(mHWData->mPCIDeviceAssignments.size());
6666
6667 size_t i = 0;
6668 for (std::list<ComObjPtr<PCIDeviceAttachment> >::const_iterator it = mHWData->mPCIDeviceAssignments.begin();
6669 it != mHWData->mPCIDeviceAssignments.end();
6670 ++i, ++it)
6671 (*it).queryInterfaceTo(aPCIDeviceAssignments[i].asOutParam());
6672
6673 return S_OK;
6674}
6675
6676HRESULT Machine::getBandwidthControl(ComPtr<IBandwidthControl> &aBandwidthControl)
6677{
6678 mBandwidthControl.queryInterfaceTo(aBandwidthControl.asOutParam());
6679
6680 return S_OK;
6681}
6682
6683HRESULT Machine::getTracingEnabled(BOOL *aTracingEnabled)
6684{
6685 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6686
6687 *aTracingEnabled = mHWData->mDebugging.fTracingEnabled;
6688
6689 return S_OK;
6690}
6691
6692HRESULT Machine::setTracingEnabled(BOOL aTracingEnabled)
6693{
6694 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6695 HRESULT hrc = i_checkStateDependency(MutableStateDep);
6696 if (SUCCEEDED(hrc))
6697 {
6698 hrc = mHWData.backupEx();
6699 if (SUCCEEDED(hrc))
6700 {
6701 i_setModified(IsModified_MachineData);
6702 mHWData->mDebugging.fTracingEnabled = aTracingEnabled != FALSE;
6703 }
6704 }
6705 return hrc;
6706}
6707
6708HRESULT Machine::getTracingConfig(com::Utf8Str &aTracingConfig)
6709{
6710 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6711 aTracingConfig = mHWData->mDebugging.strTracingConfig;
6712 return S_OK;
6713}
6714
6715HRESULT Machine::setTracingConfig(const com::Utf8Str &aTracingConfig)
6716{
6717 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6718 HRESULT hrc = i_checkStateDependency(MutableStateDep);
6719 if (SUCCEEDED(hrc))
6720 {
6721 hrc = mHWData.backupEx();
6722 if (SUCCEEDED(hrc))
6723 {
6724 mHWData->mDebugging.strTracingConfig = aTracingConfig;
6725 if (SUCCEEDED(hrc))
6726 i_setModified(IsModified_MachineData);
6727 }
6728 }
6729 return hrc;
6730}
6731
6732HRESULT Machine::getAllowTracingToAccessVM(BOOL *aAllowTracingToAccessVM)
6733{
6734 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6735
6736 *aAllowTracingToAccessVM = mHWData->mDebugging.fAllowTracingToAccessVM;
6737
6738 return S_OK;
6739}
6740
6741HRESULT Machine::setAllowTracingToAccessVM(BOOL aAllowTracingToAccessVM)
6742{
6743 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6744 HRESULT hrc = i_checkStateDependency(MutableStateDep);
6745 if (SUCCEEDED(hrc))
6746 {
6747 hrc = mHWData.backupEx();
6748 if (SUCCEEDED(hrc))
6749 {
6750 i_setModified(IsModified_MachineData);
6751 mHWData->mDebugging.fAllowTracingToAccessVM = aAllowTracingToAccessVM != FALSE;
6752 }
6753 }
6754 return hrc;
6755}
6756
6757HRESULT Machine::getAutostartEnabled(BOOL *aAutostartEnabled)
6758{
6759 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6760
6761 *aAutostartEnabled = mHWData->mAutostart.fAutostartEnabled;
6762
6763 return S_OK;
6764}
6765
6766HRESULT Machine::setAutostartEnabled(BOOL aAutostartEnabled)
6767{
6768 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6769
6770 HRESULT hrc = i_checkStateDependency(MutableStateDep);
6771 if ( SUCCEEDED(hrc)
6772 && mHWData->mAutostart.fAutostartEnabled != !!aAutostartEnabled)
6773 {
6774 AutostartDb *autostartDb = mParent->i_getAutostartDb();
6775 int vrc;
6776
6777 if (aAutostartEnabled)
6778 vrc = autostartDb->addAutostartVM(mUserData->s.strName.c_str());
6779 else
6780 vrc = autostartDb->removeAutostartVM(mUserData->s.strName.c_str());
6781
6782 if (RT_SUCCESS(vrc))
6783 {
6784 hrc = mHWData.backupEx();
6785 if (SUCCEEDED(hrc))
6786 {
6787 i_setModified(IsModified_MachineData);
6788 mHWData->mAutostart.fAutostartEnabled = aAutostartEnabled != FALSE;
6789 }
6790 }
6791 else if (vrc == VERR_NOT_SUPPORTED)
6792 hrc = setError(VBOX_E_NOT_SUPPORTED,
6793 tr("The VM autostart feature is not supported on this platform"));
6794 else if (vrc == VERR_PATH_NOT_FOUND)
6795 hrc = setError(E_FAIL,
6796 tr("The path to the autostart database is not set"));
6797 else
6798 hrc = setError(E_UNEXPECTED,
6799 tr("%s machine '%s' to the autostart database failed with %Rrc"),
6800 aAutostartEnabled ? "Adding" : "Removing",
6801 mUserData->s.strName.c_str(), vrc);
6802 }
6803 return hrc;
6804}
6805
6806HRESULT Machine::getAutostartDelay(ULONG *aAutostartDelay)
6807{
6808 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6809
6810 *aAutostartDelay = mHWData->mAutostart.uAutostartDelay;
6811
6812 return S_OK;
6813}
6814
6815HRESULT Machine::setAutostartDelay(ULONG aAutostartDelay)
6816{
6817 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6818 HRESULT hrc = i_checkStateDependency(MutableStateDep);
6819 if (SUCCEEDED(hrc))
6820 {
6821 hrc = mHWData.backupEx();
6822 if (SUCCEEDED(hrc))
6823 {
6824 i_setModified(IsModified_MachineData);
6825 mHWData->mAutostart.uAutostartDelay = aAutostartDelay;
6826 }
6827 }
6828 return hrc;
6829}
6830
6831HRESULT Machine::getAutostopType(AutostopType_T *aAutostopType)
6832{
6833 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6834
6835 *aAutostopType = mHWData->mAutostart.enmAutostopType;
6836
6837 return S_OK;
6838}
6839
6840HRESULT Machine::setAutostopType(AutostopType_T aAutostopType)
6841{
6842 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6843 HRESULT hrc = i_checkStateDependency(MutableStateDep);
6844 if ( SUCCEEDED(hrc)
6845 && mHWData->mAutostart.enmAutostopType != aAutostopType)
6846 {
6847 AutostartDb *autostartDb = mParent->i_getAutostartDb();
6848 int vrc;
6849
6850 if (aAutostopType != AutostopType_Disabled)
6851 vrc = autostartDb->addAutostopVM(mUserData->s.strName.c_str());
6852 else
6853 vrc = autostartDb->removeAutostopVM(mUserData->s.strName.c_str());
6854
6855 if (RT_SUCCESS(vrc))
6856 {
6857 hrc = mHWData.backupEx();
6858 if (SUCCEEDED(hrc))
6859 {
6860 i_setModified(IsModified_MachineData);
6861 mHWData->mAutostart.enmAutostopType = aAutostopType;
6862 }
6863 }
6864 else if (vrc == VERR_NOT_SUPPORTED)
6865 hrc = setError(VBOX_E_NOT_SUPPORTED,
6866 tr("The VM autostop feature is not supported on this platform"));
6867 else if (vrc == VERR_PATH_NOT_FOUND)
6868 hrc = setError(E_FAIL,
6869 tr("The path to the autostart database is not set"));
6870 else
6871 hrc = setError(E_UNEXPECTED,
6872 tr("%s machine '%s' to the autostop database failed with %Rrc"),
6873 aAutostopType != AutostopType_Disabled ? "Adding" : "Removing",
6874 mUserData->s.strName.c_str(), vrc);
6875 }
6876 return hrc;
6877}
6878
6879HRESULT Machine::getDefaultFrontend(com::Utf8Str &aDefaultFrontend)
6880{
6881 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6882
6883 aDefaultFrontend = mHWData->mDefaultFrontend;
6884
6885 return S_OK;
6886}
6887
6888HRESULT Machine::setDefaultFrontend(const com::Utf8Str &aDefaultFrontend)
6889{
6890 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6891 HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
6892 if (SUCCEEDED(hrc))
6893 {
6894 hrc = mHWData.backupEx();
6895 if (SUCCEEDED(hrc))
6896 {
6897 i_setModified(IsModified_MachineData);
6898 mHWData->mDefaultFrontend = aDefaultFrontend;
6899 }
6900 }
6901 return hrc;
6902}
6903
6904HRESULT Machine::getIcon(std::vector<BYTE> &aIcon)
6905{
6906 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6907 com::SafeArray<BYTE> icon(mUserData->mIcon.size());
6908 aIcon.resize(mUserData->mIcon.size());
6909 memcpy(icon.raw(), &mUserData->mIcon[0], mUserData->mIcon.size());
6910 aIcon.resize(icon.size());
6911 for (size_t i = 0; i < icon.size(); ++i)
6912 aIcon[i] = icon[i];
6913 return S_OK;
6914}
6915
6916HRESULT Machine::setIcon(const std::vector<BYTE> &aIcon)
6917{
6918 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6919 HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
6920 if (SUCCEEDED(hrc))
6921 {
6922 i_setModified(IsModified_MachineData);
6923 mUserData.backup();
6924 com::SafeArray<BYTE> icon(aIcon);
6925 mUserData->mIcon.resize(aIcon.size());
6926 memcpy(&mUserData->mIcon[0], icon.raw(), mUserData->mIcon.size());
6927 }
6928 return hrc;
6929}
6930
6931HRESULT Machine::getUSBProxyAvailable(BOOL *aUSBProxyAvailable)
6932{
6933
6934#ifdef VBOX_WITH_USB
6935 *aUSBProxyAvailable = true;
6936#else
6937 *aUSBProxyAvailable = false;
6938#endif
6939 return S_OK;
6940}
6941
6942HRESULT Machine::cloneTo(const ComPtr<IMachine> &aTarget, CloneMode_T aMode, const std::vector<CloneOptions_T> &aOptions,
6943 ComPtr<IProgress> &aProgress)
6944{
6945 ComObjPtr<Progress> pP;
6946 Progress *ppP = pP;
6947 IProgress *iP = static_cast<IProgress *>(ppP);
6948 IProgress **pProgress = &iP;
6949
6950 IMachine *pTarget = aTarget;
6951
6952 /* Convert the options. */
6953 RTCList<CloneOptions_T> optList;
6954 if (aOptions.size())
6955 for (size_t i = 0; i < aOptions.size(); ++i)
6956 optList.append(aOptions[i]);
6957
6958 if (optList.contains(CloneOptions_Link))
6959 {
6960 if (!i_isSnapshotMachine())
6961 return setError(E_INVALIDARG,
6962 tr("Linked clone can only be created from a snapshot"));
6963 if (aMode != CloneMode_MachineState)
6964 return setError(E_INVALIDARG,
6965 tr("Linked clone can only be created for a single machine state"));
6966 }
6967 AssertReturn(!(optList.contains(CloneOptions_KeepAllMACs) && optList.contains(CloneOptions_KeepNATMACs)), E_INVALIDARG);
6968
6969 MachineCloneVM *pWorker = new MachineCloneVM(this, static_cast<Machine*>(pTarget), aMode, optList);
6970
6971 HRESULT rc = pWorker->start(pProgress);
6972
6973 pP = static_cast<Progress *>(*pProgress);
6974 pP.queryInterfaceTo(aProgress.asOutParam());
6975
6976 return rc;
6977
6978}
6979
6980// public methods for internal purposes
6981/////////////////////////////////////////////////////////////////////////////
6982
6983/**
6984 * Adds the given IsModified_* flag to the dirty flags of the machine.
6985 * This must be called either during i_loadSettings or under the machine write lock.
6986 * @param fl
6987 */
6988void Machine::i_setModified(uint32_t fl, bool fAllowStateModification /* = true */)
6989{
6990 mData->flModifications |= fl;
6991 if (fAllowStateModification && i_isStateModificationAllowed())
6992 mData->mCurrentStateModified = true;
6993}
6994
6995/**
6996 * Adds the given IsModified_* flag to the dirty flags of the machine, taking
6997 * care of the write locking.
6998 *
6999 * @param fModifications The flag to add.
7000 */
7001void Machine::i_setModifiedLock(uint32_t fModification, bool fAllowStateModification /* = true */)
7002{
7003 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7004 i_setModified(fModification, fAllowStateModification);
7005}
7006
7007/**
7008 * Saves the registry entry of this machine to the given configuration node.
7009 *
7010 * @param aEntryNode Node to save the registry entry to.
7011 *
7012 * @note locks this object for reading.
7013 */
7014HRESULT Machine::i_saveRegistryEntry(settings::MachineRegistryEntry &data)
7015{
7016 AutoLimitedCaller autoCaller(this);
7017 AssertComRCReturnRC(autoCaller.rc());
7018
7019 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7020
7021 data.uuid = mData->mUuid;
7022 data.strSettingsFile = mData->m_strConfigFile;
7023
7024 return S_OK;
7025}
7026
7027/**
7028 * Calculates the absolute path of the given path taking the directory of the
7029 * machine settings file as the current directory.
7030 *
7031 * @param aPath Path to calculate the absolute path for.
7032 * @param aResult Where to put the result (used only on success, can be the
7033 * same Utf8Str instance as passed in @a aPath).
7034 * @return IPRT result.
7035 *
7036 * @note Locks this object for reading.
7037 */
7038int Machine::i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult)
7039{
7040 AutoCaller autoCaller(this);
7041 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
7042
7043 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7044
7045 AssertReturn(!mData->m_strConfigFileFull.isEmpty(), VERR_GENERAL_FAILURE);
7046
7047 Utf8Str strSettingsDir = mData->m_strConfigFileFull;
7048
7049 strSettingsDir.stripFilename();
7050 char folder[RTPATH_MAX];
7051 int vrc = RTPathAbsEx(strSettingsDir.c_str(), strPath.c_str(), folder, sizeof(folder));
7052 if (RT_SUCCESS(vrc))
7053 aResult = folder;
7054
7055 return vrc;
7056}
7057
7058/**
7059 * Copies strSource to strTarget, making it relative to the machine folder
7060 * if it is a subdirectory thereof, or simply copying it otherwise.
7061 *
7062 * @param strSource Path to evaluate and copy.
7063 * @param strTarget Buffer to receive target path.
7064 *
7065 * @note Locks this object for reading.
7066 */
7067void Machine::i_copyPathRelativeToMachine(const Utf8Str &strSource,
7068 Utf8Str &strTarget)
7069{
7070 AutoCaller autoCaller(this);
7071 AssertComRCReturn(autoCaller.rc(), (void)0);
7072
7073 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7074
7075 AssertReturnVoid(!mData->m_strConfigFileFull.isEmpty());
7076 // use strTarget as a temporary buffer to hold the machine settings dir
7077 strTarget = mData->m_strConfigFileFull;
7078 strTarget.stripFilename();
7079 if (RTPathStartsWith(strSource.c_str(), strTarget.c_str()))
7080 {
7081 // is relative: then append what's left
7082 strTarget = strSource.substr(strTarget.length() + 1); // skip '/'
7083 // for empty paths (only possible for subdirs) use "." to avoid
7084 // triggering default settings for not present config attributes.
7085 if (strTarget.isEmpty())
7086 strTarget = ".";
7087 }
7088 else
7089 // is not relative: then overwrite
7090 strTarget = strSource;
7091}
7092
7093/**
7094 * Returns the full path to the machine's log folder in the
7095 * \a aLogFolder argument.
7096 */
7097void Machine::i_getLogFolder(Utf8Str &aLogFolder)
7098{
7099 AutoCaller autoCaller(this);
7100 AssertComRCReturnVoid(autoCaller.rc());
7101
7102 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7103
7104 char szTmp[RTPATH_MAX];
7105 int vrc = RTEnvGetEx(RTENV_DEFAULT, "VBOX_USER_VMLOGDIR", szTmp, sizeof(szTmp), NULL);
7106 if (RT_SUCCESS(vrc))
7107 {
7108 if (szTmp[0] && !mUserData.isNull())
7109 {
7110 char szTmp2[RTPATH_MAX];
7111 vrc = RTPathAbs(szTmp, szTmp2, sizeof(szTmp2));
7112 if (RT_SUCCESS(vrc))
7113 aLogFolder = BstrFmt("%s%c%s",
7114 szTmp2,
7115 RTPATH_DELIMITER,
7116 mUserData->s.strName.c_str()); // path/to/logfolder/vmname
7117 }
7118 else
7119 vrc = VERR_PATH_IS_RELATIVE;
7120 }
7121
7122 if (RT_FAILURE(vrc))
7123 {
7124 // fallback if VBOX_USER_LOGHOME is not set or invalid
7125 aLogFolder = mData->m_strConfigFileFull; // path/to/machinesfolder/vmname/vmname.vbox
7126 aLogFolder.stripFilename(); // path/to/machinesfolder/vmname
7127 aLogFolder.append(RTPATH_DELIMITER);
7128 aLogFolder.append("Logs"); // path/to/machinesfolder/vmname/Logs
7129 }
7130}
7131
7132/**
7133 * Returns the full path to the machine's log file for an given index.
7134 */
7135Utf8Str Machine::i_queryLogFilename(ULONG idx) /** @todo r=bird: Misnamed. Should be i_getLogFilename as it cannot fail. See VBox-CodingGuidelines.cpp, Compulsory seciont, line 79. */
7136{
7137 Utf8Str logFolder;
7138 getLogFolder(logFolder);
7139 Assert(logFolder.length());
7140 Utf8Str log;
7141 if (idx == 0)
7142 log = Utf8StrFmt("%s%cVBox.log",
7143 logFolder.c_str(), RTPATH_DELIMITER);
7144 else
7145 log = Utf8StrFmt("%s%cVBox.log.%d",
7146 logFolder.c_str(), RTPATH_DELIMITER, idx);
7147 return log;
7148}
7149
7150/**
7151 * Returns the full path to the machine's (hardened) startup log file.
7152 */
7153Utf8Str Machine::i_getStartupLogFilename(void)
7154{
7155 Utf8Str strFilename;
7156 getLogFolder(strFilename);
7157 Assert(strFilename.length());
7158 strFilename.append(RTPATH_SLASH_STR "VBoxStartup.log");
7159 return strFilename;
7160}
7161
7162
7163/**
7164 * Composes a unique saved state filename based on the current system time. The filename is
7165 * granular to the second so this will work so long as no more than one snapshot is taken on
7166 * a machine per second.
7167 *
7168 * Before version 4.1, we used this formula for saved state files:
7169 * Utf8StrFmt("%s%c{%RTuuid}.sav", strFullSnapshotFolder.c_str(), RTPATH_DELIMITER, mData->mUuid.raw())
7170 * which no longer works because saved state files can now be shared between the saved state of the
7171 * "saved" machine and an online snapshot, and the following would cause problems:
7172 * 1) save machine
7173 * 2) create online snapshot from that machine state --> reusing saved state file
7174 * 3) save machine again --> filename would be reused, breaking the online snapshot
7175 *
7176 * So instead we now use a timestamp.
7177 *
7178 * @param str
7179 */
7180
7181void Machine::i_composeSavedStateFilename(Utf8Str &strStateFilePath)
7182{
7183 AutoCaller autoCaller(this);
7184 AssertComRCReturnVoid(autoCaller.rc());
7185
7186 {
7187 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7188 i_calculateFullPath(mUserData->s.strSnapshotFolder, strStateFilePath);
7189 }
7190
7191 RTTIMESPEC ts;
7192 RTTimeNow(&ts);
7193 RTTIME time;
7194 RTTimeExplode(&time, &ts);
7195
7196 strStateFilePath += RTPATH_DELIMITER;
7197 strStateFilePath += Utf8StrFmt("%04d-%02u-%02uT%02u-%02u-%02u-%09uZ.sav",
7198 time.i32Year, time.u8Month, time.u8MonthDay,
7199 time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond);
7200}
7201
7202/**
7203 * Returns the full path to the default video capture file.
7204 */
7205void Machine::i_getDefaultVideoCaptureFile(Utf8Str &strFile)
7206{
7207 AutoCaller autoCaller(this);
7208 AssertComRCReturnVoid(autoCaller.rc());
7209
7210 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7211
7212 strFile = mData->m_strConfigFileFull; // path/to/machinesfolder/vmname/vmname.vbox
7213 strFile.stripSuffix(); // path/to/machinesfolder/vmname/vmname
7214 strFile.append(".webm"); // path/to/machinesfolder/vmname/vmname.webm
7215}
7216
7217/**
7218 * Returns whether at least one USB controller is present for the VM.
7219 */
7220bool Machine::i_isUSBControllerPresent()
7221{
7222 AutoCaller autoCaller(this);
7223 AssertComRCReturn(autoCaller.rc(), false);
7224
7225 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7226
7227 return (mUSBControllers->size() > 0);
7228}
7229
7230/**
7231 * @note Locks this object for writing, calls the client process
7232 * (inside the lock).
7233 */
7234HRESULT Machine::i_launchVMProcess(IInternalSessionControl *aControl,
7235 const Utf8Str &strFrontend,
7236 const Utf8Str &strEnvironment,
7237 ProgressProxy *aProgress)
7238{
7239 LogFlowThisFuncEnter();
7240
7241 AssertReturn(aControl, E_FAIL);
7242 AssertReturn(aProgress, E_FAIL);
7243 AssertReturn(!strFrontend.isEmpty(), E_FAIL);
7244
7245 AutoCaller autoCaller(this);
7246 if (FAILED(autoCaller.rc())) return autoCaller.rc();
7247
7248 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7249
7250 if (!mData->mRegistered)
7251 return setError(E_UNEXPECTED,
7252 tr("The machine '%s' is not registered"),
7253 mUserData->s.strName.c_str());
7254
7255 LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
7256
7257 if ( mData->mSession.mState == SessionState_Locked
7258 || mData->mSession.mState == SessionState_Spawning
7259 || mData->mSession.mState == SessionState_Unlocking)
7260 return setError(VBOX_E_INVALID_OBJECT_STATE,
7261 tr("The machine '%s' is already locked by a session (or being locked or unlocked)"),
7262 mUserData->s.strName.c_str());
7263
7264 /* may not be busy */
7265 AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
7266
7267 /* get the path to the executable */
7268 char szPath[RTPATH_MAX];
7269 RTPathAppPrivateArch(szPath, sizeof(szPath) - 1);
7270 size_t cchBufLeft = strlen(szPath);
7271 szPath[cchBufLeft++] = RTPATH_DELIMITER;
7272 szPath[cchBufLeft] = 0;
7273 char *pszNamePart = szPath + cchBufLeft;
7274 cchBufLeft = sizeof(szPath) - cchBufLeft;
7275
7276 int vrc = VINF_SUCCESS;
7277 RTPROCESS pid = NIL_RTPROCESS;
7278
7279 RTENV env = RTENV_DEFAULT;
7280
7281 if (!strEnvironment.isEmpty())
7282 {
7283 char *newEnvStr = NULL;
7284
7285 do
7286 {
7287 /* clone the current environment */
7288 int vrc2 = RTEnvClone(&env, RTENV_DEFAULT);
7289 AssertRCBreakStmt(vrc2, vrc = vrc2);
7290
7291 newEnvStr = RTStrDup(strEnvironment.c_str());
7292 AssertPtrBreakStmt(newEnvStr, vrc = vrc2);
7293
7294 /* put new variables to the environment
7295 * (ignore empty variable names here since RTEnv API
7296 * intentionally doesn't do that) */
7297 char *var = newEnvStr;
7298 for (char *p = newEnvStr; *p; ++p)
7299 {
7300 if (*p == '\n' && (p == newEnvStr || *(p - 1) != '\\'))
7301 {
7302 *p = '\0';
7303 if (*var)
7304 {
7305 char *val = strchr(var, '=');
7306 if (val)
7307 {
7308 *val++ = '\0';
7309 vrc2 = RTEnvSetEx(env, var, val);
7310 }
7311 else
7312 vrc2 = RTEnvUnsetEx(env, var);
7313 if (RT_FAILURE(vrc2))
7314 break;
7315 }
7316 var = p + 1;
7317 }
7318 }
7319 if (RT_SUCCESS(vrc2) && *var)
7320 vrc2 = RTEnvPutEx(env, var);
7321
7322 AssertRCBreakStmt(vrc2, vrc = vrc2);
7323 }
7324 while (0);
7325
7326 if (newEnvStr != NULL)
7327 RTStrFree(newEnvStr);
7328 }
7329
7330 /* Hardened startup logging */
7331#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_HARDENING)
7332 Utf8Str strSupStartLogArg("--sup-startup-log=");
7333 {
7334 Utf8Str strStartupLogFile = i_getStartupLogFilename();
7335 int vrc2 = RTFileDelete(strStartupLogFile.c_str());
7336 if (vrc2 == VERR_PATH_NOT_FOUND || vrc2 == VERR_FILE_NOT_FOUND)
7337 {
7338 Utf8Str strStartupLogDir = strStartupLogFile;
7339 strStartupLogDir.stripFilename();
7340 RTDirCreateFullPath(strStartupLogDir.c_str(), 0755); /** @todo add a variant for creating the path to a file without stripping the file. */
7341 }
7342 strSupStartLogArg.append(strStartupLogFile);
7343 }
7344 const char *pszSupStartupLogArg = strSupStartLogArg.c_str();
7345#else
7346 const char *pszSupStartupLogArg = NULL;
7347#endif
7348
7349
7350#ifdef VBOX_WITH_QTGUI
7351 if (strFrontend == "gui" || strFrontend == "GUI/Qt")
7352 {
7353# ifdef RT_OS_DARWIN /* Avoid Launch Services confusing this with the selector by using a helper app. */
7354 /* Modify the base path so that we don't need to use ".." below. */
7355 RTPathStripTrailingSlash(szPath);
7356 RTPathStripFilename(szPath);
7357 cchBufLeft = strlen(szPath);
7358 pszNamePart = szPath + cchBufLeft;
7359 cchBufLeft = sizeof(szPath) - cchBufLeft;
7360
7361# define OSX_APP_NAME "VirtualBoxVM"
7362# define OSX_APP_PATH_FMT "/Resources/%s.app/Contents/MacOS/VirtualBoxVM"
7363
7364 Utf8Str strAppOverride = i_getExtraData(Utf8Str("VBoxInternal2/VirtualBoxVMAppOverride"));
7365 if ( strAppOverride.contains(".")
7366 || strAppOverride.contains("/")
7367 || strAppOverride.contains("\\")
7368 || strAppOverride.contains(":"))
7369 strAppOverride.setNull();
7370 Utf8Str strAppPath;
7371 if (!strAppOverride.isEmpty())
7372 {
7373 strAppPath = Utf8StrFmt(OSX_APP_PATH_FMT, strAppOverride.c_str());
7374 Utf8Str strFullPath(szPath);
7375 strFullPath.append(strAppPath);
7376 /* there is a race, but people using this deserve the failure */
7377 if (!RTFileExists(strFullPath.c_str()))
7378 strAppOverride.setNull();
7379 }
7380 if (strAppOverride.isEmpty())
7381 strAppPath = Utf8StrFmt(OSX_APP_PATH_FMT, OSX_APP_NAME);
7382 AssertReturn(cchBufLeft > strAppPath.length(), E_UNEXPECTED);
7383 strcpy(pszNamePart, strAppPath.c_str());
7384# else
7385 static const char s_szVirtualBox_exe[] = "VirtualBox" HOSTSUFF_EXE;
7386 Assert(cchBufLeft >= sizeof(s_szVirtualBox_exe));
7387 strcpy(pszNamePart, s_szVirtualBox_exe);
7388# endif
7389
7390 Utf8Str idStr = mData->mUuid.toString();
7391 const char *apszArgs[] =
7392 {
7393 szPath,
7394 "--comment", mUserData->s.strName.c_str(),
7395 "--startvm", idStr.c_str(),
7396 "--no-startvm-errormsgbox",
7397 pszSupStartupLogArg,
7398 NULL
7399 };
7400 vrc = RTProcCreate(szPath, apszArgs, env, 0, &pid);
7401 }
7402#else /* !VBOX_WITH_QTGUI */
7403 if (0)
7404 ;
7405#endif /* VBOX_WITH_QTGUI */
7406
7407 else
7408
7409#ifdef VBOX_WITH_VBOXSDL
7410 if (strFrontend == "sdl" || strFrontend == "GUI/SDL")
7411 {
7412 static const char s_szVBoxSDL_exe[] = "VBoxSDL" HOSTSUFF_EXE;
7413 Assert(cchBufLeft >= sizeof(s_szVBoxSDL_exe));
7414 strcpy(pszNamePart, s_szVBoxSDL_exe);
7415
7416 Utf8Str idStr = mData->mUuid.toString();
7417 const char *apszArgs[] =
7418 {
7419 szPath,
7420 "--comment", mUserData->s.strName.c_str(),
7421 "--startvm", idStr.c_str(),
7422 pszSupStartupLogArg,
7423 NULL
7424 };
7425 vrc = RTProcCreate(szPath, apszArgs, env, 0, &pid);
7426 }
7427#else /* !VBOX_WITH_VBOXSDL */
7428 if (0)
7429 ;
7430#endif /* !VBOX_WITH_VBOXSDL */
7431
7432 else
7433
7434#ifdef VBOX_WITH_HEADLESS
7435 if ( strFrontend == "headless"
7436 || strFrontend == "capture"
7437 || strFrontend == "vrdp" /* Deprecated. Same as headless. */
7438 )
7439 {
7440 /* On pre-4.0 the "headless" type was used for passing "--vrdp off" to VBoxHeadless to let it work in OSE,
7441 * which did not contain VRDP server. In VBox 4.0 the remote desktop server (VRDE) is optional,
7442 * and a VM works even if the server has not been installed.
7443 * So in 4.0 the "headless" behavior remains the same for default VBox installations.
7444 * Only if a VRDE has been installed and the VM enables it, the "headless" will work
7445 * differently in 4.0 and 3.x.
7446 */
7447 static const char s_szVBoxHeadless_exe[] = "VBoxHeadless" HOSTSUFF_EXE;
7448 Assert(cchBufLeft >= sizeof(s_szVBoxHeadless_exe));
7449 strcpy(pszNamePart, s_szVBoxHeadless_exe);
7450
7451 Utf8Str idStr = mData->mUuid.toString();
7452 const char *apszArgs[] =
7453 {
7454 szPath,
7455 "--comment", mUserData->s.strName.c_str(),
7456 "--startvm", idStr.c_str(),
7457 "--vrde", "config",
7458 0, /* For "--capture". */
7459 0, /* For "--sup-startup-log". */
7460 0
7461 };
7462 unsigned iArg = 7;
7463 if (strFrontend == "capture")
7464 apszArgs[iArg++] = "--capture";
7465 apszArgs[iArg++] = pszSupStartupLogArg;
7466
7467# ifdef RT_OS_WINDOWS
7468 vrc = RTProcCreate(szPath, apszArgs, env, RTPROC_FLAGS_NO_WINDOW, &pid);
7469# else
7470 vrc = RTProcCreate(szPath, apszArgs, env, 0, &pid);
7471# endif
7472 }
7473#else /* !VBOX_WITH_HEADLESS */
7474 if (0)
7475 ;
7476#endif /* !VBOX_WITH_HEADLESS */
7477 else
7478 {
7479 RTEnvDestroy(env);
7480 return setError(E_INVALIDARG,
7481 tr("Invalid frontend name: '%s'"),
7482 strFrontend.c_str());
7483 }
7484
7485 RTEnvDestroy(env);
7486
7487 if (RT_FAILURE(vrc))
7488 return setError(VBOX_E_IPRT_ERROR,
7489 tr("Could not launch a process for the machine '%s' (%Rrc)"),
7490 mUserData->s.strName.c_str(), vrc);
7491
7492 LogFlowThisFunc(("launched.pid=%d(0x%x)\n", pid, pid));
7493
7494 /*
7495 * Note that we don't release the lock here before calling the client,
7496 * because it doesn't need to call us back if called with a NULL argument.
7497 * Releasing the lock here is dangerous because we didn't prepare the
7498 * launch data yet, but the client we've just started may happen to be
7499 * too fast and call LockMachine() that will fail (because of PID, etc.),
7500 * so that the Machine will never get out of the Spawning session state.
7501 */
7502
7503 /* inform the session that it will be a remote one */
7504 LogFlowThisFunc(("Calling AssignMachine (NULL)...\n"));
7505#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
7506 HRESULT rc = aControl->AssignMachine(NULL, LockType_Write, Bstr::Empty.raw());
7507#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
7508 HRESULT rc = aControl->AssignMachine(NULL, LockType_Write, NULL);
7509#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
7510 LogFlowThisFunc(("AssignMachine (NULL) returned %08X\n", rc));
7511
7512 if (FAILED(rc))
7513 {
7514 /* restore the session state */
7515 mData->mSession.mState = SessionState_Unlocked;
7516 alock.release();
7517 mParent->i_addProcessToReap(pid);
7518 /* The failure may occur w/o any error info (from RPC), so provide one */
7519 return setError(VBOX_E_VM_ERROR,
7520 tr("Failed to assign the machine to the session (%Rhrc)"), rc);
7521 }
7522
7523 /* attach launch data to the machine */
7524 Assert(mData->mSession.mPID == NIL_RTPROCESS);
7525 mData->mSession.mRemoteControls.push_back(aControl);
7526 mData->mSession.mProgress = aProgress;
7527 mData->mSession.mPID = pid;
7528 mData->mSession.mState = SessionState_Spawning;
7529 mData->mSession.mType = strFrontend;
7530
7531 alock.release();
7532 mParent->i_addProcessToReap(pid);
7533
7534 LogFlowThisFuncLeave();
7535 return S_OK;
7536}
7537
7538/**
7539 * Returns @c true if the given session machine instance has an open direct
7540 * session (and optionally also for direct sessions which are closing) and
7541 * returns the session control machine instance if so.
7542 *
7543 * Note that when the method returns @c false, the arguments remain unchanged.
7544 *
7545 * @param aMachine Session machine object.
7546 * @param aControl Direct session control object (optional).
7547 * @param aAllowClosing If true then additionally a session which is currently
7548 * being closed will also be allowed.
7549 *
7550 * @note locks this object for reading.
7551 */
7552bool Machine::i_isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
7553 ComPtr<IInternalSessionControl> *aControl /*= NULL*/,
7554 bool aAllowClosing /*= false*/)
7555{
7556 AutoLimitedCaller autoCaller(this);
7557 AssertComRCReturn(autoCaller.rc(), false);
7558
7559 /* just return false for inaccessible machines */
7560 if (getObjectState().getState() != ObjectState::Ready)
7561 return false;
7562
7563 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7564
7565 if ( mData->mSession.mState == SessionState_Locked
7566 || (aAllowClosing && mData->mSession.mState == SessionState_Unlocking)
7567 )
7568 {
7569 AssertReturn(!mData->mSession.mMachine.isNull(), false);
7570
7571 aMachine = mData->mSession.mMachine;
7572
7573 if (aControl != NULL)
7574 *aControl = mData->mSession.mDirectControl;
7575
7576 return true;
7577 }
7578
7579 return false;
7580}
7581
7582/**
7583 * Returns @c true if the given machine has an spawning direct session.
7584 *
7585 * @note locks this object for reading.
7586 */
7587bool Machine::i_isSessionSpawning()
7588{
7589 AutoLimitedCaller autoCaller(this);
7590 AssertComRCReturn(autoCaller.rc(), false);
7591
7592 /* just return false for inaccessible machines */
7593 if (getObjectState().getState() != ObjectState::Ready)
7594 return false;
7595
7596 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7597
7598 if (mData->mSession.mState == SessionState_Spawning)
7599 return true;
7600
7601 return false;
7602}
7603
7604/**
7605 * Called from the client watcher thread to check for unexpected client process
7606 * death during Session_Spawning state (e.g. before it successfully opened a
7607 * direct session).
7608 *
7609 * On Win32 and on OS/2, this method is called only when we've got the
7610 * direct client's process termination notification, so it always returns @c
7611 * true.
7612 *
7613 * On other platforms, this method returns @c true if the client process is
7614 * terminated and @c false if it's still alive.
7615 *
7616 * @note Locks this object for writing.
7617 */
7618bool Machine::i_checkForSpawnFailure()
7619{
7620 AutoCaller autoCaller(this);
7621 if (!autoCaller.isOk())
7622 {
7623 /* nothing to do */
7624 LogFlowThisFunc(("Already uninitialized!\n"));
7625 return true;
7626 }
7627
7628 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7629
7630 if (mData->mSession.mState != SessionState_Spawning)
7631 {
7632 /* nothing to do */
7633 LogFlowThisFunc(("Not spawning any more!\n"));
7634 return true;
7635 }
7636
7637 HRESULT rc = S_OK;
7638
7639 /* PID not yet initialized, skip check. */
7640 if (mData->mSession.mPID == NIL_RTPROCESS)
7641 return false;
7642
7643 RTPROCSTATUS status;
7644 int vrc = RTProcWait(mData->mSession.mPID, RTPROCWAIT_FLAGS_NOBLOCK, &status);
7645
7646 if (vrc != VERR_PROCESS_RUNNING)
7647 {
7648 Utf8Str strExtraInfo;
7649
7650#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_HARDENING)
7651 /* If the startup logfile exists and is of non-zero length, tell the
7652 user to look there for more details to encourage them to attach it
7653 when reporting startup issues. */
7654 Utf8Str strStartupLogFile = i_getStartupLogFilename();
7655 uint64_t cbStartupLogFile = 0;
7656 int vrc2 = RTFileQuerySize(strStartupLogFile.c_str(), &cbStartupLogFile);
7657 if (RT_SUCCESS(vrc2) && cbStartupLogFile > 0)
7658 strExtraInfo.append(Utf8StrFmt(tr(". More details may be available in '%s'"), strStartupLogFile.c_str()));
7659#endif
7660
7661 if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_NORMAL)
7662 rc = setError(E_FAIL,
7663 tr("The virtual machine '%s' has terminated unexpectedly during startup with exit code %d (%#x)%s"),
7664 i_getName().c_str(), status.iStatus, status.iStatus, strExtraInfo.c_str());
7665 else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_SIGNAL)
7666 rc = setError(E_FAIL,
7667 tr("The virtual machine '%s' has terminated unexpectedly during startup because of signal %d%s"),
7668 i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
7669 else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_ABEND)
7670 rc = setError(E_FAIL,
7671 tr("The virtual machine '%s' has terminated abnormally (iStatus=%#x)%s"),
7672 i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
7673 else
7674 rc = setError(E_FAIL,
7675 tr("The virtual machine '%s' has terminated unexpectedly during startup (%Rrc)%s"),
7676 i_getName().c_str(), vrc, strExtraInfo.c_str());
7677 }
7678
7679 if (FAILED(rc))
7680 {
7681 /* Close the remote session, remove the remote control from the list
7682 * and reset session state to Closed (@note keep the code in sync with
7683 * the relevant part in LockMachine()). */
7684
7685 Assert(mData->mSession.mRemoteControls.size() == 1);
7686 if (mData->mSession.mRemoteControls.size() == 1)
7687 {
7688 ErrorInfoKeeper eik;
7689 mData->mSession.mRemoteControls.front()->Uninitialize();
7690 }
7691
7692 mData->mSession.mRemoteControls.clear();
7693 mData->mSession.mState = SessionState_Unlocked;
7694
7695 /* finalize the progress after setting the state */
7696 if (!mData->mSession.mProgress.isNull())
7697 {
7698 mData->mSession.mProgress->notifyComplete(rc);
7699 mData->mSession.mProgress.setNull();
7700 }
7701
7702 mData->mSession.mPID = NIL_RTPROCESS;
7703
7704 mParent->i_onSessionStateChange(mData->mUuid, SessionState_Unlocked);
7705 return true;
7706 }
7707
7708 return false;
7709}
7710
7711/**
7712 * Checks whether the machine can be registered. If so, commits and saves
7713 * all settings.
7714 *
7715 * @note Must be called from mParent's write lock. Locks this object and
7716 * children for writing.
7717 */
7718HRESULT Machine::i_prepareRegister()
7719{
7720 AssertReturn(mParent->isWriteLockOnCurrentThread(), E_FAIL);
7721
7722 AutoLimitedCaller autoCaller(this);
7723 AssertComRCReturnRC(autoCaller.rc());
7724
7725 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7726
7727 /* wait for state dependents to drop to zero */
7728 i_ensureNoStateDependencies();
7729
7730 if (!mData->mAccessible)
7731 return setError(VBOX_E_INVALID_OBJECT_STATE,
7732 tr("The machine '%s' with UUID {%s} is inaccessible and cannot be registered"),
7733 mUserData->s.strName.c_str(),
7734 mData->mUuid.toString().c_str());
7735
7736 AssertReturn(getObjectState().getState() == ObjectState::Ready, E_FAIL);
7737
7738 if (mData->mRegistered)
7739 return setError(VBOX_E_INVALID_OBJECT_STATE,
7740 tr("The machine '%s' with UUID {%s} is already registered"),
7741 mUserData->s.strName.c_str(),
7742 mData->mUuid.toString().c_str());
7743
7744 HRESULT rc = S_OK;
7745
7746 // Ensure the settings are saved. If we are going to be registered and
7747 // no config file exists yet, create it by calling i_saveSettings() too.
7748 if ( (mData->flModifications)
7749 || (!mData->pMachineConfigFile->fileExists())
7750 )
7751 {
7752 rc = i_saveSettings(NULL);
7753 // no need to check whether VirtualBox.xml needs saving too since
7754 // we can't have a machine XML file rename pending
7755 if (FAILED(rc)) return rc;
7756 }
7757
7758 /* more config checking goes here */
7759
7760 if (SUCCEEDED(rc))
7761 {
7762 /* we may have had implicit modifications we want to fix on success */
7763 i_commit();
7764
7765 mData->mRegistered = true;
7766 }
7767 else
7768 {
7769 /* we may have had implicit modifications we want to cancel on failure*/
7770 i_rollback(false /* aNotify */);
7771 }
7772
7773 return rc;
7774}
7775
7776/**
7777 * Increases the number of objects dependent on the machine state or on the
7778 * registered state. Guarantees that these two states will not change at least
7779 * until #releaseStateDependency() is called.
7780 *
7781 * Depending on the @a aDepType value, additional state checks may be made.
7782 * These checks will set extended error info on failure. See
7783 * #checkStateDependency() for more info.
7784 *
7785 * If this method returns a failure, the dependency is not added and the caller
7786 * is not allowed to rely on any particular machine state or registration state
7787 * value and may return the failed result code to the upper level.
7788 *
7789 * @param aDepType Dependency type to add.
7790 * @param aState Current machine state (NULL if not interested).
7791 * @param aRegistered Current registered state (NULL if not interested).
7792 *
7793 * @note Locks this object for writing.
7794 */
7795HRESULT Machine::i_addStateDependency(StateDependency aDepType /* = AnyStateDep */,
7796 MachineState_T *aState /* = NULL */,
7797 BOOL *aRegistered /* = NULL */)
7798{
7799 AutoCaller autoCaller(this);
7800 AssertComRCReturnRC(autoCaller.rc());
7801
7802 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7803
7804 HRESULT rc = i_checkStateDependency(aDepType);
7805 if (FAILED(rc)) return rc;
7806
7807 {
7808 if (mData->mMachineStateChangePending != 0)
7809 {
7810 /* i_ensureNoStateDependencies() is waiting for state dependencies to
7811 * drop to zero so don't add more. It may make sense to wait a bit
7812 * and retry before reporting an error (since the pending state
7813 * transition should be really quick) but let's just assert for
7814 * now to see if it ever happens on practice. */
7815
7816 AssertFailed();
7817
7818 return setError(E_ACCESSDENIED,
7819 tr("Machine state change is in progress. Please retry the operation later."));
7820 }
7821
7822 ++mData->mMachineStateDeps;
7823 Assert(mData->mMachineStateDeps != 0 /* overflow */);
7824 }
7825
7826 if (aState)
7827 *aState = mData->mMachineState;
7828 if (aRegistered)
7829 *aRegistered = mData->mRegistered;
7830
7831 return S_OK;
7832}
7833
7834/**
7835 * Decreases the number of objects dependent on the machine state.
7836 * Must always complete the #addStateDependency() call after the state
7837 * dependency is no more necessary.
7838 */
7839void Machine::i_releaseStateDependency()
7840{
7841 AutoCaller autoCaller(this);
7842 AssertComRCReturnVoid(autoCaller.rc());
7843
7844 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
7845
7846 /* releaseStateDependency() w/o addStateDependency()? */
7847 AssertReturnVoid(mData->mMachineStateDeps != 0);
7848 -- mData->mMachineStateDeps;
7849
7850 if (mData->mMachineStateDeps == 0)
7851 {
7852 /* inform i_ensureNoStateDependencies() that there are no more deps */
7853 if (mData->mMachineStateChangePending != 0)
7854 {
7855 Assert(mData->mMachineStateDepsSem != NIL_RTSEMEVENTMULTI);
7856 RTSemEventMultiSignal (mData->mMachineStateDepsSem);
7857 }
7858 }
7859}
7860
7861Utf8Str Machine::i_getExtraData(const Utf8Str &strKey)
7862{
7863 /* start with nothing found */
7864 Utf8Str strResult("");
7865
7866 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7867
7868 settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(strKey);
7869 if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
7870 // found:
7871 strResult = it->second; // source is a Utf8Str
7872
7873 return strResult;
7874}
7875
7876// protected methods
7877/////////////////////////////////////////////////////////////////////////////
7878
7879/**
7880 * Performs machine state checks based on the @a aDepType value. If a check
7881 * fails, this method will set extended error info, otherwise it will return
7882 * S_OK. It is supposed, that on failure, the caller will immediately return
7883 * the return value of this method to the upper level.
7884 *
7885 * When @a aDepType is AnyStateDep, this method always returns S_OK.
7886 *
7887 * When @a aDepType is MutableStateDep, this method returns S_OK only if the
7888 * current state of this machine object allows to change settings of the
7889 * machine (i.e. the machine is not registered, or registered but not running
7890 * and not saved). It is useful to call this method from Machine setters
7891 * before performing any change.
7892 *
7893 * When @a aDepType is MutableOrSavedStateDep, this method behaves the same
7894 * as for MutableStateDep except that if the machine is saved, S_OK is also
7895 * returned. This is useful in setters which allow changing machine
7896 * properties when it is in the saved state.
7897 *
7898 * When @a aDepType is OfflineStateDep, this method returns S_OK if the
7899 * state is one of the 4 offline states (PoweredOff, Saved, Teleported,
7900 * Aborted).
7901 *
7902 * @param aDepType Dependency type to check.
7903 *
7904 * @note Non Machine based classes should use #addStateDependency() and
7905 * #releaseStateDependency() methods or the smart AutoStateDependency
7906 * template.
7907 *
7908 * @note This method must be called from under this object's read or write
7909 * lock.
7910 */
7911HRESULT Machine::i_checkStateDependency(StateDependency aDepType)
7912{
7913 switch (aDepType)
7914 {
7915 case AnyStateDep:
7916 {
7917 break;
7918 }
7919 case MutableStateDep:
7920 {
7921 if ( mData->mRegistered
7922 && ( !i_isSessionMachine() /** @todo This was just converted raw; Check if Running and
7923 Paused should actually be included here... (Live Migration) */
7924 || ( mData->mMachineState != MachineState_Paused
7925 && mData->mMachineState != MachineState_Running
7926 && mData->mMachineState != MachineState_Aborted
7927 && mData->mMachineState != MachineState_Teleported
7928 && mData->mMachineState != MachineState_PoweredOff
7929 )
7930 )
7931 )
7932 return setError(VBOX_E_INVALID_VM_STATE,
7933 tr("The machine is not mutable (state is %s)"),
7934 Global::stringifyMachineState(mData->mMachineState));
7935 break;
7936 }
7937 case MutableOrSavedStateDep:
7938 {
7939 if ( mData->mRegistered
7940 && ( !i_isSessionMachine() /** @todo This was just converted raw; Check if Running and
7941 Paused should actually be included here... (Live Migration) */
7942 || ( mData->mMachineState != MachineState_Paused
7943 && mData->mMachineState != MachineState_Running
7944 && mData->mMachineState != MachineState_Aborted
7945 && mData->mMachineState != MachineState_Teleported
7946 && mData->mMachineState != MachineState_Saved
7947 && mData->mMachineState != MachineState_PoweredOff
7948 )
7949 )
7950 )
7951 return setError(VBOX_E_INVALID_VM_STATE,
7952 tr("The machine is not mutable (state is %s)"),
7953 Global::stringifyMachineState(mData->mMachineState));
7954 break;
7955 }
7956 case OfflineStateDep:
7957 {
7958 if ( mData->mRegistered
7959 && ( !i_isSessionMachine()
7960 || ( mData->mMachineState != MachineState_PoweredOff
7961 && mData->mMachineState != MachineState_Saved
7962 && mData->mMachineState != MachineState_Aborted
7963 && mData->mMachineState != MachineState_Teleported
7964 )
7965 )
7966 )
7967 return setError(VBOX_E_INVALID_VM_STATE,
7968 tr("The machine is not offline (state is %s)"),
7969 Global::stringifyMachineState(mData->mMachineState));
7970 break;
7971 }
7972 }
7973
7974 return S_OK;
7975}
7976
7977/**
7978 * Helper to initialize all associated child objects and allocate data
7979 * structures.
7980 *
7981 * This method must be called as a part of the object's initialization procedure
7982 * (usually done in the #init() method).
7983 *
7984 * @note Must be called only from #init() or from #registeredInit().
7985 */
7986HRESULT Machine::initDataAndChildObjects()
7987{
7988 AutoCaller autoCaller(this);
7989 AssertComRCReturnRC(autoCaller.rc());
7990 AssertComRCReturn( getObjectState().getState() == ObjectState::InInit
7991 || getObjectState().getState() == ObjectState::Limited, E_FAIL);
7992
7993 AssertReturn(!mData->mAccessible, E_FAIL);
7994
7995 /* allocate data structures */
7996 mSSData.allocate();
7997 mUserData.allocate();
7998 mHWData.allocate();
7999 mMediaData.allocate();
8000 mStorageControllers.allocate();
8001 mUSBControllers.allocate();
8002
8003 /* initialize mOSTypeId */
8004 mUserData->s.strOsType = mParent->i_getUnknownOSType()->i_id();
8005
8006 /* create associated BIOS settings object */
8007 unconst(mBIOSSettings).createObject();
8008 mBIOSSettings->init(this);
8009
8010 /* create an associated VRDE object (default is disabled) */
8011 unconst(mVRDEServer).createObject();
8012 mVRDEServer->init(this);
8013
8014 /* create associated serial port objects */
8015 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
8016 {
8017 unconst(mSerialPorts[slot]).createObject();
8018 mSerialPorts[slot]->init(this, slot);
8019 }
8020
8021 /* create associated parallel port objects */
8022 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
8023 {
8024 unconst(mParallelPorts[slot]).createObject();
8025 mParallelPorts[slot]->init(this, slot);
8026 }
8027
8028 /* create the audio adapter object (always present, default is disabled) */
8029 unconst(mAudioAdapter).createObject();
8030 mAudioAdapter->init(this);
8031
8032 /* create the USB device filters object (always present) */
8033 unconst(mUSBDeviceFilters).createObject();
8034 mUSBDeviceFilters->init(this);
8035
8036 /* create associated network adapter objects */
8037 mNetworkAdapters.resize(Global::getMaxNetworkAdapters(mHWData->mChipsetType));
8038 for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
8039 {
8040 unconst(mNetworkAdapters[slot]).createObject();
8041 mNetworkAdapters[slot]->init(this, slot);
8042 }
8043
8044 /* create the bandwidth control */
8045 unconst(mBandwidthControl).createObject();
8046 mBandwidthControl->init(this);
8047
8048 return S_OK;
8049}
8050
8051/**
8052 * Helper to uninitialize all associated child objects and to free all data
8053 * structures.
8054 *
8055 * This method must be called as a part of the object's uninitialization
8056 * procedure (usually done in the #uninit() method).
8057 *
8058 * @note Must be called only from #uninit() or from #registeredInit().
8059 */
8060void Machine::uninitDataAndChildObjects()
8061{
8062 AutoCaller autoCaller(this);
8063 AssertComRCReturnVoid(autoCaller.rc());
8064 AssertComRCReturnVoid( getObjectState().getState() == ObjectState::InUninit
8065 || getObjectState().getState() == ObjectState::Limited);
8066
8067 /* tell all our other child objects we've been uninitialized */
8068 if (mBandwidthControl)
8069 {
8070 mBandwidthControl->uninit();
8071 unconst(mBandwidthControl).setNull();
8072 }
8073
8074 for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
8075 {
8076 if (mNetworkAdapters[slot])
8077 {
8078 mNetworkAdapters[slot]->uninit();
8079 unconst(mNetworkAdapters[slot]).setNull();
8080 }
8081 }
8082
8083 if (mUSBDeviceFilters)
8084 {
8085 mUSBDeviceFilters->uninit();
8086 unconst(mUSBDeviceFilters).setNull();
8087 }
8088
8089 if (mAudioAdapter)
8090 {
8091 mAudioAdapter->uninit();
8092 unconst(mAudioAdapter).setNull();
8093 }
8094
8095 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
8096 {
8097 if (mParallelPorts[slot])
8098 {
8099 mParallelPorts[slot]->uninit();
8100 unconst(mParallelPorts[slot]).setNull();
8101 }
8102 }
8103
8104 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
8105 {
8106 if (mSerialPorts[slot])
8107 {
8108 mSerialPorts[slot]->uninit();
8109 unconst(mSerialPorts[slot]).setNull();
8110 }
8111 }
8112
8113 if (mVRDEServer)
8114 {
8115 mVRDEServer->uninit();
8116 unconst(mVRDEServer).setNull();
8117 }
8118
8119 if (mBIOSSettings)
8120 {
8121 mBIOSSettings->uninit();
8122 unconst(mBIOSSettings).setNull();
8123 }
8124
8125 /* Deassociate media (only when a real Machine or a SnapshotMachine
8126 * instance is uninitialized; SessionMachine instances refer to real
8127 * Machine media). This is necessary for a clean re-initialization of
8128 * the VM after successfully re-checking the accessibility state. Note
8129 * that in case of normal Machine or SnapshotMachine uninitialization (as
8130 * a result of unregistering or deleting the snapshot), outdated media
8131 * attachments will already be uninitialized and deleted, so this
8132 * code will not affect them. */
8133 if ( !!mMediaData
8134 && (!i_isSessionMachine())
8135 )
8136 {
8137 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
8138 it != mMediaData->mAttachments.end();
8139 ++it)
8140 {
8141 ComObjPtr<Medium> pMedium = (*it)->i_getMedium();
8142 if (pMedium.isNull())
8143 continue;
8144 HRESULT rc = pMedium->i_removeBackReference(mData->mUuid, i_getSnapshotId());
8145 AssertComRC(rc);
8146 }
8147 }
8148
8149 if (!i_isSessionMachine() && !i_isSnapshotMachine())
8150 {
8151 // clean up the snapshots list (Snapshot::uninit() will handle the snapshot's children recursively)
8152 if (mData->mFirstSnapshot)
8153 {
8154 // snapshots tree is protected by machine write lock; strictly
8155 // this isn't necessary here since we're deleting the entire
8156 // machine, but otherwise we assert in Snapshot::uninit()
8157 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8158 mData->mFirstSnapshot->uninit();
8159 mData->mFirstSnapshot.setNull();
8160 }
8161
8162 mData->mCurrentSnapshot.setNull();
8163 }
8164
8165 /* free data structures (the essential mData structure is not freed here
8166 * since it may be still in use) */
8167 mMediaData.free();
8168 mStorageControllers.free();
8169 mUSBControllers.free();
8170 mHWData.free();
8171 mUserData.free();
8172 mSSData.free();
8173}
8174
8175/**
8176 * Returns a pointer to the Machine object for this machine that acts like a
8177 * parent for complex machine data objects such as shared folders, etc.
8178 *
8179 * For primary Machine objects and for SnapshotMachine objects, returns this
8180 * object's pointer itself. For SessionMachine objects, returns the peer
8181 * (primary) machine pointer.
8182 */
8183Machine* Machine::i_getMachine()
8184{
8185 if (i_isSessionMachine())
8186 return (Machine*)mPeer;
8187 return this;
8188}
8189
8190/**
8191 * Makes sure that there are no machine state dependents. If necessary, waits
8192 * for the number of dependents to drop to zero.
8193 *
8194 * Make sure this method is called from under this object's write lock to
8195 * guarantee that no new dependents may be added when this method returns
8196 * control to the caller.
8197 *
8198 * @note Locks this object for writing. The lock will be released while waiting
8199 * (if necessary).
8200 *
8201 * @warning To be used only in methods that change the machine state!
8202 */
8203void Machine::i_ensureNoStateDependencies()
8204{
8205 AssertReturnVoid(isWriteLockOnCurrentThread());
8206
8207 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8208
8209 /* Wait for all state dependents if necessary */
8210 if (mData->mMachineStateDeps != 0)
8211 {
8212 /* lazy semaphore creation */
8213 if (mData->mMachineStateDepsSem == NIL_RTSEMEVENTMULTI)
8214 RTSemEventMultiCreate(&mData->mMachineStateDepsSem);
8215
8216 LogFlowThisFunc(("Waiting for state deps (%d) to drop to zero...\n",
8217 mData->mMachineStateDeps));
8218
8219 ++mData->mMachineStateChangePending;
8220
8221 /* reset the semaphore before waiting, the last dependent will signal
8222 * it */
8223 RTSemEventMultiReset(mData->mMachineStateDepsSem);
8224
8225 alock.release();
8226
8227 RTSemEventMultiWait(mData->mMachineStateDepsSem, RT_INDEFINITE_WAIT);
8228
8229 alock.acquire();
8230
8231 -- mData->mMachineStateChangePending;
8232 }
8233}
8234
8235/**
8236 * Changes the machine state and informs callbacks.
8237 *
8238 * This method is not intended to fail so it either returns S_OK or asserts (and
8239 * returns a failure).
8240 *
8241 * @note Locks this object for writing.
8242 */
8243HRESULT Machine::i_setMachineState(MachineState_T aMachineState)
8244{
8245 LogFlowThisFuncEnter();
8246 LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
8247
8248 AutoCaller autoCaller(this);
8249 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
8250
8251 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8252
8253 /* wait for state dependents to drop to zero */
8254 i_ensureNoStateDependencies();
8255
8256 if (mData->mMachineState != aMachineState)
8257 {
8258 mData->mMachineState = aMachineState;
8259
8260 RTTimeNow(&mData->mLastStateChange);
8261
8262 mParent->i_onMachineStateChange(mData->mUuid, aMachineState);
8263 }
8264
8265 LogFlowThisFuncLeave();
8266 return S_OK;
8267}
8268
8269/**
8270 * Searches for a shared folder with the given logical name
8271 * in the collection of shared folders.
8272 *
8273 * @param aName logical name of the shared folder
8274 * @param aSharedFolder where to return the found object
8275 * @param aSetError whether to set the error info if the folder is
8276 * not found
8277 * @return
8278 * S_OK when found or VBOX_E_OBJECT_NOT_FOUND when not found
8279 *
8280 * @note
8281 * must be called from under the object's lock!
8282 */
8283HRESULT Machine::i_findSharedFolder(const Utf8Str &aName,
8284 ComObjPtr<SharedFolder> &aSharedFolder,
8285 bool aSetError /* = false */)
8286{
8287 HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
8288 for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
8289 it != mHWData->mSharedFolders.end();
8290 ++it)
8291 {
8292 SharedFolder *pSF = *it;
8293 AutoCaller autoCaller(pSF);
8294 if (pSF->i_getName() == aName)
8295 {
8296 aSharedFolder = pSF;
8297 rc = S_OK;
8298 break;
8299 }
8300 }
8301
8302 if (aSetError && FAILED(rc))
8303 setError(rc, tr("Could not find a shared folder named '%s'"), aName.c_str());
8304
8305 return rc;
8306}
8307
8308/**
8309 * Initializes all machine instance data from the given settings structures
8310 * from XML. The exception is the machine UUID which needs special handling
8311 * depending on the caller's use case, so the caller needs to set that herself.
8312 *
8313 * This gets called in several contexts during machine initialization:
8314 *
8315 * -- When machine XML exists on disk already and needs to be loaded into memory,
8316 * for example, from registeredInit() to load all registered machines on
8317 * VirtualBox startup. In this case, puuidRegistry is NULL because the media
8318 * attached to the machine should be part of some media registry already.
8319 *
8320 * -- During OVF import, when a machine config has been constructed from an
8321 * OVF file. In this case, puuidRegistry is set to the machine UUID to
8322 * ensure that the media listed as attachments in the config (which have
8323 * been imported from the OVF) receive the correct registry ID.
8324 *
8325 * -- During VM cloning.
8326 *
8327 * @param config Machine settings from XML.
8328 * @param puuidRegistry If != NULL, Medium::setRegistryIdIfFirst() gets called with this registry ID
8329 * for each attached medium in the config.
8330 * @return
8331 */
8332HRESULT Machine::i_loadMachineDataFromSettings(const settings::MachineConfigFile &config,
8333 const Guid *puuidRegistry)
8334{
8335 // copy name, description, OS type, teleporter, UTC etc.
8336 mUserData->s = config.machineUserData;
8337
8338 // Decode the Icon overide data from config userdata and set onto Machine.
8339 #define DECODE_STR_MAX _1M
8340 const char* pszStr = config.machineUserData.ovIcon.c_str();
8341 ssize_t cbOut = RTBase64DecodedSize(pszStr, NULL);
8342 if (cbOut > DECODE_STR_MAX)
8343 return setError(E_FAIL,
8344 tr("Icon Data too long.'%d' > '%d'"),
8345 cbOut,
8346 DECODE_STR_MAX);
8347 com::SafeArray<BYTE> iconByte(cbOut);
8348 HRESULT rc = RTBase64Decode(pszStr, iconByte.raw(), cbOut, NULL, NULL);
8349 if (FAILED(rc))
8350 return setError(E_FAIL,
8351 tr("Failure to Decode Icon Data. '%s' (%d)"),
8352 pszStr,
8353 rc);
8354 mUserData->mIcon.resize(iconByte.size());
8355 memcpy(&mUserData->mIcon[0], iconByte.raw(), mUserData->mIcon.size());
8356
8357 // look up the object by Id to check it is valid
8358 ComPtr<IGuestOSType> guestOSType;
8359 rc = mParent->GetGuestOSType(Bstr(mUserData->s.strOsType).raw(),
8360 guestOSType.asOutParam());
8361 if (FAILED(rc)) return rc;
8362
8363 // stateFile (optional)
8364 if (config.strStateFile.isEmpty())
8365 mSSData->strStateFilePath.setNull();
8366 else
8367 {
8368 Utf8Str stateFilePathFull(config.strStateFile);
8369 int vrc = i_calculateFullPath(stateFilePathFull, stateFilePathFull);
8370 if (RT_FAILURE(vrc))
8371 return setError(E_FAIL,
8372 tr("Invalid saved state file path '%s' (%Rrc)"),
8373 config.strStateFile.c_str(),
8374 vrc);
8375 mSSData->strStateFilePath = stateFilePathFull;
8376 }
8377
8378 // snapshot folder needs special processing so set it again
8379 rc = COMSETTER(SnapshotFolder)(Bstr(config.machineUserData.strSnapshotFolder).raw());
8380 if (FAILED(rc)) return rc;
8381
8382 /* Copy the extra data items (Not in any case config is already the same as
8383 * mData->pMachineConfigFile, like when the xml files are read from disk. So
8384 * make sure the extra data map is copied). */
8385 mData->pMachineConfigFile->mapExtraDataItems = config.mapExtraDataItems;
8386
8387 /* currentStateModified (optional, default is true) */
8388 mData->mCurrentStateModified = config.fCurrentStateModified;
8389
8390 mData->mLastStateChange = config.timeLastStateChange;
8391
8392 /*
8393 * note: all mUserData members must be assigned prior this point because
8394 * we need to commit changes in order to let mUserData be shared by all
8395 * snapshot machine instances.
8396 */
8397 mUserData.commitCopy();
8398
8399 // machine registry, if present (must be loaded before snapshots)
8400 if (config.canHaveOwnMediaRegistry())
8401 {
8402 // determine machine folder
8403 Utf8Str strMachineFolder = i_getSettingsFileFull();
8404 strMachineFolder.stripFilename();
8405 rc = mParent->initMedia(i_getId(), // media registry ID == machine UUID
8406 config.mediaRegistry,
8407 strMachineFolder);
8408 if (FAILED(rc)) return rc;
8409 }
8410
8411 /* Snapshot node (optional) */
8412 size_t cRootSnapshots;
8413 if ((cRootSnapshots = config.llFirstSnapshot.size()))
8414 {
8415 // there must be only one root snapshot
8416 Assert(cRootSnapshots == 1);
8417
8418 const settings::Snapshot &snap = config.llFirstSnapshot.front();
8419
8420 rc = i_loadSnapshot(snap,
8421 config.uuidCurrentSnapshot,
8422 NULL); // no parent == first snapshot
8423 if (FAILED(rc)) return rc;
8424 }
8425
8426 // hardware data
8427 rc = i_loadHardware(config.hardwareMachine, &config.debugging, &config.autostart);
8428 if (FAILED(rc)) return rc;
8429
8430 // load storage controllers
8431 rc = i_loadStorageControllers(config.storageMachine,
8432 puuidRegistry,
8433 NULL /* puuidSnapshot */);
8434 if (FAILED(rc)) return rc;
8435
8436 /*
8437 * NOTE: the assignment below must be the last thing to do,
8438 * otherwise it will be not possible to change the settings
8439 * somewhere in the code above because all setters will be
8440 * blocked by i_checkStateDependency(MutableStateDep).
8441 */
8442
8443 /* set the machine state to Aborted or Saved when appropriate */
8444 if (config.fAborted)
8445 {
8446 mSSData->strStateFilePath.setNull();
8447
8448 /* no need to use i_setMachineState() during init() */
8449 mData->mMachineState = MachineState_Aborted;
8450 }
8451 else if (!mSSData->strStateFilePath.isEmpty())
8452 {
8453 /* no need to use i_setMachineState() during init() */
8454 mData->mMachineState = MachineState_Saved;
8455 }
8456
8457 // after loading settings, we are no longer different from the XML on disk
8458 mData->flModifications = 0;
8459
8460 return S_OK;
8461}
8462
8463/**
8464 * Recursively loads all snapshots starting from the given.
8465 *
8466 * @param aNode <Snapshot> node.
8467 * @param aCurSnapshotId Current snapshot ID from the settings file.
8468 * @param aParentSnapshot Parent snapshot.
8469 */
8470HRESULT Machine::i_loadSnapshot(const settings::Snapshot &data,
8471 const Guid &aCurSnapshotId,
8472 Snapshot *aParentSnapshot)
8473{
8474 AssertReturn(!i_isSnapshotMachine(), E_FAIL);
8475 AssertReturn(!i_isSessionMachine(), E_FAIL);
8476
8477 HRESULT rc = S_OK;
8478
8479 Utf8Str strStateFile;
8480 if (!data.strStateFile.isEmpty())
8481 {
8482 /* optional */
8483 strStateFile = data.strStateFile;
8484 int vrc = i_calculateFullPath(strStateFile, strStateFile);
8485 if (RT_FAILURE(vrc))
8486 return setError(E_FAIL,
8487 tr("Invalid saved state file path '%s' (%Rrc)"),
8488 strStateFile.c_str(),
8489 vrc);
8490 }
8491
8492 /* create a snapshot machine object */
8493 ComObjPtr<SnapshotMachine> pSnapshotMachine;
8494 pSnapshotMachine.createObject();
8495 rc = pSnapshotMachine->initFromSettings(this,
8496 data.hardware,
8497 &data.debugging,
8498 &data.autostart,
8499 data.storage,
8500 data.uuid.ref(),
8501 strStateFile);
8502 if (FAILED(rc)) return rc;
8503
8504 /* create a snapshot object */
8505 ComObjPtr<Snapshot> pSnapshot;
8506 pSnapshot.createObject();
8507 /* initialize the snapshot */
8508 rc = pSnapshot->init(mParent, // VirtualBox object
8509 data.uuid,
8510 data.strName,
8511 data.strDescription,
8512 data.timestamp,
8513 pSnapshotMachine,
8514 aParentSnapshot);
8515 if (FAILED(rc)) return rc;
8516
8517 /* memorize the first snapshot if necessary */
8518 if (!mData->mFirstSnapshot)
8519 mData->mFirstSnapshot = pSnapshot;
8520
8521 /* memorize the current snapshot when appropriate */
8522 if ( !mData->mCurrentSnapshot
8523 && pSnapshot->i_getId() == aCurSnapshotId
8524 )
8525 mData->mCurrentSnapshot = pSnapshot;
8526
8527 // now create the children
8528 for (settings::SnapshotsList::const_iterator it = data.llChildSnapshots.begin();
8529 it != data.llChildSnapshots.end();
8530 ++it)
8531 {
8532 const settings::Snapshot &childData = *it;
8533 // recurse
8534 rc = i_loadSnapshot(childData,
8535 aCurSnapshotId,
8536 pSnapshot); // parent = the one we created above
8537 if (FAILED(rc)) return rc;
8538 }
8539
8540 return rc;
8541}
8542
8543/**
8544 * Loads settings into mHWData.
8545 *
8546 * @param data Reference to the hardware settings.
8547 * @param pDbg Pointer to the debugging settings.
8548 * @param pAutostart Pointer to the autostart settings.
8549 */
8550HRESULT Machine::i_loadHardware(const settings::Hardware &data, const settings::Debugging *pDbg,
8551 const settings::Autostart *pAutostart)
8552{
8553 AssertReturn(!i_isSessionMachine(), E_FAIL);
8554
8555 HRESULT rc = S_OK;
8556
8557 try
8558 {
8559 /* The hardware version attribute (optional). */
8560 mHWData->mHWVersion = data.strVersion;
8561 mHWData->mHardwareUUID = data.uuid;
8562
8563 mHWData->mHWVirtExEnabled = data.fHardwareVirt;
8564 mHWData->mHWVirtExNestedPagingEnabled = data.fNestedPaging;
8565 mHWData->mHWVirtExLargePagesEnabled = data.fLargePages;
8566 mHWData->mHWVirtExVPIDEnabled = data.fVPID;
8567 mHWData->mHWVirtExUXEnabled = data.fUnrestrictedExecution;
8568 mHWData->mHWVirtExForceEnabled = data.fHardwareVirtForce;
8569 mHWData->mPAEEnabled = data.fPAE;
8570 mHWData->mSyntheticCpu = data.fSyntheticCpu;
8571 mHWData->mLongMode = data.enmLongMode;
8572 mHWData->mTripleFaultReset = data.fTripleFaultReset;
8573 mHWData->mCPUCount = data.cCPUs;
8574 mHWData->mCPUHotPlugEnabled = data.fCpuHotPlug;
8575 mHWData->mCpuExecutionCap = data.ulCpuExecutionCap;
8576
8577 // cpu
8578 if (mHWData->mCPUHotPlugEnabled)
8579 {
8580 for (settings::CpuList::const_iterator it = data.llCpus.begin();
8581 it != data.llCpus.end();
8582 ++it)
8583 {
8584 const settings::Cpu &cpu = *it;
8585
8586 mHWData->mCPUAttached[cpu.ulId] = true;
8587 }
8588 }
8589
8590 // cpuid leafs
8591 for (settings::CpuIdLeafsList::const_iterator it = data.llCpuIdLeafs.begin();
8592 it != data.llCpuIdLeafs.end();
8593 ++it)
8594 {
8595 const settings::CpuIdLeaf &leaf = *it;
8596
8597 switch (leaf.ulId)
8598 {
8599 case 0x0:
8600 case 0x1:
8601 case 0x2:
8602 case 0x3:
8603 case 0x4:
8604 case 0x5:
8605 case 0x6:
8606 case 0x7:
8607 case 0x8:
8608 case 0x9:
8609 case 0xA:
8610 mHWData->mCpuIdStdLeafs[leaf.ulId] = leaf;
8611 break;
8612
8613 case 0x80000000:
8614 case 0x80000001:
8615 case 0x80000002:
8616 case 0x80000003:
8617 case 0x80000004:
8618 case 0x80000005:
8619 case 0x80000006:
8620 case 0x80000007:
8621 case 0x80000008:
8622 case 0x80000009:
8623 case 0x8000000A:
8624 mHWData->mCpuIdExtLeafs[leaf.ulId - 0x80000000] = leaf;
8625 break;
8626
8627 default:
8628 /* just ignore */
8629 break;
8630 }
8631 }
8632
8633 mHWData->mMemorySize = data.ulMemorySizeMB;
8634 mHWData->mPageFusionEnabled = data.fPageFusionEnabled;
8635
8636 // boot order
8637 for (size_t i = 0; i < RT_ELEMENTS(mHWData->mBootOrder); ++i)
8638 {
8639 settings::BootOrderMap::const_iterator it = data.mapBootOrder.find(i);
8640 if (it == data.mapBootOrder.end())
8641 mHWData->mBootOrder[i] = DeviceType_Null;
8642 else
8643 mHWData->mBootOrder[i] = it->second;
8644 }
8645
8646 mHWData->mGraphicsControllerType = data.graphicsControllerType;
8647 mHWData->mVRAMSize = data.ulVRAMSizeMB;
8648 mHWData->mMonitorCount = data.cMonitors;
8649 mHWData->mAccelerate3DEnabled = data.fAccelerate3D;
8650 mHWData->mAccelerate2DVideoEnabled = data.fAccelerate2DVideo;
8651 mHWData->mVideoCaptureWidth = data.ulVideoCaptureHorzRes;
8652 mHWData->mVideoCaptureHeight = data.ulVideoCaptureVertRes;
8653 mHWData->mVideoCaptureEnabled = data.fVideoCaptureEnabled;
8654 for (unsigned i = 0; i < RT_ELEMENTS(mHWData->maVideoCaptureScreens); ++i)
8655 mHWData->maVideoCaptureScreens[i] = ASMBitTest(&data.u64VideoCaptureScreens, i);
8656 AssertCompile(RT_ELEMENTS(mHWData->maVideoCaptureScreens) == sizeof(data.u64VideoCaptureScreens) * 8);
8657 mHWData->mVideoCaptureRate = data.ulVideoCaptureRate;
8658 mHWData->mVideoCaptureFPS = data.ulVideoCaptureFPS;
8659 if (!data.strVideoCaptureFile.isEmpty())
8660 i_calculateFullPath(data.strVideoCaptureFile, mHWData->mVideoCaptureFile);
8661 else
8662 mHWData->mVideoCaptureFile.setNull();
8663 mHWData->mFirmwareType = data.firmwareType;
8664 mHWData->mPointingHIDType = data.pointingHIDType;
8665 mHWData->mKeyboardHIDType = data.keyboardHIDType;
8666 mHWData->mChipsetType = data.chipsetType;
8667 mHWData->mParavirtProvider = data.paravirtProvider;
8668 mHWData->mEmulatedUSBCardReaderEnabled = data.fEmulatedUSBCardReader;
8669 mHWData->mHPETEnabled = data.fHPETEnabled;
8670
8671 /* VRDEServer */
8672 rc = mVRDEServer->i_loadSettings(data.vrdeSettings);
8673 if (FAILED(rc)) return rc;
8674
8675 /* BIOS */
8676 rc = mBIOSSettings->i_loadSettings(data.biosSettings);
8677 if (FAILED(rc)) return rc;
8678
8679 // Bandwidth control (must come before network adapters)
8680 rc = mBandwidthControl->i_loadSettings(data.ioSettings);
8681 if (FAILED(rc)) return rc;
8682
8683 /* Shared folders */
8684 for (settings::USBControllerList::const_iterator it = data.usbSettings.llUSBControllers.begin();
8685 it != data.usbSettings.llUSBControllers.end();
8686 ++it)
8687 {
8688 const settings::USBController &settingsCtrl = *it;
8689 ComObjPtr<USBController> newCtrl;
8690
8691 newCtrl.createObject();
8692 newCtrl->init(this, settingsCtrl.strName, settingsCtrl.enmType);
8693 mUSBControllers->push_back(newCtrl);
8694 }
8695
8696 /* USB device filters */
8697 rc = mUSBDeviceFilters->i_loadSettings(data.usbSettings);
8698 if (FAILED(rc)) return rc;
8699
8700 // network adapters
8701 uint32_t newCount = Global::getMaxNetworkAdapters(mHWData->mChipsetType);
8702 uint32_t oldCount = mNetworkAdapters.size();
8703 if (newCount > oldCount)
8704 {
8705 mNetworkAdapters.resize(newCount);
8706 for (ULONG slot = oldCount; slot < mNetworkAdapters.size(); ++slot)
8707 {
8708 unconst(mNetworkAdapters[slot]).createObject();
8709 mNetworkAdapters[slot]->init(this, slot);
8710 }
8711 }
8712 else if (newCount < oldCount)
8713 mNetworkAdapters.resize(newCount);
8714 for (settings::NetworkAdaptersList::const_iterator it = data.llNetworkAdapters.begin();
8715 it != data.llNetworkAdapters.end();
8716 ++it)
8717 {
8718 const settings::NetworkAdapter &nic = *it;
8719
8720 /* slot unicity is guaranteed by XML Schema */
8721 AssertBreak(nic.ulSlot < mNetworkAdapters.size());
8722 rc = mNetworkAdapters[nic.ulSlot]->i_loadSettings(mBandwidthControl, nic);
8723 if (FAILED(rc)) return rc;
8724 }
8725
8726 // serial ports
8727 for (settings::SerialPortsList::const_iterator it = data.llSerialPorts.begin();
8728 it != data.llSerialPorts.end();
8729 ++it)
8730 {
8731 const settings::SerialPort &s = *it;
8732
8733 AssertBreak(s.ulSlot < RT_ELEMENTS(mSerialPorts));
8734 rc = mSerialPorts[s.ulSlot]->i_loadSettings(s);
8735 if (FAILED(rc)) return rc;
8736 }
8737
8738 // parallel ports (optional)
8739 for (settings::ParallelPortsList::const_iterator it = data.llParallelPorts.begin();
8740 it != data.llParallelPorts.end();
8741 ++it)
8742 {
8743 const settings::ParallelPort &p = *it;
8744
8745 AssertBreak(p.ulSlot < RT_ELEMENTS(mParallelPorts));
8746 rc = mParallelPorts[p.ulSlot]->i_loadSettings(p);
8747 if (FAILED(rc)) return rc;
8748 }
8749
8750 /* AudioAdapter */
8751 rc = mAudioAdapter->i_loadSettings(data.audioAdapter);
8752 if (FAILED(rc)) return rc;
8753
8754 /* Shared folders */
8755 for (settings::SharedFoldersList::const_iterator it = data.llSharedFolders.begin();
8756 it != data.llSharedFolders.end();
8757 ++it)
8758 {
8759 const settings::SharedFolder &sf = *it;
8760
8761 ComObjPtr<SharedFolder> sharedFolder;
8762 /* Check for double entries. Not allowed! */
8763 rc = i_findSharedFolder(sf.strName, sharedFolder, false /* aSetError */);
8764 if (SUCCEEDED(rc))
8765 return setError(VBOX_E_OBJECT_IN_USE,
8766 tr("Shared folder named '%s' already exists"),
8767 sf.strName.c_str());
8768
8769 /* Create the new shared folder. Don't break on error. This will be
8770 * reported when the machine starts. */
8771 sharedFolder.createObject();
8772 rc = sharedFolder->init(i_getMachine(),
8773 sf.strName,
8774 sf.strHostPath,
8775 RT_BOOL(sf.fWritable),
8776 RT_BOOL(sf.fAutoMount),
8777 false /* fFailOnError */);
8778 if (FAILED(rc)) return rc;
8779 mHWData->mSharedFolders.push_back(sharedFolder);
8780 }
8781
8782 // Clipboard
8783 mHWData->mClipboardMode = data.clipboardMode;
8784
8785 // drag'n'drop
8786 mHWData->mDnDMode = data.dndMode;
8787
8788 // guest settings
8789 mHWData->mMemoryBalloonSize = data.ulMemoryBalloonSize;
8790
8791 // IO settings
8792 mHWData->mIOCacheEnabled = data.ioSettings.fIOCacheEnabled;
8793 mHWData->mIOCacheSize = data.ioSettings.ulIOCacheSize;
8794
8795 // Host PCI devices
8796 for (settings::HostPCIDeviceAttachmentList::const_iterator it = data.pciAttachments.begin();
8797 it != data.pciAttachments.end();
8798 ++it)
8799 {
8800 const settings::HostPCIDeviceAttachment &hpda = *it;
8801 ComObjPtr<PCIDeviceAttachment> pda;
8802
8803 pda.createObject();
8804 pda->i_loadSettings(this, hpda);
8805 mHWData->mPCIDeviceAssignments.push_back(pda);
8806 }
8807
8808 /*
8809 * (The following isn't really real hardware, but it lives in HWData
8810 * for reasons of convenience.)
8811 */
8812
8813#ifdef VBOX_WITH_GUEST_PROPS
8814 /* Guest properties (optional) */
8815 for (settings::GuestPropertiesList::const_iterator it = data.llGuestProperties.begin();
8816 it != data.llGuestProperties.end();
8817 ++it)
8818 {
8819 const settings::GuestProperty &prop = *it;
8820 uint32_t fFlags = guestProp::NILFLAG;
8821 guestProp::validateFlags(prop.strFlags.c_str(), &fFlags);
8822 HWData::GuestProperty property = { prop.strValue, (LONG64) prop.timestamp, fFlags };
8823 mHWData->mGuestProperties[prop.strName] = property;
8824 }
8825
8826 mHWData->mGuestPropertyNotificationPatterns = data.strNotificationPatterns;
8827#endif /* VBOX_WITH_GUEST_PROPS defined */
8828
8829 rc = i_loadDebugging(pDbg);
8830 if (FAILED(rc))
8831 return rc;
8832
8833 mHWData->mAutostart = *pAutostart;
8834
8835 /* default frontend */
8836 mHWData->mDefaultFrontend = data.strDefaultFrontend;
8837 }
8838 catch(std::bad_alloc &)
8839 {
8840 return E_OUTOFMEMORY;
8841 }
8842
8843 AssertComRC(rc);
8844 return rc;
8845}
8846
8847/**
8848 * Called from Machine::loadHardware() to load the debugging settings of the
8849 * machine.
8850 *
8851 * @param pDbg Pointer to the settings.
8852 */
8853HRESULT Machine::i_loadDebugging(const settings::Debugging *pDbg)
8854{
8855 mHWData->mDebugging = *pDbg;
8856 /* no more processing currently required, this will probably change. */
8857 return S_OK;
8858}
8859
8860/**
8861 * Called from i_loadMachineDataFromSettings() for the storage controller data, including media.
8862 *
8863 * @param data
8864 * @param puuidRegistry media registry ID to set media to or NULL; see Machine::i_loadMachineDataFromSettings()
8865 * @param puuidSnapshot
8866 * @return
8867 */
8868HRESULT Machine::i_loadStorageControllers(const settings::Storage &data,
8869 const Guid *puuidRegistry,
8870 const Guid *puuidSnapshot)
8871{
8872 AssertReturn(!i_isSessionMachine(), E_FAIL);
8873
8874 HRESULT rc = S_OK;
8875
8876 for (settings::StorageControllersList::const_iterator it = data.llStorageControllers.begin();
8877 it != data.llStorageControllers.end();
8878 ++it)
8879 {
8880 const settings::StorageController &ctlData = *it;
8881
8882 ComObjPtr<StorageController> pCtl;
8883 /* Try to find one with the name first. */
8884 rc = i_getStorageControllerByName(ctlData.strName, pCtl, false /* aSetError */);
8885 if (SUCCEEDED(rc))
8886 return setError(VBOX_E_OBJECT_IN_USE,
8887 tr("Storage controller named '%s' already exists"),
8888 ctlData.strName.c_str());
8889
8890 pCtl.createObject();
8891 rc = pCtl->init(this,
8892 ctlData.strName,
8893 ctlData.storageBus,
8894 ctlData.ulInstance,
8895 ctlData.fBootable);
8896 if (FAILED(rc)) return rc;
8897
8898 mStorageControllers->push_back(pCtl);
8899
8900 rc = pCtl->COMSETTER(ControllerType)(ctlData.controllerType);
8901 if (FAILED(rc)) return rc;
8902
8903 rc = pCtl->COMSETTER(PortCount)(ctlData.ulPortCount);
8904 if (FAILED(rc)) return rc;
8905
8906 rc = pCtl->COMSETTER(UseHostIOCache)(ctlData.fUseHostIOCache);
8907 if (FAILED(rc)) return rc;
8908
8909 /* Set IDE emulation settings (only for AHCI controller). */
8910 if (ctlData.controllerType == StorageControllerType_IntelAhci)
8911 {
8912 if ( (FAILED(rc = pCtl->i_setIDEEmulationPort(0, ctlData.lIDE0MasterEmulationPort)))
8913 || (FAILED(rc = pCtl->i_setIDEEmulationPort(1, ctlData.lIDE0SlaveEmulationPort)))
8914 || (FAILED(rc = pCtl->i_setIDEEmulationPort(2, ctlData.lIDE1MasterEmulationPort)))
8915 || (FAILED(rc = pCtl->i_setIDEEmulationPort(3, ctlData.lIDE1SlaveEmulationPort)))
8916 )
8917 return rc;
8918 }
8919
8920 /* Load the attached devices now. */
8921 rc = i_loadStorageDevices(pCtl,
8922 ctlData,
8923 puuidRegistry,
8924 puuidSnapshot);
8925 if (FAILED(rc)) return rc;
8926 }
8927
8928 return S_OK;
8929}
8930
8931/**
8932 * Called from i_loadStorageControllers for a controller's devices.
8933 *
8934 * @param aStorageController
8935 * @param data
8936 * @param puuidRegistry media registry ID to set media to or NULL; see Machine::i_loadMachineDataFromSettings()
8937 * @param aSnapshotId pointer to the snapshot ID if this is a snapshot machine
8938 * @return
8939 */
8940HRESULT Machine::i_loadStorageDevices(StorageController *aStorageController,
8941 const settings::StorageController &data,
8942 const Guid *puuidRegistry,
8943 const Guid *puuidSnapshot)
8944{
8945 HRESULT rc = S_OK;
8946
8947 /* paranoia: detect duplicate attachments */
8948 for (settings::AttachedDevicesList::const_iterator it = data.llAttachedDevices.begin();
8949 it != data.llAttachedDevices.end();
8950 ++it)
8951 {
8952 const settings::AttachedDevice &ad = *it;
8953
8954 for (settings::AttachedDevicesList::const_iterator it2 = it;
8955 it2 != data.llAttachedDevices.end();
8956 ++it2)
8957 {
8958 if (it == it2)
8959 continue;
8960
8961 const settings::AttachedDevice &ad2 = *it2;
8962
8963 if ( ad.lPort == ad2.lPort
8964 && ad.lDevice == ad2.lDevice)
8965 {
8966 return setError(E_FAIL,
8967 tr("Duplicate attachments for storage controller '%s', port %d, device %d of the virtual machine '%s'"),
8968 aStorageController->i_getName().c_str(),
8969 ad.lPort,
8970 ad.lDevice,
8971 mUserData->s.strName.c_str());
8972 }
8973 }
8974 }
8975
8976 for (settings::AttachedDevicesList::const_iterator it = data.llAttachedDevices.begin();
8977 it != data.llAttachedDevices.end();
8978 ++it)
8979 {
8980 const settings::AttachedDevice &dev = *it;
8981 ComObjPtr<Medium> medium;
8982
8983 switch (dev.deviceType)
8984 {
8985 case DeviceType_Floppy:
8986 case DeviceType_DVD:
8987 if (dev.strHostDriveSrc.isNotEmpty())
8988 rc = mParent->i_host()->i_findHostDriveByName(dev.deviceType, dev.strHostDriveSrc,
8989 false /* fRefresh */, medium);
8990 else
8991 rc = mParent->i_findRemoveableMedium(dev.deviceType,
8992 dev.uuid,
8993 false /* fRefresh */,
8994 false /* aSetError */,
8995 medium);
8996 if (rc == VBOX_E_OBJECT_NOT_FOUND)
8997 // This is not an error. The host drive or UUID might have vanished, so just go
8998 // ahead without this removeable medium attachment
8999 rc = S_OK;
9000 break;
9001
9002 case DeviceType_HardDisk:
9003 {
9004 /* find a hard disk by UUID */
9005 rc = mParent->i_findHardDiskById(dev.uuid, true /* aDoSetError */, &medium);
9006 if (FAILED(rc))
9007 {
9008 if (i_isSnapshotMachine())
9009 {
9010 // wrap another error message around the "cannot find hard disk" set by findHardDisk
9011 // so the user knows that the bad disk is in a snapshot somewhere
9012 com::ErrorInfo info;
9013 return setError(E_FAIL,
9014 tr("A differencing image of snapshot {%RTuuid} could not be found. %ls"),
9015 puuidSnapshot->raw(),
9016 info.getText().raw());
9017 }
9018 else
9019 return rc;
9020 }
9021
9022 AutoWriteLock hdLock(medium COMMA_LOCKVAL_SRC_POS);
9023
9024 if (medium->i_getType() == MediumType_Immutable)
9025 {
9026 if (i_isSnapshotMachine())
9027 return setError(E_FAIL,
9028 tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
9029 "of the virtual machine '%s' ('%s')"),
9030 medium->i_getLocationFull().c_str(),
9031 dev.uuid.raw(),
9032 puuidSnapshot->raw(),
9033 mUserData->s.strName.c_str(),
9034 mData->m_strConfigFileFull.c_str());
9035
9036 return setError(E_FAIL,
9037 tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
9038 medium->i_getLocationFull().c_str(),
9039 dev.uuid.raw(),
9040 mUserData->s.strName.c_str(),
9041 mData->m_strConfigFileFull.c_str());
9042 }
9043
9044 if (medium->i_getType() == MediumType_MultiAttach)
9045 {
9046 if (i_isSnapshotMachine())
9047 return setError(E_FAIL,
9048 tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
9049 "of the virtual machine '%s' ('%s')"),
9050 medium->i_getLocationFull().c_str(),
9051 dev.uuid.raw(),
9052 puuidSnapshot->raw(),
9053 mUserData->s.strName.c_str(),
9054 mData->m_strConfigFileFull.c_str());
9055
9056 return setError(E_FAIL,
9057 tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
9058 medium->i_getLocationFull().c_str(),
9059 dev.uuid.raw(),
9060 mUserData->s.strName.c_str(),
9061 mData->m_strConfigFileFull.c_str());
9062 }
9063
9064 if ( !i_isSnapshotMachine()
9065 && medium->i_getChildren().size() != 0
9066 )
9067 return setError(E_FAIL,
9068 tr("Hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s') "
9069 "because it has %d differencing child hard disks"),
9070 medium->i_getLocationFull().c_str(),
9071 dev.uuid.raw(),
9072 mUserData->s.strName.c_str(),
9073 mData->m_strConfigFileFull.c_str(),
9074 medium->i_getChildren().size());
9075
9076 if (i_findAttachment(mMediaData->mAttachments,
9077 medium))
9078 return setError(E_FAIL,
9079 tr("Hard disk '%s' with UUID {%RTuuid} is already attached to the virtual machine '%s' ('%s')"),
9080 medium->i_getLocationFull().c_str(),
9081 dev.uuid.raw(),
9082 mUserData->s.strName.c_str(),
9083 mData->m_strConfigFileFull.c_str());
9084
9085 break;
9086 }
9087
9088 default:
9089 return setError(E_FAIL,
9090 tr("Device '%s' with unknown type is attached to the virtual machine '%s' ('%s')"),
9091 medium->i_getLocationFull().c_str(),
9092 mUserData->s.strName.c_str(),
9093 mData->m_strConfigFileFull.c_str());
9094 }
9095
9096 if (FAILED(rc))
9097 break;
9098
9099 /* Bandwidth groups are loaded at this point. */
9100 ComObjPtr<BandwidthGroup> pBwGroup;
9101
9102 if (!dev.strBwGroup.isEmpty())
9103 {
9104 rc = mBandwidthControl->i_getBandwidthGroupByName(dev.strBwGroup, pBwGroup, false /* aSetError */);
9105 if (FAILED(rc))
9106 return setError(E_FAIL,
9107 tr("Device '%s' with unknown bandwidth group '%s' is attached to the virtual machine '%s' ('%s')"),
9108 medium->i_getLocationFull().c_str(),
9109 dev.strBwGroup.c_str(),
9110 mUserData->s.strName.c_str(),
9111 mData->m_strConfigFileFull.c_str());
9112 pBwGroup->i_reference();
9113 }
9114
9115 const Bstr controllerName = aStorageController->i_getName();
9116 ComObjPtr<MediumAttachment> pAttachment;
9117 pAttachment.createObject();
9118 rc = pAttachment->init(this,
9119 medium,
9120 controllerName,
9121 dev.lPort,
9122 dev.lDevice,
9123 dev.deviceType,
9124 false,
9125 dev.fPassThrough,
9126 dev.fTempEject,
9127 dev.fNonRotational,
9128 dev.fDiscard,
9129 dev.fHotPluggable,
9130 pBwGroup.isNull() ? Utf8Str::Empty : pBwGroup->i_getName());
9131 if (FAILED(rc)) break;
9132
9133 /* associate the medium with this machine and snapshot */
9134 if (!medium.isNull())
9135 {
9136 AutoCaller medCaller(medium);
9137 if (FAILED(medCaller.rc())) return medCaller.rc();
9138 AutoWriteLock mlock(medium COMMA_LOCKVAL_SRC_POS);
9139
9140 if (i_isSnapshotMachine())
9141 rc = medium->i_addBackReference(mData->mUuid, *puuidSnapshot);
9142 else
9143 rc = medium->i_addBackReference(mData->mUuid);
9144 /* If the medium->addBackReference fails it sets an appropriate
9145 * error message, so no need to do any guesswork here. */
9146
9147 if (puuidRegistry)
9148 // caller wants registry ID to be set on all attached media (OVF import case)
9149 medium->i_addRegistry(*puuidRegistry, false /* fRecurse */);
9150 }
9151
9152 if (FAILED(rc))
9153 break;
9154
9155 /* back up mMediaData to let registeredInit() properly rollback on failure
9156 * (= limited accessibility) */
9157 i_setModified(IsModified_Storage);
9158 mMediaData.backup();
9159 mMediaData->mAttachments.push_back(pAttachment);
9160 }
9161
9162 return rc;
9163}
9164
9165/**
9166 * Returns the snapshot with the given UUID or fails of no such snapshot exists.
9167 *
9168 * @param aId snapshot UUID to find (empty UUID refers the first snapshot)
9169 * @param aSnapshot where to return the found snapshot
9170 * @param aSetError true to set extended error info on failure
9171 */
9172HRESULT Machine::i_findSnapshotById(const Guid &aId,
9173 ComObjPtr<Snapshot> &aSnapshot,
9174 bool aSetError /* = false */)
9175{
9176 AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
9177
9178 if (!mData->mFirstSnapshot)
9179 {
9180 if (aSetError)
9181 return setError(E_FAIL, tr("This machine does not have any snapshots"));
9182 return E_FAIL;
9183 }
9184
9185 if (aId.isZero())
9186 aSnapshot = mData->mFirstSnapshot;
9187 else
9188 aSnapshot = mData->mFirstSnapshot->i_findChildOrSelf(aId.ref());
9189
9190 if (!aSnapshot)
9191 {
9192 if (aSetError)
9193 return setError(E_FAIL,
9194 tr("Could not find a snapshot with UUID {%s}"),
9195 aId.toString().c_str());
9196 return E_FAIL;
9197 }
9198
9199 return S_OK;
9200}
9201
9202/**
9203 * Returns the snapshot with the given name or fails of no such snapshot.
9204 *
9205 * @param aName snapshot name to find
9206 * @param aSnapshot where to return the found snapshot
9207 * @param aSetError true to set extended error info on failure
9208 */
9209HRESULT Machine::i_findSnapshotByName(const Utf8Str &strName,
9210 ComObjPtr<Snapshot> &aSnapshot,
9211 bool aSetError /* = false */)
9212{
9213 AssertReturn(!strName.isEmpty(), E_INVALIDARG);
9214
9215 AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
9216
9217 if (!mData->mFirstSnapshot)
9218 {
9219 if (aSetError)
9220 return setError(VBOX_E_OBJECT_NOT_FOUND,
9221 tr("This machine does not have any snapshots"));
9222 return VBOX_E_OBJECT_NOT_FOUND;
9223 }
9224
9225 aSnapshot = mData->mFirstSnapshot->i_findChildOrSelf(strName);
9226
9227 if (!aSnapshot)
9228 {
9229 if (aSetError)
9230 return setError(VBOX_E_OBJECT_NOT_FOUND,
9231 tr("Could not find a snapshot named '%s'"), strName.c_str());
9232 return VBOX_E_OBJECT_NOT_FOUND;
9233 }
9234
9235 return S_OK;
9236}
9237
9238/**
9239 * Returns a storage controller object with the given name.
9240 *
9241 * @param aName storage controller name to find
9242 * @param aStorageController where to return the found storage controller
9243 * @param aSetError true to set extended error info on failure
9244 */
9245HRESULT Machine::i_getStorageControllerByName(const Utf8Str &aName,
9246 ComObjPtr<StorageController> &aStorageController,
9247 bool aSetError /* = false */)
9248{
9249 AssertReturn(!aName.isEmpty(), E_INVALIDARG);
9250
9251 for (StorageControllerList::const_iterator it = mStorageControllers->begin();
9252 it != mStorageControllers->end();
9253 ++it)
9254 {
9255 if ((*it)->i_getName() == aName)
9256 {
9257 aStorageController = (*it);
9258 return S_OK;
9259 }
9260 }
9261
9262 if (aSetError)
9263 return setError(VBOX_E_OBJECT_NOT_FOUND,
9264 tr("Could not find a storage controller named '%s'"),
9265 aName.c_str());
9266 return VBOX_E_OBJECT_NOT_FOUND;
9267}
9268
9269/**
9270 * Returns a USB controller object with the given name.
9271 *
9272 * @param aName USB controller name to find
9273 * @param aUSBController where to return the found USB controller
9274 * @param aSetError true to set extended error info on failure
9275 */
9276HRESULT Machine::i_getUSBControllerByName(const Utf8Str &aName,
9277 ComObjPtr<USBController> &aUSBController,
9278 bool aSetError /* = false */)
9279{
9280 AssertReturn(!aName.isEmpty(), E_INVALIDARG);
9281
9282 for (USBControllerList::const_iterator it = mUSBControllers->begin();
9283 it != mUSBControllers->end();
9284 ++it)
9285 {
9286 if ((*it)->i_getName() == aName)
9287 {
9288 aUSBController = (*it);
9289 return S_OK;
9290 }
9291 }
9292
9293 if (aSetError)
9294 return setError(VBOX_E_OBJECT_NOT_FOUND,
9295 tr("Could not find a storage controller named '%s'"),
9296 aName.c_str());
9297 return VBOX_E_OBJECT_NOT_FOUND;
9298}
9299
9300/**
9301 * Returns the number of USB controller instance of the given type.
9302 *
9303 * @param enmType USB controller type.
9304 */
9305ULONG Machine::i_getUSBControllerCountByType(USBControllerType_T enmType)
9306{
9307 ULONG cCtrls = 0;
9308
9309 for (USBControllerList::const_iterator it = mUSBControllers->begin();
9310 it != mUSBControllers->end();
9311 ++it)
9312 {
9313 if ((*it)->i_getControllerType() == enmType)
9314 cCtrls++;
9315 }
9316
9317 return cCtrls;
9318}
9319
9320HRESULT Machine::i_getMediumAttachmentsOfController(const Utf8Str &aName,
9321 MediaData::AttachmentList &atts)
9322{
9323 AutoCaller autoCaller(this);
9324 if (FAILED(autoCaller.rc())) return autoCaller.rc();
9325
9326 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
9327
9328 for (MediaData::AttachmentList::iterator it = mMediaData->mAttachments.begin();
9329 it != mMediaData->mAttachments.end();
9330 ++it)
9331 {
9332 const ComObjPtr<MediumAttachment> &pAtt = *it;
9333 // should never happen, but deal with NULL pointers in the list.
9334 AssertStmt(!pAtt.isNull(), continue);
9335
9336 // getControllerName() needs caller+read lock
9337 AutoCaller autoAttCaller(pAtt);
9338 if (FAILED(autoAttCaller.rc()))
9339 {
9340 atts.clear();
9341 return autoAttCaller.rc();
9342 }
9343 AutoReadLock attLock(pAtt COMMA_LOCKVAL_SRC_POS);
9344
9345 if (pAtt->i_getControllerName() == Bstr(aName).raw())
9346 atts.push_back(pAtt);
9347 }
9348
9349 return S_OK;
9350}
9351
9352
9353/**
9354 * Helper for #i_saveSettings. Cares about renaming the settings directory and
9355 * file if the machine name was changed and about creating a new settings file
9356 * if this is a new machine.
9357 *
9358 * @note Must be never called directly but only from #saveSettings().
9359 */
9360HRESULT Machine::i_prepareSaveSettings(bool *pfNeedsGlobalSaveSettings)
9361{
9362 AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
9363
9364 HRESULT rc = S_OK;
9365
9366 bool fSettingsFileIsNew = !mData->pMachineConfigFile->fileExists();
9367
9368 /// @todo need to handle primary group change, too
9369
9370 /* attempt to rename the settings file if machine name is changed */
9371 if ( mUserData->s.fNameSync
9372 && mUserData.isBackedUp()
9373 && ( mUserData.backedUpData()->s.strName != mUserData->s.strName
9374 || mUserData.backedUpData()->s.llGroups.front() != mUserData->s.llGroups.front())
9375 )
9376 {
9377 bool dirRenamed = false;
9378 bool fileRenamed = false;
9379
9380 Utf8Str configFile, newConfigFile;
9381 Utf8Str configFilePrev, newConfigFilePrev;
9382 Utf8Str configDir, newConfigDir;
9383
9384 do
9385 {
9386 int vrc = VINF_SUCCESS;
9387
9388 Utf8Str name = mUserData.backedUpData()->s.strName;
9389 Utf8Str newName = mUserData->s.strName;
9390 Utf8Str group = mUserData.backedUpData()->s.llGroups.front();
9391 if (group == "/")
9392 group.setNull();
9393 Utf8Str newGroup = mUserData->s.llGroups.front();
9394 if (newGroup == "/")
9395 newGroup.setNull();
9396
9397 configFile = mData->m_strConfigFileFull;
9398
9399 /* first, rename the directory if it matches the group and machine name */
9400 Utf8Str groupPlusName = Utf8StrFmt("%s%c%s",
9401 group.c_str(), RTPATH_DELIMITER, name.c_str());
9402 /** @todo hack, make somehow use of ComposeMachineFilename */
9403 if (mUserData->s.fDirectoryIncludesUUID)
9404 groupPlusName += Utf8StrFmt(" (%RTuuid)", mData->mUuid.raw());
9405 Utf8Str newGroupPlusName = Utf8StrFmt("%s%c%s",
9406 newGroup.c_str(), RTPATH_DELIMITER, newName.c_str());
9407 /** @todo hack, make somehow use of ComposeMachineFilename */
9408 if (mUserData->s.fDirectoryIncludesUUID)
9409 newGroupPlusName += Utf8StrFmt(" (%RTuuid)", mData->mUuid.raw());
9410 configDir = configFile;
9411 configDir.stripFilename();
9412 newConfigDir = configDir;
9413 if ( configDir.length() >= groupPlusName.length()
9414 && !RTPathCompare(configDir.substr(configDir.length() - groupPlusName.length(), groupPlusName.length()).c_str(),
9415 groupPlusName.c_str()))
9416 {
9417 newConfigDir = newConfigDir.substr(0, configDir.length() - groupPlusName.length());
9418 Utf8Str newConfigBaseDir(newConfigDir);
9419 newConfigDir.append(newGroupPlusName);
9420 /* consistency: use \ if appropriate on the platform */
9421 RTPathChangeToDosSlashes(newConfigDir.mutableRaw(), false);
9422 /* new dir and old dir cannot be equal here because of 'if'
9423 * above and because name != newName */
9424 Assert(configDir != newConfigDir);
9425 if (!fSettingsFileIsNew)
9426 {
9427 /* perform real rename only if the machine is not new */
9428 vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
9429 if ( vrc == VERR_FILE_NOT_FOUND
9430 || vrc == VERR_PATH_NOT_FOUND)
9431 {
9432 /* create the parent directory, then retry renaming */
9433 Utf8Str parent(newConfigDir);
9434 parent.stripFilename();
9435 (void)RTDirCreateFullPath(parent.c_str(), 0700);
9436 vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
9437 }
9438 if (RT_FAILURE(vrc))
9439 {
9440 rc = setError(E_FAIL,
9441 tr("Could not rename the directory '%s' to '%s' to save the settings file (%Rrc)"),
9442 configDir.c_str(),
9443 newConfigDir.c_str(),
9444 vrc);
9445 break;
9446 }
9447 /* delete subdirectories which are no longer needed */
9448 Utf8Str dir(configDir);
9449 dir.stripFilename();
9450 while (dir != newConfigBaseDir && dir != ".")
9451 {
9452 vrc = RTDirRemove(dir.c_str());
9453 if (RT_FAILURE(vrc))
9454 break;
9455 dir.stripFilename();
9456 }
9457 dirRenamed = true;
9458 }
9459 }
9460
9461 newConfigFile = Utf8StrFmt("%s%c%s.vbox",
9462 newConfigDir.c_str(), RTPATH_DELIMITER, newName.c_str());
9463
9464 /* then try to rename the settings file itself */
9465 if (newConfigFile != configFile)
9466 {
9467 /* get the path to old settings file in renamed directory */
9468 configFile = Utf8StrFmt("%s%c%s",
9469 newConfigDir.c_str(),
9470 RTPATH_DELIMITER,
9471 RTPathFilename(configFile.c_str()));
9472 if (!fSettingsFileIsNew)
9473 {
9474 /* perform real rename only if the machine is not new */
9475 vrc = RTFileRename(configFile.c_str(), newConfigFile.c_str(), 0);
9476 if (RT_FAILURE(vrc))
9477 {
9478 rc = setError(E_FAIL,
9479 tr("Could not rename the settings file '%s' to '%s' (%Rrc)"),
9480 configFile.c_str(),
9481 newConfigFile.c_str(),
9482 vrc);
9483 break;
9484 }
9485 fileRenamed = true;
9486 configFilePrev = configFile;
9487 configFilePrev += "-prev";
9488 newConfigFilePrev = newConfigFile;
9489 newConfigFilePrev += "-prev";
9490 RTFileRename(configFilePrev.c_str(), newConfigFilePrev.c_str(), 0);
9491 }
9492 }
9493
9494 // update m_strConfigFileFull amd mConfigFile
9495 mData->m_strConfigFileFull = newConfigFile;
9496 // compute the relative path too
9497 mParent->i_copyPathRelativeToConfig(newConfigFile, mData->m_strConfigFile);
9498
9499 // store the old and new so that VirtualBox::i_saveSettings() can update
9500 // the media registry
9501 if ( mData->mRegistered
9502 && (configDir != newConfigDir || configFile != newConfigFile))
9503 {
9504 mParent->i_rememberMachineNameChangeForMedia(configDir, newConfigDir);
9505
9506 if (pfNeedsGlobalSaveSettings)
9507 *pfNeedsGlobalSaveSettings = true;
9508 }
9509
9510 // in the saved state file path, replace the old directory with the new directory
9511 if (RTPathStartsWith(mSSData->strStateFilePath.c_str(), configDir.c_str()))
9512 mSSData->strStateFilePath = newConfigDir.append(mSSData->strStateFilePath.c_str() + configDir.length());
9513
9514 // and do the same thing for the saved state file paths of all the online snapshots
9515 if (mData->mFirstSnapshot)
9516 mData->mFirstSnapshot->i_updateSavedStatePaths(configDir.c_str(),
9517 newConfigDir.c_str());
9518 }
9519 while (0);
9520
9521 if (FAILED(rc))
9522 {
9523 /* silently try to rename everything back */
9524 if (fileRenamed)
9525 {
9526 RTFileRename(newConfigFilePrev.c_str(), configFilePrev.c_str(), 0);
9527 RTFileRename(newConfigFile.c_str(), configFile.c_str(), 0);
9528 }
9529 if (dirRenamed)
9530 RTPathRename(newConfigDir.c_str(), configDir.c_str(), 0);
9531 }
9532
9533 if (FAILED(rc)) return rc;
9534 }
9535
9536 if (fSettingsFileIsNew)
9537 {
9538 /* create a virgin config file */
9539 int vrc = VINF_SUCCESS;
9540
9541 /* ensure the settings directory exists */
9542 Utf8Str path(mData->m_strConfigFileFull);
9543 path.stripFilename();
9544 if (!RTDirExists(path.c_str()))
9545 {
9546 vrc = RTDirCreateFullPath(path.c_str(), 0700);
9547 if (RT_FAILURE(vrc))
9548 {
9549 return setError(E_FAIL,
9550 tr("Could not create a directory '%s' to save the settings file (%Rrc)"),
9551 path.c_str(),
9552 vrc);
9553 }
9554 }
9555
9556 /* Note: open flags must correlate with RTFileOpen() in lockConfig() */
9557 path = Utf8Str(mData->m_strConfigFileFull);
9558 RTFILE f = NIL_RTFILE;
9559 vrc = RTFileOpen(&f, path.c_str(),
9560 RTFILE_O_READWRITE | RTFILE_O_CREATE | RTFILE_O_DENY_WRITE);
9561 if (RT_FAILURE(vrc))
9562 return setError(E_FAIL,
9563 tr("Could not create the settings file '%s' (%Rrc)"),
9564 path.c_str(),
9565 vrc);
9566 RTFileClose(f);
9567 }
9568
9569 return rc;
9570}
9571
9572/**
9573 * Saves and commits machine data, user data and hardware data.
9574 *
9575 * Note that on failure, the data remains uncommitted.
9576 *
9577 * @a aFlags may combine the following flags:
9578 *
9579 * - SaveS_ResetCurStateModified: Resets mData->mCurrentStateModified to FALSE.
9580 * Used when saving settings after an operation that makes them 100%
9581 * correspond to the settings from the current snapshot.
9582 * - SaveS_InformCallbacksAnyway: Callbacks will be informed even if
9583 * #isReallyModified() returns false. This is necessary for cases when we
9584 * change machine data directly, not through the backup()/commit() mechanism.
9585 * - SaveS_Force: settings will be saved without doing a deep compare of the
9586 * settings structures. This is used when this is called because snapshots
9587 * have changed to avoid the overhead of the deep compare.
9588 *
9589 * @note Must be called from under this object's write lock. Locks children for
9590 * writing.
9591 *
9592 * @param pfNeedsGlobalSaveSettings Optional pointer to a bool that must have been
9593 * initialized to false and that will be set to true by this function if
9594 * the caller must invoke VirtualBox::i_saveSettings() because the global
9595 * settings have changed. This will happen if a machine rename has been
9596 * saved and the global machine and media registries will therefore need
9597 * updating.
9598 */
9599HRESULT Machine::i_saveSettings(bool *pfNeedsGlobalSaveSettings,
9600 int aFlags /*= 0*/)
9601{
9602 LogFlowThisFuncEnter();
9603
9604 AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
9605
9606 /* make sure child objects are unable to modify the settings while we are
9607 * saving them */
9608 i_ensureNoStateDependencies();
9609
9610 AssertReturn(!i_isSnapshotMachine(),
9611 E_FAIL);
9612
9613 HRESULT rc = S_OK;
9614 bool fNeedsWrite = false;
9615
9616 /* First, prepare to save settings. It will care about renaming the
9617 * settings directory and file if the machine name was changed and about
9618 * creating a new settings file if this is a new machine. */
9619 rc = i_prepareSaveSettings(pfNeedsGlobalSaveSettings);
9620 if (FAILED(rc)) return rc;
9621
9622 // keep a pointer to the current settings structures
9623 settings::MachineConfigFile *pOldConfig = mData->pMachineConfigFile;
9624 settings::MachineConfigFile *pNewConfig = NULL;
9625
9626 try
9627 {
9628 // make a fresh one to have everyone write stuff into
9629 pNewConfig = new settings::MachineConfigFile(NULL);
9630 pNewConfig->copyBaseFrom(*mData->pMachineConfigFile);
9631
9632 // now go and copy all the settings data from COM to the settings structures
9633 // (this calles i_saveSettings() on all the COM objects in the machine)
9634 i_copyMachineDataToSettings(*pNewConfig);
9635
9636 if (aFlags & SaveS_ResetCurStateModified)
9637 {
9638 // this gets set by takeSnapshot() (if offline snapshot) and restoreSnapshot()
9639 mData->mCurrentStateModified = FALSE;
9640 fNeedsWrite = true; // always, no need to compare
9641 }
9642 else if (aFlags & SaveS_Force)
9643 {
9644 fNeedsWrite = true; // always, no need to compare
9645 }
9646 else
9647 {
9648 if (!mData->mCurrentStateModified)
9649 {
9650 // do a deep compare of the settings that we just saved with the settings
9651 // previously stored in the config file; this invokes MachineConfigFile::operator==
9652 // which does a deep compare of all the settings, which is expensive but less expensive
9653 // than writing out XML in vain
9654 bool fAnySettingsChanged = !(*pNewConfig == *pOldConfig);
9655
9656 // could still be modified if any settings changed
9657 mData->mCurrentStateModified = fAnySettingsChanged;
9658
9659 fNeedsWrite = fAnySettingsChanged;
9660 }
9661 else
9662 fNeedsWrite = true;
9663 }
9664
9665 pNewConfig->fCurrentStateModified = !!mData->mCurrentStateModified;
9666
9667 if (fNeedsWrite)
9668 // now spit it all out!
9669 pNewConfig->write(mData->m_strConfigFileFull);
9670
9671 mData->pMachineConfigFile = pNewConfig;
9672 delete pOldConfig;
9673 i_commit();
9674
9675 // after saving settings, we are no longer different from the XML on disk
9676 mData->flModifications = 0;
9677 }
9678 catch (HRESULT err)
9679 {
9680 // we assume that error info is set by the thrower
9681 rc = err;
9682
9683 // restore old config
9684 delete pNewConfig;
9685 mData->pMachineConfigFile = pOldConfig;
9686 }
9687 catch (...)
9688 {
9689 rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
9690 }
9691
9692 if (fNeedsWrite || (aFlags & SaveS_InformCallbacksAnyway))
9693 {
9694 /* Fire the data change event, even on failure (since we've already
9695 * committed all data). This is done only for SessionMachines because
9696 * mutable Machine instances are always not registered (i.e. private
9697 * to the client process that creates them) and thus don't need to
9698 * inform callbacks. */
9699 if (i_isSessionMachine())
9700 mParent->i_onMachineDataChange(mData->mUuid);
9701 }
9702
9703 LogFlowThisFunc(("rc=%08X\n", rc));
9704 LogFlowThisFuncLeave();
9705 return rc;
9706}
9707
9708/**
9709 * Implementation for saving the machine settings into the given
9710 * settings::MachineConfigFile instance. This copies machine extradata
9711 * from the previous machine config file in the instance data, if any.
9712 *
9713 * This gets called from two locations:
9714 *
9715 * -- Machine::i_saveSettings(), during the regular XML writing;
9716 *
9717 * -- Appliance::buildXMLForOneVirtualSystem(), when a machine gets
9718 * exported to OVF and we write the VirtualBox proprietary XML
9719 * into a <vbox:Machine> tag.
9720 *
9721 * This routine fills all the fields in there, including snapshots, *except*
9722 * for the following:
9723 *
9724 * -- fCurrentStateModified. There is some special logic associated with that.
9725 *
9726 * The caller can then call MachineConfigFile::write() or do something else
9727 * with it.
9728 *
9729 * Caller must hold the machine lock!
9730 *
9731 * This throws XML errors and HRESULT, so the caller must have a catch block!
9732 */
9733void Machine::i_copyMachineDataToSettings(settings::MachineConfigFile &config)
9734{
9735 // deep copy extradata
9736 config.mapExtraDataItems = mData->pMachineConfigFile->mapExtraDataItems;
9737
9738 config.uuid = mData->mUuid;
9739
9740 // copy name, description, OS type, teleport, UTC etc.
9741 config.machineUserData = mUserData->s;
9742
9743 // Encode the Icon Override data from Machine and store on config userdata.
9744 com::SafeArray<BYTE> iconByte;
9745 COMGETTER(Icon)(ComSafeArrayAsOutParam(iconByte));
9746 ssize_t cbData = iconByte.size();
9747 if (cbData > 0)
9748 {
9749 ssize_t cchOut = RTBase64EncodedLength(cbData);
9750 Utf8Str strIconData;
9751 strIconData.reserve(cchOut+1);
9752 int vrc = RTBase64Encode(iconByte.raw(), cbData,
9753 strIconData.mutableRaw(), strIconData.capacity(),
9754 NULL);
9755 if (RT_FAILURE(vrc))
9756 throw setError(E_FAIL, tr("Failure to Encode Icon Data. '%s' (%Rrc)"), strIconData.mutableRaw(), vrc);
9757 strIconData.jolt();
9758 config.machineUserData.ovIcon = strIconData;
9759 }
9760 else
9761 config.machineUserData.ovIcon.setNull();
9762
9763 if ( mData->mMachineState == MachineState_Saved
9764 || mData->mMachineState == MachineState_Restoring
9765 // when deleting a snapshot we may or may not have a saved state in the current state,
9766 // so let's not assert here please
9767 || ( ( mData->mMachineState == MachineState_DeletingSnapshot
9768 || mData->mMachineState == MachineState_DeletingSnapshotOnline
9769 || mData->mMachineState == MachineState_DeletingSnapshotPaused)
9770 && (!mSSData->strStateFilePath.isEmpty())
9771 )
9772 )
9773 {
9774 Assert(!mSSData->strStateFilePath.isEmpty());
9775 /* try to make the file name relative to the settings file dir */
9776 i_copyPathRelativeToMachine(mSSData->strStateFilePath, config.strStateFile);
9777 }
9778 else
9779 {
9780 Assert(mSSData->strStateFilePath.isEmpty() || mData->mMachineState == MachineState_Saving);
9781 config.strStateFile.setNull();
9782 }
9783
9784 if (mData->mCurrentSnapshot)
9785 config.uuidCurrentSnapshot = mData->mCurrentSnapshot->i_getId();
9786 else
9787 config.uuidCurrentSnapshot.clear();
9788
9789 config.timeLastStateChange = mData->mLastStateChange;
9790 config.fAborted = (mData->mMachineState == MachineState_Aborted);
9791 /// @todo Live Migration: config.fTeleported = (mData->mMachineState == MachineState_Teleported);
9792
9793 HRESULT rc = i_saveHardware(config.hardwareMachine, &config.debugging, &config.autostart);
9794 if (FAILED(rc)) throw rc;
9795
9796 rc = i_saveStorageControllers(config.storageMachine);
9797 if (FAILED(rc)) throw rc;
9798
9799 // save machine's media registry if this is VirtualBox 4.0 or later
9800 if (config.canHaveOwnMediaRegistry())
9801 {
9802 // determine machine folder
9803 Utf8Str strMachineFolder = i_getSettingsFileFull();
9804 strMachineFolder.stripFilename();
9805 mParent->i_saveMediaRegistry(config.mediaRegistry,
9806 i_getId(), // only media with registry ID == machine UUID
9807 strMachineFolder);
9808 // this throws HRESULT
9809 }
9810
9811 // save snapshots
9812 rc = i_saveAllSnapshots(config);
9813 if (FAILED(rc)) throw rc;
9814}
9815
9816/**
9817 * Saves all snapshots of the machine into the given machine config file. Called
9818 * from Machine::buildMachineXML() and SessionMachine::deleteSnapshotHandler().
9819 * @param config
9820 * @return
9821 */
9822HRESULT Machine::i_saveAllSnapshots(settings::MachineConfigFile &config)
9823{
9824 AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
9825
9826 HRESULT rc = S_OK;
9827
9828 try
9829 {
9830 config.llFirstSnapshot.clear();
9831
9832 if (mData->mFirstSnapshot)
9833 {
9834 settings::Snapshot snapNew;
9835 config.llFirstSnapshot.push_back(snapNew);
9836
9837 // get reference to the fresh copy of the snapshot on the list and
9838 // work on that copy directly to avoid excessive copying later
9839 settings::Snapshot &snap = config.llFirstSnapshot.front();
9840
9841 rc = mData->mFirstSnapshot->i_saveSnapshot(snap, false /*aAttrsOnly*/);
9842 if (FAILED(rc)) throw rc;
9843 }
9844
9845// if (mType == IsSessionMachine)
9846// mParent->onMachineDataChange(mData->mUuid); @todo is this necessary?
9847
9848 }
9849 catch (HRESULT err)
9850 {
9851 /* we assume that error info is set by the thrower */
9852 rc = err;
9853 }
9854 catch (...)
9855 {
9856 rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
9857 }
9858
9859 return rc;
9860}
9861
9862/**
9863 * Saves the VM hardware configuration. It is assumed that the
9864 * given node is empty.
9865 *
9866 * @param data Reference to the settings object for the hardware config.
9867 * @param pDbg Pointer to the settings object for the debugging config
9868 * which happens to live in mHWData.
9869 * @param pAutostart Pointer to the settings object for the autostart config
9870 * which happens to live in mHWData.
9871 */
9872HRESULT Machine::i_saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
9873 settings::Autostart *pAutostart)
9874{
9875 HRESULT rc = S_OK;
9876
9877 try
9878 {
9879 /* The hardware version attribute (optional).
9880 Automatically upgrade from 1 to 2 when there is no saved state. (ugly!) */
9881 if ( mHWData->mHWVersion == "1"
9882 && mSSData->strStateFilePath.isEmpty()
9883 )
9884 mHWData->mHWVersion = "2"; /** @todo Is this safe, to update mHWVersion here? If not some
9885 other point needs to be found where this can be done. */
9886
9887 data.strVersion = mHWData->mHWVersion;
9888 data.uuid = mHWData->mHardwareUUID;
9889
9890 // CPU
9891 data.fHardwareVirt = !!mHWData->mHWVirtExEnabled;
9892 data.fNestedPaging = !!mHWData->mHWVirtExNestedPagingEnabled;
9893 data.fLargePages = !!mHWData->mHWVirtExLargePagesEnabled;
9894 data.fVPID = !!mHWData->mHWVirtExVPIDEnabled;
9895 data.fUnrestrictedExecution = !!mHWData->mHWVirtExUXEnabled;
9896 data.fHardwareVirtForce = !!mHWData->mHWVirtExForceEnabled;
9897 data.fPAE = !!mHWData->mPAEEnabled;
9898 data.enmLongMode = mHWData->mLongMode;
9899 data.fSyntheticCpu = !!mHWData->mSyntheticCpu;
9900 data.fTripleFaultReset = !!mHWData->mTripleFaultReset;
9901
9902 /* Standard and Extended CPUID leafs. */
9903 data.llCpuIdLeafs.clear();
9904 for (unsigned idx = 0; idx < RT_ELEMENTS(mHWData->mCpuIdStdLeafs); ++idx)
9905 {
9906 if (mHWData->mCpuIdStdLeafs[idx].ulId != UINT32_MAX)
9907 data.llCpuIdLeafs.push_back(mHWData->mCpuIdStdLeafs[idx]);
9908 }
9909 for (unsigned idx = 0; idx < RT_ELEMENTS(mHWData->mCpuIdExtLeafs); ++idx)
9910 {
9911 if (mHWData->mCpuIdExtLeafs[idx].ulId != UINT32_MAX)
9912 data.llCpuIdLeafs.push_back(mHWData->mCpuIdExtLeafs[idx]);
9913 }
9914
9915 data.cCPUs = mHWData->mCPUCount;
9916 data.fCpuHotPlug = !!mHWData->mCPUHotPlugEnabled;
9917 data.ulCpuExecutionCap = mHWData->mCpuExecutionCap;
9918
9919 data.llCpus.clear();
9920 if (data.fCpuHotPlug)
9921 {
9922 for (unsigned idx = 0; idx < data.cCPUs; ++idx)
9923 {
9924 if (mHWData->mCPUAttached[idx])
9925 {
9926 settings::Cpu cpu;
9927 cpu.ulId = idx;
9928 data.llCpus.push_back(cpu);
9929 }
9930 }
9931 }
9932
9933 // memory
9934 data.ulMemorySizeMB = mHWData->mMemorySize;
9935 data.fPageFusionEnabled = !!mHWData->mPageFusionEnabled;
9936
9937 // firmware
9938 data.firmwareType = mHWData->mFirmwareType;
9939
9940 // HID
9941 data.pointingHIDType = mHWData->mPointingHIDType;
9942 data.keyboardHIDType = mHWData->mKeyboardHIDType;
9943
9944 // chipset
9945 data.chipsetType = mHWData->mChipsetType;
9946
9947 // paravirt
9948 data.paravirtProvider = mHWData->mParavirtProvider;
9949
9950
9951 data.fEmulatedUSBCardReader = !!mHWData->mEmulatedUSBCardReaderEnabled;
9952
9953 // HPET
9954 data.fHPETEnabled = !!mHWData->mHPETEnabled;
9955
9956 // boot order
9957 data.mapBootOrder.clear();
9958 for (size_t i = 0; i < RT_ELEMENTS(mHWData->mBootOrder); ++i)
9959 data.mapBootOrder[i] = mHWData->mBootOrder[i];
9960
9961 // display
9962 data.graphicsControllerType = mHWData->mGraphicsControllerType;
9963 data.ulVRAMSizeMB = mHWData->mVRAMSize;
9964 data.cMonitors = mHWData->mMonitorCount;
9965 data.fAccelerate3D = !!mHWData->mAccelerate3DEnabled;
9966 data.fAccelerate2DVideo = !!mHWData->mAccelerate2DVideoEnabled;
9967 data.ulVideoCaptureHorzRes = mHWData->mVideoCaptureWidth;
9968 data.ulVideoCaptureVertRes = mHWData->mVideoCaptureHeight;
9969 data.ulVideoCaptureRate = mHWData->mVideoCaptureRate;
9970 data.ulVideoCaptureFPS = mHWData->mVideoCaptureFPS;
9971 data.fVideoCaptureEnabled = !!mHWData->mVideoCaptureEnabled;
9972 for (unsigned i = 0; i < sizeof(data.u64VideoCaptureScreens) * 8; ++i)
9973 {
9974 if (mHWData->maVideoCaptureScreens[i])
9975 ASMBitSet(&data.u64VideoCaptureScreens, i);
9976 else
9977 ASMBitClear(&data.u64VideoCaptureScreens, i);
9978 }
9979 /* store relative video capture file if possible */
9980 i_copyPathRelativeToMachine(mHWData->mVideoCaptureFile, data.strVideoCaptureFile);
9981
9982 /* VRDEServer settings (optional) */
9983 rc = mVRDEServer->i_saveSettings(data.vrdeSettings);
9984 if (FAILED(rc)) throw rc;
9985
9986 /* BIOS (required) */
9987 rc = mBIOSSettings->i_saveSettings(data.biosSettings);
9988 if (FAILED(rc)) throw rc;
9989
9990 /* USB Controller (required) */
9991 for (USBControllerList::const_iterator it = mUSBControllers->begin(); it != mUSBControllers->end(); ++it)
9992 {
9993 ComObjPtr<USBController> ctrl = *it;
9994 settings::USBController settingsCtrl;
9995
9996 settingsCtrl.strName = ctrl->i_getName();
9997 settingsCtrl.enmType = ctrl->i_getControllerType();
9998
9999 data.usbSettings.llUSBControllers.push_back(settingsCtrl);
10000 }
10001
10002 /* USB device filters (required) */
10003 rc = mUSBDeviceFilters->i_saveSettings(data.usbSettings);
10004 if (FAILED(rc)) throw rc;
10005
10006 /* Network adapters (required) */
10007 uint32_t uMaxNICs = RT_MIN(Global::getMaxNetworkAdapters(mHWData->mChipsetType), mNetworkAdapters.size());
10008 data.llNetworkAdapters.clear();
10009 /* Write out only the nominal number of network adapters for this
10010 * chipset type. Since Machine::commit() hasn't been called there
10011 * may be extra NIC settings in the vector. */
10012 for (ULONG slot = 0; slot < uMaxNICs; ++slot)
10013 {
10014 settings::NetworkAdapter nic;
10015 nic.ulSlot = slot;
10016 /* paranoia check... must not be NULL, but must not crash either. */
10017 if (mNetworkAdapters[slot])
10018 {
10019 rc = mNetworkAdapters[slot]->i_saveSettings(nic);
10020 if (FAILED(rc)) throw rc;
10021
10022 data.llNetworkAdapters.push_back(nic);
10023 }
10024 }
10025
10026 /* Serial ports */
10027 data.llSerialPorts.clear();
10028 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
10029 {
10030 settings::SerialPort s;
10031 s.ulSlot = slot;
10032 rc = mSerialPorts[slot]->i_saveSettings(s);
10033 if (FAILED(rc)) return rc;
10034
10035 data.llSerialPorts.push_back(s);
10036 }
10037
10038 /* Parallel ports */
10039 data.llParallelPorts.clear();
10040 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
10041 {
10042 settings::ParallelPort p;
10043 p.ulSlot = slot;
10044 rc = mParallelPorts[slot]->i_saveSettings(p);
10045 if (FAILED(rc)) return rc;
10046
10047 data.llParallelPorts.push_back(p);
10048 }
10049
10050 /* Audio adapter */
10051 rc = mAudioAdapter->i_saveSettings(data.audioAdapter);
10052 if (FAILED(rc)) return rc;
10053
10054 /* Shared folders */
10055 data.llSharedFolders.clear();
10056 for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
10057 it != mHWData->mSharedFolders.end();
10058 ++it)
10059 {
10060 SharedFolder *pSF = *it;
10061 AutoCaller sfCaller(pSF);
10062 AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
10063 settings::SharedFolder sf;
10064 sf.strName = pSF->i_getName();
10065 sf.strHostPath = pSF->i_getHostPath();
10066 sf.fWritable = !!pSF->i_isWritable();
10067 sf.fAutoMount = !!pSF->i_isAutoMounted();
10068
10069 data.llSharedFolders.push_back(sf);
10070 }
10071
10072 // clipboard
10073 data.clipboardMode = mHWData->mClipboardMode;
10074
10075 // drag'n'drop
10076 data.dndMode = mHWData->mDnDMode;
10077
10078 /* Guest */
10079 data.ulMemoryBalloonSize = mHWData->mMemoryBalloonSize;
10080
10081 // IO settings
10082 data.ioSettings.fIOCacheEnabled = !!mHWData->mIOCacheEnabled;
10083 data.ioSettings.ulIOCacheSize = mHWData->mIOCacheSize;
10084
10085 /* BandwidthControl (required) */
10086 rc = mBandwidthControl->i_saveSettings(data.ioSettings);
10087 if (FAILED(rc)) throw rc;
10088
10089 /* Host PCI devices */
10090 for (HWData::PCIDeviceAssignmentList::const_iterator it = mHWData->mPCIDeviceAssignments.begin();
10091 it != mHWData->mPCIDeviceAssignments.end();
10092 ++it)
10093 {
10094 ComObjPtr<PCIDeviceAttachment> pda = *it;
10095 settings::HostPCIDeviceAttachment hpda;
10096
10097 rc = pda->i_saveSettings(hpda);
10098 if (FAILED(rc)) throw rc;
10099
10100 data.pciAttachments.push_back(hpda);
10101 }
10102
10103
10104 // guest properties
10105 data.llGuestProperties.clear();
10106#ifdef VBOX_WITH_GUEST_PROPS
10107 for (HWData::GuestPropertyMap::const_iterator it = mHWData->mGuestProperties.begin();
10108 it != mHWData->mGuestProperties.end();
10109 ++it)
10110 {
10111 HWData::GuestProperty property = it->second;
10112
10113 /* Remove transient guest properties at shutdown unless we
10114 * are saving state */
10115 if ( ( mData->mMachineState == MachineState_PoweredOff
10116 || mData->mMachineState == MachineState_Aborted
10117 || mData->mMachineState == MachineState_Teleported)
10118 && ( property.mFlags & guestProp::TRANSIENT
10119 || property.mFlags & guestProp::TRANSRESET))
10120 continue;
10121 settings::GuestProperty prop;
10122 prop.strName = it->first;
10123 prop.strValue = property.strValue;
10124 prop.timestamp = property.mTimestamp;
10125 char szFlags[guestProp::MAX_FLAGS_LEN + 1];
10126 guestProp::writeFlags(property.mFlags, szFlags);
10127 prop.strFlags = szFlags;
10128
10129 data.llGuestProperties.push_back(prop);
10130 }
10131
10132 data.strNotificationPatterns = mHWData->mGuestPropertyNotificationPatterns;
10133 /* I presume this doesn't require a backup(). */
10134 mData->mGuestPropertiesModified = FALSE;
10135#endif /* VBOX_WITH_GUEST_PROPS defined */
10136
10137 *pDbg = mHWData->mDebugging;
10138 *pAutostart = mHWData->mAutostart;
10139
10140 data.strDefaultFrontend = mHWData->mDefaultFrontend;
10141 }
10142 catch(std::bad_alloc &)
10143 {
10144 return E_OUTOFMEMORY;
10145 }
10146
10147 AssertComRC(rc);
10148 return rc;
10149}
10150
10151/**
10152 * Saves the storage controller configuration.
10153 *
10154 * @param aNode <StorageControllers> node to save the VM hardware configuration to.
10155 */
10156HRESULT Machine::i_saveStorageControllers(settings::Storage &data)
10157{
10158 data.llStorageControllers.clear();
10159
10160 for (StorageControllerList::const_iterator it = mStorageControllers->begin();
10161 it != mStorageControllers->end();
10162 ++it)
10163 {
10164 HRESULT rc;
10165 ComObjPtr<StorageController> pCtl = *it;
10166
10167 settings::StorageController ctl;
10168 ctl.strName = pCtl->i_getName();
10169 ctl.controllerType = pCtl->i_getControllerType();
10170 ctl.storageBus = pCtl->i_getStorageBus();
10171 ctl.ulInstance = pCtl->i_getInstance();
10172 ctl.fBootable = pCtl->i_getBootable();
10173
10174 /* Save the port count. */
10175 ULONG portCount;
10176 rc = pCtl->COMGETTER(PortCount)(&portCount);
10177 ComAssertComRCRet(rc, rc);
10178 ctl.ulPortCount = portCount;
10179
10180 /* Save fUseHostIOCache */
10181 BOOL fUseHostIOCache;
10182 rc = pCtl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
10183 ComAssertComRCRet(rc, rc);
10184 ctl.fUseHostIOCache = !!fUseHostIOCache;
10185
10186 /* Save IDE emulation settings. */
10187 if (ctl.controllerType == StorageControllerType_IntelAhci)
10188 {
10189 if ( (FAILED(rc = pCtl->i_getIDEEmulationPort(0, (LONG*)&ctl.lIDE0MasterEmulationPort)))
10190 || (FAILED(rc = pCtl->i_getIDEEmulationPort(1, (LONG*)&ctl.lIDE0SlaveEmulationPort)))
10191 || (FAILED(rc = pCtl->i_getIDEEmulationPort(2, (LONG*)&ctl.lIDE1MasterEmulationPort)))
10192 || (FAILED(rc = pCtl->i_getIDEEmulationPort(3, (LONG*)&ctl.lIDE1SlaveEmulationPort)))
10193 )
10194 ComAssertComRCRet(rc, rc);
10195 }
10196
10197 /* save the devices now. */
10198 rc = i_saveStorageDevices(pCtl, ctl);
10199 ComAssertComRCRet(rc, rc);
10200
10201 data.llStorageControllers.push_back(ctl);
10202 }
10203
10204 return S_OK;
10205}
10206
10207/**
10208 * Saves the hard disk configuration.
10209 */
10210HRESULT Machine::i_saveStorageDevices(ComObjPtr<StorageController> aStorageController,
10211 settings::StorageController &data)
10212{
10213 MediaData::AttachmentList atts;
10214
10215 HRESULT rc = i_getMediumAttachmentsOfController(aStorageController->i_getName(), atts);
10216 if (FAILED(rc)) return rc;
10217
10218 data.llAttachedDevices.clear();
10219 for (MediaData::AttachmentList::const_iterator it = atts.begin();
10220 it != atts.end();
10221 ++it)
10222 {
10223 settings::AttachedDevice dev;
10224 IMediumAttachment *iA = *it;
10225 MediumAttachment *pAttach = static_cast<MediumAttachment *>(iA);
10226 Medium *pMedium = pAttach->i_getMedium();
10227
10228 dev.deviceType = pAttach->i_getType();
10229 dev.lPort = pAttach->i_getPort();
10230 dev.lDevice = pAttach->i_getDevice();
10231 dev.fPassThrough = pAttach->i_getPassthrough();
10232 dev.fHotPluggable = pAttach->i_getHotPluggable();
10233 if (pMedium)
10234 {
10235 if (pMedium->i_isHostDrive())
10236 dev.strHostDriveSrc = pMedium->i_getLocationFull();
10237 else
10238 dev.uuid = pMedium->i_getId();
10239 dev.fTempEject = pAttach->i_getTempEject();
10240 dev.fNonRotational = pAttach->i_getNonRotational();
10241 dev.fDiscard = pAttach->i_getDiscard();
10242 }
10243
10244 dev.strBwGroup = pAttach->i_getBandwidthGroup();
10245
10246 data.llAttachedDevices.push_back(dev);
10247 }
10248
10249 return S_OK;
10250}
10251
10252/**
10253 * Saves machine state settings as defined by aFlags
10254 * (SaveSTS_* values).
10255 *
10256 * @param aFlags Combination of SaveSTS_* flags.
10257 *
10258 * @note Locks objects for writing.
10259 */
10260HRESULT Machine::i_saveStateSettings(int aFlags)
10261{
10262 if (aFlags == 0)
10263 return S_OK;
10264
10265 AutoCaller autoCaller(this);
10266 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10267
10268 /* This object's write lock is also necessary to serialize file access
10269 * (prevent concurrent reads and writes) */
10270 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10271
10272 HRESULT rc = S_OK;
10273
10274 Assert(mData->pMachineConfigFile);
10275
10276 try
10277 {
10278 if (aFlags & SaveSTS_CurStateModified)
10279 mData->pMachineConfigFile->fCurrentStateModified = true;
10280
10281 if (aFlags & SaveSTS_StateFilePath)
10282 {
10283 if (!mSSData->strStateFilePath.isEmpty())
10284 /* try to make the file name relative to the settings file dir */
10285 i_copyPathRelativeToMachine(mSSData->strStateFilePath, mData->pMachineConfigFile->strStateFile);
10286 else
10287 mData->pMachineConfigFile->strStateFile.setNull();
10288 }
10289
10290 if (aFlags & SaveSTS_StateTimeStamp)
10291 {
10292 Assert( mData->mMachineState != MachineState_Aborted
10293 || mSSData->strStateFilePath.isEmpty());
10294
10295 mData->pMachineConfigFile->timeLastStateChange = mData->mLastStateChange;
10296
10297 mData->pMachineConfigFile->fAborted = (mData->mMachineState == MachineState_Aborted);
10298//@todo live migration mData->pMachineConfigFile->fTeleported = (mData->mMachineState == MachineState_Teleported);
10299 }
10300
10301 mData->pMachineConfigFile->write(mData->m_strConfigFileFull);
10302 }
10303 catch (...)
10304 {
10305 rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
10306 }
10307
10308 return rc;
10309}
10310
10311/**
10312 * Ensures that the given medium is added to a media registry. If this machine
10313 * was created with 4.0 or later, then the machine registry is used. Otherwise
10314 * the global VirtualBox media registry is used.
10315 *
10316 * Caller must NOT hold machine lock, media tree or any medium locks!
10317 *
10318 * @param pMedium
10319 */
10320void Machine::i_addMediumToRegistry(ComObjPtr<Medium> &pMedium)
10321{
10322 /* Paranoia checks: do not hold machine or media tree locks. */
10323 AssertReturnVoid(!isWriteLockOnCurrentThread());
10324 AssertReturnVoid(!mParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
10325
10326 ComObjPtr<Medium> pBase;
10327 {
10328 AutoReadLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10329 pBase = pMedium->i_getBase();
10330 }
10331
10332 /* Paranoia checks: do not hold medium locks. */
10333 AssertReturnVoid(!pMedium->isWriteLockOnCurrentThread());
10334 AssertReturnVoid(!pBase->isWriteLockOnCurrentThread());
10335
10336 // decide which medium registry to use now that the medium is attached:
10337 Guid uuid;
10338 if (mData->pMachineConfigFile->canHaveOwnMediaRegistry())
10339 // machine XML is VirtualBox 4.0 or higher:
10340 uuid = i_getId(); // machine UUID
10341 else
10342 uuid = mParent->i_getGlobalRegistryId(); // VirtualBox global registry UUID
10343
10344 if (pMedium->i_addRegistry(uuid, false /* fRecurse */))
10345 mParent->i_markRegistryModified(uuid);
10346
10347 /* For more complex hard disk structures it can happen that the base
10348 * medium isn't yet associated with any medium registry. Do that now. */
10349 if (pMedium != pBase)
10350 {
10351 if (pBase->i_addRegistry(uuid, true /* fRecurse */))
10352 mParent->i_markRegistryModified(uuid);
10353 }
10354}
10355
10356/**
10357 * Creates differencing hard disks for all normal hard disks attached to this
10358 * machine and a new set of attachments to refer to created disks.
10359 *
10360 * Used when taking a snapshot or when deleting the current state. Gets called
10361 * from SessionMachine::BeginTakingSnapshot() and SessionMachine::restoreSnapshotHandler().
10362 *
10363 * This method assumes that mMediaData contains the original hard disk attachments
10364 * it needs to create diffs for. On success, these attachments will be replaced
10365 * with the created diffs. On failure, #deleteImplicitDiffs() is implicitly
10366 * called to delete created diffs which will also rollback mMediaData and restore
10367 * whatever was backed up before calling this method.
10368 *
10369 * Attachments with non-normal hard disks are left as is.
10370 *
10371 * If @a aOnline is @c false then the original hard disks that require implicit
10372 * diffs will be locked for reading. Otherwise it is assumed that they are
10373 * already locked for writing (when the VM was started). Note that in the latter
10374 * case it is responsibility of the caller to lock the newly created diffs for
10375 * writing if this method succeeds.
10376 *
10377 * @param aProgress Progress object to run (must contain at least as
10378 * many operations left as the number of hard disks
10379 * attached).
10380 * @param aOnline Whether the VM was online prior to this operation.
10381 *
10382 * @note The progress object is not marked as completed, neither on success nor
10383 * on failure. This is a responsibility of the caller.
10384 *
10385 * @note Locks this object and the media tree for writing.
10386 */
10387HRESULT Machine::i_createImplicitDiffs(IProgress *aProgress,
10388 ULONG aWeight,
10389 bool aOnline)
10390{
10391 LogFlowThisFunc(("aOnline=%d\n", aOnline));
10392
10393 AutoCaller autoCaller(this);
10394 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10395
10396 AutoMultiWriteLock2 alock(this->lockHandle(),
10397 &mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10398
10399 /* must be in a protective state because we release the lock below */
10400 AssertReturn( mData->mMachineState == MachineState_Saving
10401 || mData->mMachineState == MachineState_LiveSnapshotting
10402 || mData->mMachineState == MachineState_RestoringSnapshot
10403 || mData->mMachineState == MachineState_DeletingSnapshot
10404 , E_FAIL);
10405
10406 HRESULT rc = S_OK;
10407
10408 // use appropriate locked media map (online or offline)
10409 MediumLockListMap lockedMediaOffline;
10410 MediumLockListMap *lockedMediaMap;
10411 if (aOnline)
10412 lockedMediaMap = &mData->mSession.mLockedMedia;
10413 else
10414 lockedMediaMap = &lockedMediaOffline;
10415
10416 try
10417 {
10418 if (!aOnline)
10419 {
10420 /* lock all attached hard disks early to detect "in use"
10421 * situations before creating actual diffs */
10422 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
10423 it != mMediaData->mAttachments.end();
10424 ++it)
10425 {
10426 MediumAttachment* pAtt = *it;
10427 if (pAtt->i_getType() == DeviceType_HardDisk)
10428 {
10429 Medium* pMedium = pAtt->i_getMedium();
10430 Assert(pMedium);
10431
10432 MediumLockList *pMediumLockList(new MediumLockList());
10433 alock.release();
10434 rc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
10435 false /* fMediumLockWrite */,
10436 NULL,
10437 *pMediumLockList);
10438 alock.acquire();
10439 if (FAILED(rc))
10440 {
10441 delete pMediumLockList;
10442 throw rc;
10443 }
10444 rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
10445 if (FAILED(rc))
10446 {
10447 throw setError(rc,
10448 tr("Collecting locking information for all attached media failed"));
10449 }
10450 }
10451 }
10452
10453 /* Now lock all media. If this fails, nothing is locked. */
10454 alock.release();
10455 rc = lockedMediaMap->Lock();
10456 alock.acquire();
10457 if (FAILED(rc))
10458 {
10459 throw setError(rc,
10460 tr("Locking of attached media failed"));
10461 }
10462 }
10463
10464 /* remember the current list (note that we don't use backup() since
10465 * mMediaData may be already backed up) */
10466 MediaData::AttachmentList atts = mMediaData->mAttachments;
10467
10468 /* start from scratch */
10469 mMediaData->mAttachments.clear();
10470
10471 /* go through remembered attachments and create diffs for normal hard
10472 * disks and attach them */
10473 for (MediaData::AttachmentList::const_iterator it = atts.begin();
10474 it != atts.end();
10475 ++it)
10476 {
10477 MediumAttachment* pAtt = *it;
10478
10479 DeviceType_T devType = pAtt->i_getType();
10480 Medium* pMedium = pAtt->i_getMedium();
10481
10482 if ( devType != DeviceType_HardDisk
10483 || pMedium == NULL
10484 || pMedium->i_getType() != MediumType_Normal)
10485 {
10486 /* copy the attachment as is */
10487
10488 /** @todo the progress object created in Console::TakeSnaphot
10489 * only expects operations for hard disks. Later other
10490 * device types need to show up in the progress as well. */
10491 if (devType == DeviceType_HardDisk)
10492 {
10493 if (pMedium == NULL)
10494 aProgress->SetNextOperation(Bstr(tr("Skipping attachment without medium")).raw(),
10495 aWeight); // weight
10496 else
10497 aProgress->SetNextOperation(BstrFmt(tr("Skipping medium '%s'"),
10498 pMedium->i_getBase()->i_getName().c_str()).raw(),
10499 aWeight); // weight
10500 }
10501
10502 mMediaData->mAttachments.push_back(pAtt);
10503 continue;
10504 }
10505
10506 /* need a diff */
10507 aProgress->SetNextOperation(BstrFmt(tr("Creating differencing hard disk for '%s'"),
10508 pMedium->i_getBase()->i_getName().c_str()).raw(),
10509 aWeight); // weight
10510
10511 Utf8Str strFullSnapshotFolder;
10512 i_calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
10513
10514 ComObjPtr<Medium> diff;
10515 diff.createObject();
10516 // store the diff in the same registry as the parent
10517 // (this cannot fail here because we can't create implicit diffs for
10518 // unregistered images)
10519 Guid uuidRegistryParent;
10520 bool fInRegistry = pMedium->i_getFirstRegistryMachineId(uuidRegistryParent);
10521 Assert(fInRegistry); NOREF(fInRegistry);
10522 rc = diff->init(mParent,
10523 pMedium->i_getPreferredDiffFormat(),
10524 strFullSnapshotFolder.append(RTPATH_SLASH_STR),
10525 uuidRegistryParent);
10526 if (FAILED(rc)) throw rc;
10527
10528 /** @todo r=bird: How is the locking and diff image cleaned up if we fail before
10529 * the push_back? Looks like we're going to release medium with the
10530 * wrong kind of lock (general issue with if we fail anywhere at all)
10531 * and an orphaned VDI in the snapshots folder. */
10532
10533 /* update the appropriate lock list */
10534 MediumLockList *pMediumLockList;
10535 rc = lockedMediaMap->Get(pAtt, pMediumLockList);
10536 AssertComRCThrowRC(rc);
10537 if (aOnline)
10538 {
10539 alock.release();
10540 /* The currently attached medium will be read-only, change
10541 * the lock type to read. */
10542 rc = pMediumLockList->Update(pMedium, false);
10543 alock.acquire();
10544 AssertComRCThrowRC(rc);
10545 }
10546
10547 /* release the locks before the potentially lengthy operation */
10548 alock.release();
10549 rc = pMedium->i_createDiffStorage(diff, MediumVariant_Standard,
10550 pMediumLockList,
10551 NULL /* aProgress */,
10552 true /* aWait */);
10553 alock.acquire();
10554 if (FAILED(rc)) throw rc;
10555
10556 /* actual lock list update is done in Medium::commitMedia */
10557
10558 rc = diff->i_addBackReference(mData->mUuid);
10559 AssertComRCThrowRC(rc);
10560
10561 /* add a new attachment */
10562 ComObjPtr<MediumAttachment> attachment;
10563 attachment.createObject();
10564 rc = attachment->init(this,
10565 diff,
10566 pAtt->i_getControllerName(),
10567 pAtt->i_getPort(),
10568 pAtt->i_getDevice(),
10569 DeviceType_HardDisk,
10570 true /* aImplicit */,
10571 false /* aPassthrough */,
10572 false /* aTempEject */,
10573 pAtt->i_getNonRotational(),
10574 pAtt->i_getDiscard(),
10575 pAtt->i_getHotPluggable(),
10576 pAtt->i_getBandwidthGroup());
10577 if (FAILED(rc)) throw rc;
10578
10579 rc = lockedMediaMap->ReplaceKey(pAtt, attachment);
10580 AssertComRCThrowRC(rc);
10581 mMediaData->mAttachments.push_back(attachment);
10582 }
10583 }
10584 catch (HRESULT aRC) { rc = aRC; }
10585
10586 /* unlock all hard disks we locked when there is no VM */
10587 if (!aOnline)
10588 {
10589 ErrorInfoKeeper eik;
10590
10591 HRESULT rc1 = lockedMediaMap->Clear();
10592 AssertComRC(rc1);
10593 }
10594
10595 return rc;
10596}
10597
10598/**
10599 * Deletes implicit differencing hard disks created either by
10600 * #createImplicitDiffs() or by #AttachDevice() and rolls back mMediaData.
10601 *
10602 * Note that to delete hard disks created by #AttachDevice() this method is
10603 * called from #fixupMedia() when the changes are rolled back.
10604 *
10605 * @note Locks this object and the media tree for writing.
10606 */
10607HRESULT Machine::i_deleteImplicitDiffs(bool aOnline)
10608{
10609 LogFlowThisFunc(("aOnline=%d\n", aOnline));
10610
10611 AutoCaller autoCaller(this);
10612 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10613
10614 AutoMultiWriteLock2 alock(this->lockHandle(),
10615 &mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
10616
10617 /* We absolutely must have backed up state. */
10618 AssertReturn(mMediaData.isBackedUp(), E_FAIL);
10619
10620 /* Check if there are any implicitly created diff images. */
10621 bool fImplicitDiffs = false;
10622 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
10623 it != mMediaData->mAttachments.end();
10624 ++it)
10625 {
10626 const ComObjPtr<MediumAttachment> &pAtt = *it;
10627 if (pAtt->i_isImplicit())
10628 {
10629 fImplicitDiffs = true;
10630 break;
10631 }
10632 }
10633 /* If there is nothing to do, leave early. This saves lots of image locking
10634 * effort. It also avoids a MachineStateChanged event without real reason.
10635 * This is important e.g. when loading a VM config, because there should be
10636 * no events. Otherwise API clients can become thoroughly confused for
10637 * inaccessible VMs (the code for loading VM configs uses this method for
10638 * cleanup if the config makes no sense), as they take such events as an
10639 * indication that the VM is alive, and they would force the VM config to
10640 * be reread, leading to an endless loop. */
10641 if (!fImplicitDiffs)
10642 return S_OK;
10643
10644 HRESULT rc = S_OK;
10645 MachineState_T oldState = mData->mMachineState;
10646
10647 /* will release the lock before the potentially lengthy operation,
10648 * so protect with the special state (unless already protected) */
10649 if ( oldState != MachineState_Saving
10650 && oldState != MachineState_LiveSnapshotting
10651 && oldState != MachineState_RestoringSnapshot
10652 && oldState != MachineState_DeletingSnapshot
10653 && oldState != MachineState_DeletingSnapshotOnline
10654 && oldState != MachineState_DeletingSnapshotPaused
10655 )
10656 i_setMachineState(MachineState_SettingUp);
10657
10658 // use appropriate locked media map (online or offline)
10659 MediumLockListMap lockedMediaOffline;
10660 MediumLockListMap *lockedMediaMap;
10661 if (aOnline)
10662 lockedMediaMap = &mData->mSession.mLockedMedia;
10663 else
10664 lockedMediaMap = &lockedMediaOffline;
10665
10666 try
10667 {
10668 if (!aOnline)
10669 {
10670 /* lock all attached hard disks early to detect "in use"
10671 * situations before deleting actual diffs */
10672 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
10673 it != mMediaData->mAttachments.end();
10674 ++it)
10675 {
10676 MediumAttachment* pAtt = *it;
10677 if (pAtt->i_getType() == DeviceType_HardDisk)
10678 {
10679 Medium* pMedium = pAtt->i_getMedium();
10680 Assert(pMedium);
10681
10682 MediumLockList *pMediumLockList(new MediumLockList());
10683 alock.release();
10684 rc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
10685 false /* fMediumLockWrite */,
10686 NULL,
10687 *pMediumLockList);
10688 alock.acquire();
10689
10690 if (FAILED(rc))
10691 {
10692 delete pMediumLockList;
10693 throw rc;
10694 }
10695
10696 rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
10697 if (FAILED(rc))
10698 throw rc;
10699 }
10700 }
10701
10702 if (FAILED(rc))
10703 throw rc;
10704 } // end of offline
10705
10706 /* Lock lists are now up to date and include implicitly created media */
10707
10708 /* Go through remembered attachments and delete all implicitly created
10709 * diffs and fix up the attachment information */
10710 const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
10711 MediaData::AttachmentList implicitAtts;
10712 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
10713 it != mMediaData->mAttachments.end();
10714 ++it)
10715 {
10716 ComObjPtr<MediumAttachment> pAtt = *it;
10717 ComObjPtr<Medium> pMedium = pAtt->i_getMedium();
10718 if (pMedium.isNull())
10719 continue;
10720
10721 // Implicit attachments go on the list for deletion and back references are removed.
10722 if (pAtt->i_isImplicit())
10723 {
10724 /* Deassociate and mark for deletion */
10725 LogFlowThisFunc(("Detaching '%s', pending deletion\n", pAtt->i_getLogName()));
10726 rc = pMedium->i_removeBackReference(mData->mUuid);
10727 if (FAILED(rc))
10728 throw rc;
10729 implicitAtts.push_back(pAtt);
10730 continue;
10731 }
10732
10733 /* Was this medium attached before? */
10734 if (!i_findAttachment(oldAtts, pMedium))
10735 {
10736 /* no: de-associate */
10737 LogFlowThisFunc(("Detaching '%s', no deletion\n", pAtt->i_getLogName()));
10738 rc = pMedium->i_removeBackReference(mData->mUuid);
10739 if (FAILED(rc))
10740 throw rc;
10741 continue;
10742 }
10743 LogFlowThisFunc(("Not detaching '%s'\n", pAtt->i_getLogName()));
10744 }
10745
10746 /* If there are implicit attachments to delete, throw away the lock
10747 * map contents (which will unlock all media) since the medium
10748 * attachments will be rolled back. Below we need to completely
10749 * recreate the lock map anyway since it is infinitely complex to
10750 * do this incrementally (would need reconstructing each attachment
10751 * change, which would be extremely hairy). */
10752 if (implicitAtts.size() != 0)
10753 {
10754 ErrorInfoKeeper eik;
10755
10756 HRESULT rc1 = lockedMediaMap->Clear();
10757 AssertComRC(rc1);
10758 }
10759
10760 /* rollback hard disk changes */
10761 mMediaData.rollback();
10762
10763 MultiResult mrc(S_OK);
10764
10765 // Delete unused implicit diffs.
10766 if (implicitAtts.size() != 0)
10767 {
10768 alock.release();
10769
10770 for (MediaData::AttachmentList::const_iterator it = implicitAtts.begin(); it != implicitAtts.end(); ++it)
10771 {
10772 // Remove medium associated with this attachment.
10773 ComObjPtr<MediumAttachment> pAtt = *it;
10774 Assert(pAtt);
10775 LogFlowThisFunc(("Deleting '%s'\n", pAtt->i_getLogName()));
10776 ComObjPtr<Medium> pMedium = pAtt->i_getMedium();
10777 Assert(pMedium);
10778
10779 rc = pMedium->i_deleteStorage(NULL /*aProgress*/, true /*aWait*/);
10780 // continue on delete failure, just collect error messages
10781 AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, pAtt->i_getLogName(),
10782 pMedium->i_getLocationFull().c_str() ));
10783 mrc = rc;
10784 }
10785
10786 alock.acquire();
10787
10788 /* if there is a VM recreate media lock map as mentioned above,
10789 * otherwise it is a waste of time and we leave things unlocked */
10790 if (aOnline)
10791 {
10792 const ComObjPtr<SessionMachine> pMachine = mData->mSession.mMachine;
10793 /* must never be NULL, but better safe than sorry */
10794 if (!pMachine.isNull())
10795 {
10796 alock.release();
10797 rc = mData->mSession.mMachine->lockMedia();
10798 alock.acquire();
10799 if (FAILED(rc))
10800 throw rc;
10801 }
10802 }
10803 }
10804 }
10805 catch (HRESULT aRC) {rc = aRC;}
10806
10807 if (mData->mMachineState == MachineState_SettingUp)
10808 i_setMachineState(oldState);
10809
10810 /* unlock all hard disks we locked when there is no VM */
10811 if (!aOnline)
10812 {
10813 ErrorInfoKeeper eik;
10814
10815 HRESULT rc1 = lockedMediaMap->Clear();
10816 AssertComRC(rc1);
10817 }
10818
10819 return rc;
10820}
10821
10822
10823/**
10824 * Looks through the given list of media attachments for one with the given parameters
10825 * and returns it, or NULL if not found. The list is a parameter so that backup lists
10826 * can be searched as well if needed.
10827 *
10828 * @param list
10829 * @param aControllerName
10830 * @param aControllerPort
10831 * @param aDevice
10832 * @return
10833 */
10834MediumAttachment* Machine::i_findAttachment(const MediaData::AttachmentList &ll,
10835 IN_BSTR aControllerName,
10836 LONG aControllerPort,
10837 LONG aDevice)
10838{
10839 for (MediaData::AttachmentList::const_iterator it = ll.begin(); it != ll.end(); ++it)
10840 {
10841 MediumAttachment *pAttach = *it;
10842 if (pAttach->i_matches(aControllerName, aControllerPort, aDevice))
10843 return pAttach;
10844 }
10845
10846 return NULL;
10847}
10848
10849/**
10850 * Looks through the given list of media attachments for one with the given parameters
10851 * and returns it, or NULL if not found. The list is a parameter so that backup lists
10852 * can be searched as well if needed.
10853 *
10854 * @param list
10855 * @param aControllerName
10856 * @param aControllerPort
10857 * @param aDevice
10858 * @return
10859 */
10860MediumAttachment* Machine::i_findAttachment(const MediaData::AttachmentList &ll,
10861 ComObjPtr<Medium> pMedium)
10862{
10863 for (MediaData::AttachmentList::const_iterator it = ll.begin(); it != ll.end(); ++it)
10864 {
10865 MediumAttachment *pAttach = *it;
10866 ComObjPtr<Medium> pMediumThis = pAttach->i_getMedium();
10867 if (pMediumThis == pMedium)
10868 return pAttach;
10869 }
10870
10871 return NULL;
10872}
10873
10874/**
10875 * Looks through the given list of media attachments for one with the given parameters
10876 * and returns it, or NULL if not found. The list is a parameter so that backup lists
10877 * can be searched as well if needed.
10878 *
10879 * @param list
10880 * @param aControllerName
10881 * @param aControllerPort
10882 * @param aDevice
10883 * @return
10884 */
10885MediumAttachment* Machine::i_findAttachment(const MediaData::AttachmentList &ll,
10886 Guid &id)
10887{
10888 for (MediaData::AttachmentList::const_iterator it = ll.begin(); it != ll.end(); ++it)
10889 {
10890 MediumAttachment *pAttach = *it;
10891 ComObjPtr<Medium> pMediumThis = pAttach->i_getMedium();
10892 if (pMediumThis->i_getId() == id)
10893 return pAttach;
10894 }
10895
10896 return NULL;
10897}
10898
10899/**
10900 * Main implementation for Machine::DetachDevice. This also gets called
10901 * from Machine::prepareUnregister() so it has been taken out for simplicity.
10902 *
10903 * @param pAttach Medium attachment to detach.
10904 * @param writeLock Machine write lock which the caller must have locked once. This may be released temporarily in here.
10905 * @param pSnapshot If NULL, then the detachment is for the current machine. Otherwise this is for a
10906 * SnapshotMachine, and this must be its snapshot.
10907 * @return
10908 */
10909HRESULT Machine::i_detachDevice(MediumAttachment *pAttach,
10910 AutoWriteLock &writeLock,
10911 Snapshot *pSnapshot)
10912{
10913 ComObjPtr<Medium> oldmedium = pAttach->i_getMedium();
10914 DeviceType_T mediumType = pAttach->i_getType();
10915
10916 LogFlowThisFunc(("Entering, medium of attachment is %s\n", oldmedium ? oldmedium->i_getLocationFull().c_str() : "NULL"));
10917
10918 if (pAttach->i_isImplicit())
10919 {
10920 /* attempt to implicitly delete the implicitly created diff */
10921
10922 /// @todo move the implicit flag from MediumAttachment to Medium
10923 /// and forbid any hard disk operation when it is implicit. Or maybe
10924 /// a special media state for it to make it even more simple.
10925
10926 Assert(mMediaData.isBackedUp());
10927
10928 /* will release the lock before the potentially lengthy operation, so
10929 * protect with the special state */
10930 MachineState_T oldState = mData->mMachineState;
10931 i_setMachineState(MachineState_SettingUp);
10932
10933 writeLock.release();
10934
10935 HRESULT rc = oldmedium->i_deleteStorage(NULL /*aProgress*/,
10936 true /*aWait*/);
10937
10938 writeLock.acquire();
10939
10940 i_setMachineState(oldState);
10941
10942 if (FAILED(rc)) return rc;
10943 }
10944
10945 i_setModified(IsModified_Storage);
10946 mMediaData.backup();
10947 mMediaData->mAttachments.remove(pAttach);
10948
10949 if (!oldmedium.isNull())
10950 {
10951 // if this is from a snapshot, do not defer detachment to commitMedia()
10952 if (pSnapshot)
10953 oldmedium->i_removeBackReference(mData->mUuid, pSnapshot->i_getId());
10954 // else if non-hard disk media, do not defer detachment to commitMedia() either
10955 else if (mediumType != DeviceType_HardDisk)
10956 oldmedium->i_removeBackReference(mData->mUuid);
10957 }
10958
10959 return S_OK;
10960}
10961
10962/**
10963 * Goes thru all media of the given list and
10964 *
10965 * 1) calls i_detachDevice() on each of them for this machine and
10966 * 2) adds all Medium objects found in the process to the given list,
10967 * depending on cleanupMode.
10968 *
10969 * If cleanupMode is CleanupMode_DetachAllReturnHardDisksOnly, this only
10970 * adds hard disks to the list. If it is CleanupMode_Full, this adds all
10971 * media to the list.
10972 *
10973 * This gets called from Machine::Unregister, both for the actual Machine and
10974 * the SnapshotMachine objects that might be found in the snapshots.
10975 *
10976 * Requires caller and locking. The machine lock must be passed in because it
10977 * will be passed on to i_detachDevice which needs it for temporary unlocking.
10978 *
10979 * @param writeLock Machine lock from top-level caller; this gets passed to i_detachDevice.
10980 * @param pSnapshot Must be NULL when called for a "real" Machine or a snapshot object if called for a SnapshotMachine.
10981 * @param cleanupMode If DetachAllReturnHardDisksOnly, only hard disk media get added to llMedia; if
10982 * Full, then all media get added;
10983 * otherwise no media get added.
10984 * @param llMedia Caller's list to receive Medium objects which got detached so caller can close() them, depending on cleanupMode.
10985 * @return
10986 */
10987HRESULT Machine::i_detachAllMedia(AutoWriteLock &writeLock,
10988 Snapshot *pSnapshot,
10989 CleanupMode_T cleanupMode,
10990 MediaList &llMedia)
10991{
10992 Assert(isWriteLockOnCurrentThread());
10993
10994 HRESULT rc;
10995
10996 // make a temporary list because i_detachDevice invalidates iterators into
10997 // mMediaData->mAttachments
10998 MediaData::AttachmentList llAttachments2 = mMediaData->mAttachments;
10999
11000 for (MediaData::AttachmentList::iterator it = llAttachments2.begin(); it != llAttachments2.end(); ++it)
11001 {
11002 ComObjPtr<MediumAttachment> &pAttach = *it;
11003 ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
11004
11005 if (!pMedium.isNull())
11006 {
11007 AutoCaller mac(pMedium);
11008 if (FAILED(mac.rc())) return mac.rc();
11009 AutoReadLock lock(pMedium COMMA_LOCKVAL_SRC_POS);
11010 DeviceType_T devType = pMedium->i_getDeviceType();
11011 if ( ( cleanupMode == CleanupMode_DetachAllReturnHardDisksOnly
11012 && devType == DeviceType_HardDisk)
11013 || (cleanupMode == CleanupMode_Full)
11014 )
11015 {
11016 llMedia.push_back(pMedium);
11017 ComObjPtr<Medium> pParent = pMedium->i_getParent();
11018 /*
11019 * Search for medias which are not attached to any machine, but
11020 * in the chain to an attached disk. Mediums are only consided
11021 * if they are:
11022 * - have only one child
11023 * - no references to any machines
11024 * - are of normal medium type
11025 */
11026 while (!pParent.isNull())
11027 {
11028 AutoCaller mac1(pParent);
11029 if (FAILED(mac1.rc())) return mac1.rc();
11030 AutoReadLock lock1(pParent COMMA_LOCKVAL_SRC_POS);
11031 if (pParent->i_getChildren().size() == 1)
11032 {
11033 if ( pParent->i_getMachineBackRefCount() == 0
11034 && pParent->i_getType() == MediumType_Normal
11035 && find(llMedia.begin(), llMedia.end(), pParent) == llMedia.end())
11036 llMedia.push_back(pParent);
11037 }
11038 else
11039 break;
11040 pParent = pParent->i_getParent();
11041 }
11042 }
11043 }
11044
11045 // real machine: then we need to use the proper method
11046 rc = i_detachDevice(pAttach, writeLock, pSnapshot);
11047
11048 if (FAILED(rc))
11049 return rc;
11050 }
11051
11052 return S_OK;
11053}
11054
11055/**
11056 * Perform deferred hard disk detachments.
11057 *
11058 * Does nothing if the hard disk attachment data (mMediaData) is not changed (not
11059 * backed up).
11060 *
11061 * If @a aOnline is @c true then this method will also unlock the old hard disks
11062 * for which the new implicit diffs were created and will lock these new diffs for
11063 * writing.
11064 *
11065 * @param aOnline Whether the VM was online prior to this operation.
11066 *
11067 * @note Locks this object for writing!
11068 */
11069void Machine::i_commitMedia(bool aOnline /*= false*/)
11070{
11071 AutoCaller autoCaller(this);
11072 AssertComRCReturnVoid(autoCaller.rc());
11073
11074 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11075
11076 LogFlowThisFunc(("Entering, aOnline=%d\n", aOnline));
11077
11078 HRESULT rc = S_OK;
11079
11080 /* no attach/detach operations -- nothing to do */
11081 if (!mMediaData.isBackedUp())
11082 return;
11083
11084 MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
11085 bool fMediaNeedsLocking = false;
11086
11087 /* enumerate new attachments */
11088 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
11089 it != mMediaData->mAttachments.end();
11090 ++it)
11091 {
11092 MediumAttachment *pAttach = *it;
11093
11094 pAttach->i_commit();
11095
11096 Medium* pMedium = pAttach->i_getMedium();
11097 bool fImplicit = pAttach->i_isImplicit();
11098
11099 LogFlowThisFunc(("Examining current medium '%s' (implicit: %d)\n",
11100 (pMedium) ? pMedium->i_getName().c_str() : "NULL",
11101 fImplicit));
11102
11103 /** @todo convert all this Machine-based voodoo to MediumAttachment
11104 * based commit logic. */
11105 if (fImplicit)
11106 {
11107 /* convert implicit attachment to normal */
11108 pAttach->i_setImplicit(false);
11109
11110 if ( aOnline
11111 && pMedium
11112 && pAttach->i_getType() == DeviceType_HardDisk
11113 )
11114 {
11115 ComObjPtr<Medium> parent = pMedium->i_getParent();
11116 AutoWriteLock parentLock(parent COMMA_LOCKVAL_SRC_POS);
11117
11118 /* update the appropriate lock list */
11119 MediumLockList *pMediumLockList;
11120 rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
11121 AssertComRC(rc);
11122 if (pMediumLockList)
11123 {
11124 /* unlock if there's a need to change the locking */
11125 if (!fMediaNeedsLocking)
11126 {
11127 rc = mData->mSession.mLockedMedia.Unlock();
11128 AssertComRC(rc);
11129 fMediaNeedsLocking = true;
11130 }
11131 rc = pMediumLockList->Update(parent, false);
11132 AssertComRC(rc);
11133 rc = pMediumLockList->Append(pMedium, true);
11134 AssertComRC(rc);
11135 }
11136 }
11137
11138 continue;
11139 }
11140
11141 if (pMedium)
11142 {
11143 /* was this medium attached before? */
11144 for (MediaData::AttachmentList::iterator oldIt = oldAtts.begin(); oldIt != oldAtts.end(); ++oldIt)
11145 {
11146 MediumAttachment *pOldAttach = *oldIt;
11147 if (pOldAttach->i_getMedium() == pMedium)
11148 {
11149 LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->i_getName().c_str()));
11150
11151 /* yes: remove from old to avoid de-association */
11152 oldAtts.erase(oldIt);
11153 break;
11154 }
11155 }
11156 }
11157 }
11158
11159 /* enumerate remaining old attachments and de-associate from the
11160 * current machine state */
11161 for (MediaData::AttachmentList::const_iterator it = oldAtts.begin(); it != oldAtts.end(); ++it)
11162 {
11163 MediumAttachment *pAttach = *it;
11164 Medium* pMedium = pAttach->i_getMedium();
11165
11166 /* Detach only hard disks, since DVD/floppy media is detached
11167 * instantly in MountMedium. */
11168 if (pAttach->i_getType() == DeviceType_HardDisk && pMedium)
11169 {
11170 LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->i_getName().c_str()));
11171
11172 /* now de-associate from the current machine state */
11173 rc = pMedium->i_removeBackReference(mData->mUuid);
11174 AssertComRC(rc);
11175
11176 if (aOnline)
11177 {
11178 /* unlock since medium is not used anymore */
11179 MediumLockList *pMediumLockList;
11180 rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
11181 if (RT_UNLIKELY(rc == VBOX_E_INVALID_OBJECT_STATE))
11182 {
11183 /* this happens for online snapshots, there the attachment
11184 * is changing, but only to a diff image created under
11185 * the old one, so there is no separate lock list */
11186 Assert(!pMediumLockList);
11187 }
11188 else
11189 {
11190 AssertComRC(rc);
11191 if (pMediumLockList)
11192 {
11193 rc = mData->mSession.mLockedMedia.Remove(pAttach);
11194 AssertComRC(rc);
11195 }
11196 }
11197 }
11198 }
11199 }
11200
11201 /* take media locks again so that the locking state is consistent */
11202 if (fMediaNeedsLocking)
11203 {
11204 Assert(aOnline);
11205 rc = mData->mSession.mLockedMedia.Lock();
11206 AssertComRC(rc);
11207 }
11208
11209 /* commit the hard disk changes */
11210 mMediaData.commit();
11211
11212 if (i_isSessionMachine())
11213 {
11214 /*
11215 * Update the parent machine to point to the new owner.
11216 * This is necessary because the stored parent will point to the
11217 * session machine otherwise and cause crashes or errors later
11218 * when the session machine gets invalid.
11219 */
11220 /** @todo Change the MediumAttachment class to behave like any other
11221 * class in this regard by creating peer MediumAttachment
11222 * objects for session machines and share the data with the peer
11223 * machine.
11224 */
11225 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
11226 it != mMediaData->mAttachments.end();
11227 ++it)
11228 (*it)->i_updateParentMachine(mPeer);
11229
11230 /* attach new data to the primary machine and reshare it */
11231 mPeer->mMediaData.attach(mMediaData);
11232 }
11233
11234 return;
11235}
11236
11237/**
11238 * Perform deferred deletion of implicitly created diffs.
11239 *
11240 * Does nothing if the hard disk attachment data (mMediaData) is not changed (not
11241 * backed up).
11242 *
11243 * @note Locks this object for writing!
11244 */
11245void Machine::i_rollbackMedia()
11246{
11247 AutoCaller autoCaller(this);
11248 AssertComRCReturnVoid(autoCaller.rc());
11249
11250 // AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11251 LogFlowThisFunc(("Entering rollbackMedia\n"));
11252
11253 HRESULT rc = S_OK;
11254
11255 /* no attach/detach operations -- nothing to do */
11256 if (!mMediaData.isBackedUp())
11257 return;
11258
11259 /* enumerate new attachments */
11260 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
11261 it != mMediaData->mAttachments.end();
11262 ++it)
11263 {
11264 MediumAttachment *pAttach = *it;
11265 /* Fix up the backrefs for DVD/floppy media. */
11266 if (pAttach->i_getType() != DeviceType_HardDisk)
11267 {
11268 Medium* pMedium = pAttach->i_getMedium();
11269 if (pMedium)
11270 {
11271 rc = pMedium->i_removeBackReference(mData->mUuid);
11272 AssertComRC(rc);
11273 }
11274 }
11275
11276 (*it)->i_rollback();
11277
11278 pAttach = *it;
11279 /* Fix up the backrefs for DVD/floppy media. */
11280 if (pAttach->i_getType() != DeviceType_HardDisk)
11281 {
11282 Medium* pMedium = pAttach->i_getMedium();
11283 if (pMedium)
11284 {
11285 rc = pMedium->i_addBackReference(mData->mUuid);
11286 AssertComRC(rc);
11287 }
11288 }
11289 }
11290
11291 /** @todo convert all this Machine-based voodoo to MediumAttachment
11292 * based rollback logic. */
11293 i_deleteImplicitDiffs(Global::IsOnline(mData->mMachineState));
11294
11295 return;
11296}
11297
11298/**
11299 * Returns true if the settings file is located in the directory named exactly
11300 * as the machine; this means, among other things, that the machine directory
11301 * should be auto-renamed.
11302 *
11303 * @param aSettingsDir if not NULL, the full machine settings file directory
11304 * name will be assigned there.
11305 *
11306 * @note Doesn't lock anything.
11307 * @note Not thread safe (must be called from this object's lock).
11308 */
11309bool Machine::i_isInOwnDir(Utf8Str *aSettingsDir /* = NULL */) const
11310{
11311 Utf8Str strMachineDirName(mData->m_strConfigFileFull); // path/to/machinesfolder/vmname/vmname.vbox
11312 strMachineDirName.stripFilename(); // path/to/machinesfolder/vmname
11313 if (aSettingsDir)
11314 *aSettingsDir = strMachineDirName;
11315 strMachineDirName.stripPath(); // vmname
11316 Utf8Str strConfigFileOnly(mData->m_strConfigFileFull); // path/to/machinesfolder/vmname/vmname.vbox
11317 strConfigFileOnly.stripPath() // vmname.vbox
11318 .stripSuffix(); // vmname
11319 /** @todo hack, make somehow use of ComposeMachineFilename */
11320 if (mUserData->s.fDirectoryIncludesUUID)
11321 strConfigFileOnly += Utf8StrFmt(" (%RTuuid)", mData->mUuid.raw());
11322
11323 AssertReturn(!strMachineDirName.isEmpty(), false);
11324 AssertReturn(!strConfigFileOnly.isEmpty(), false);
11325
11326 return strMachineDirName == strConfigFileOnly;
11327}
11328
11329/**
11330 * Discards all changes to machine settings.
11331 *
11332 * @param aNotify Whether to notify the direct session about changes or not.
11333 *
11334 * @note Locks objects for writing!
11335 */
11336void Machine::i_rollback(bool aNotify)
11337{
11338 AutoCaller autoCaller(this);
11339 AssertComRCReturn(autoCaller.rc(), (void)0);
11340
11341 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11342
11343 if (!mStorageControllers.isNull())
11344 {
11345 if (mStorageControllers.isBackedUp())
11346 {
11347 /* unitialize all new devices (absent in the backed up list). */
11348 StorageControllerList::const_iterator it = mStorageControllers->begin();
11349 StorageControllerList *backedList = mStorageControllers.backedUpData();
11350 while (it != mStorageControllers->end())
11351 {
11352 if ( std::find(backedList->begin(), backedList->end(), *it)
11353 == backedList->end()
11354 )
11355 {
11356 (*it)->uninit();
11357 }
11358 ++it;
11359 }
11360
11361 /* restore the list */
11362 mStorageControllers.rollback();
11363 }
11364
11365 /* rollback any changes to devices after restoring the list */
11366 if (mData->flModifications & IsModified_Storage)
11367 {
11368 StorageControllerList::const_iterator it = mStorageControllers->begin();
11369 while (it != mStorageControllers->end())
11370 {
11371 (*it)->i_rollback();
11372 ++it;
11373 }
11374 }
11375 }
11376
11377 if (!mUSBControllers.isNull())
11378 {
11379 if (mUSBControllers.isBackedUp())
11380 {
11381 /* unitialize all new devices (absent in the backed up list). */
11382 USBControllerList::const_iterator it = mUSBControllers->begin();
11383 USBControllerList *backedList = mUSBControllers.backedUpData();
11384 while (it != mUSBControllers->end())
11385 {
11386 if ( std::find(backedList->begin(), backedList->end(), *it)
11387 == backedList->end()
11388 )
11389 {
11390 (*it)->uninit();
11391 }
11392 ++it;
11393 }
11394
11395 /* restore the list */
11396 mUSBControllers.rollback();
11397 }
11398
11399 /* rollback any changes to devices after restoring the list */
11400 if (mData->flModifications & IsModified_USB)
11401 {
11402 USBControllerList::const_iterator it = mUSBControllers->begin();
11403 while (it != mUSBControllers->end())
11404 {
11405 (*it)->i_rollback();
11406 ++it;
11407 }
11408 }
11409 }
11410
11411 mUserData.rollback();
11412
11413 mHWData.rollback();
11414
11415 if (mData->flModifications & IsModified_Storage)
11416 i_rollbackMedia();
11417
11418 if (mBIOSSettings)
11419 mBIOSSettings->i_rollback();
11420
11421 if (mVRDEServer && (mData->flModifications & IsModified_VRDEServer))
11422 mVRDEServer->i_rollback();
11423
11424 if (mAudioAdapter)
11425 mAudioAdapter->i_rollback();
11426
11427 if (mUSBDeviceFilters && (mData->flModifications & IsModified_USB))
11428 mUSBDeviceFilters->i_rollback();
11429
11430 if (mBandwidthControl && (mData->flModifications & IsModified_BandwidthControl))
11431 mBandwidthControl->i_rollback();
11432
11433 if (!mHWData.isNull())
11434 mNetworkAdapters.resize(Global::getMaxNetworkAdapters(mHWData->mChipsetType));
11435 NetworkAdapterVector networkAdapters(mNetworkAdapters.size());
11436 ComPtr<ISerialPort> serialPorts[RT_ELEMENTS(mSerialPorts)];
11437 ComPtr<IParallelPort> parallelPorts[RT_ELEMENTS(mParallelPorts)];
11438
11439 if (mData->flModifications & IsModified_NetworkAdapters)
11440 for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
11441 if ( mNetworkAdapters[slot]
11442 && mNetworkAdapters[slot]->i_isModified())
11443 {
11444 mNetworkAdapters[slot]->i_rollback();
11445 networkAdapters[slot] = mNetworkAdapters[slot];
11446 }
11447
11448 if (mData->flModifications & IsModified_SerialPorts)
11449 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
11450 if ( mSerialPorts[slot]
11451 && mSerialPorts[slot]->i_isModified())
11452 {
11453 mSerialPorts[slot]->i_rollback();
11454 serialPorts[slot] = mSerialPorts[slot];
11455 }
11456
11457 if (mData->flModifications & IsModified_ParallelPorts)
11458 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
11459 if ( mParallelPorts[slot]
11460 && mParallelPorts[slot]->i_isModified())
11461 {
11462 mParallelPorts[slot]->i_rollback();
11463 parallelPorts[slot] = mParallelPorts[slot];
11464 }
11465
11466 if (aNotify)
11467 {
11468 /* inform the direct session about changes */
11469
11470 ComObjPtr<Machine> that = this;
11471 uint32_t flModifications = mData->flModifications;
11472 alock.release();
11473
11474 if (flModifications & IsModified_SharedFolders)
11475 that->i_onSharedFolderChange();
11476
11477 if (flModifications & IsModified_VRDEServer)
11478 that->i_onVRDEServerChange(/* aRestart */ TRUE);
11479 if (flModifications & IsModified_USB)
11480 that->i_onUSBControllerChange();
11481
11482 for (ULONG slot = 0; slot < networkAdapters.size(); ++slot)
11483 if (networkAdapters[slot])
11484 that->i_onNetworkAdapterChange(networkAdapters[slot], FALSE);
11485 for (ULONG slot = 0; slot < RT_ELEMENTS(serialPorts); ++slot)
11486 if (serialPorts[slot])
11487 that->i_onSerialPortChange(serialPorts[slot]);
11488 for (ULONG slot = 0; slot < RT_ELEMENTS(parallelPorts); ++slot)
11489 if (parallelPorts[slot])
11490 that->i_onParallelPortChange(parallelPorts[slot]);
11491
11492 if (flModifications & IsModified_Storage)
11493 that->i_onStorageControllerChange();
11494
11495#if 0
11496 if (flModifications & IsModified_BandwidthControl)
11497 that->onBandwidthControlChange();
11498#endif
11499 }
11500}
11501
11502/**
11503 * Commits all the changes to machine settings.
11504 *
11505 * Note that this operation is supposed to never fail.
11506 *
11507 * @note Locks this object and children for writing.
11508 */
11509void Machine::i_commit()
11510{
11511 AutoCaller autoCaller(this);
11512 AssertComRCReturnVoid(autoCaller.rc());
11513
11514 AutoCaller peerCaller(mPeer);
11515 AssertComRCReturnVoid(peerCaller.rc());
11516
11517 AutoMultiWriteLock2 alock(mPeer, this COMMA_LOCKVAL_SRC_POS);
11518
11519 /*
11520 * use safe commit to ensure Snapshot machines (that share mUserData)
11521 * will still refer to a valid memory location
11522 */
11523 mUserData.commitCopy();
11524
11525 mHWData.commit();
11526
11527 if (mMediaData.isBackedUp())
11528 i_commitMedia(Global::IsOnline(mData->mMachineState));
11529
11530 mBIOSSettings->i_commit();
11531 mVRDEServer->i_commit();
11532 mAudioAdapter->i_commit();
11533 mUSBDeviceFilters->i_commit();
11534 mBandwidthControl->i_commit();
11535
11536 /* Since mNetworkAdapters is a list which might have been changed (resized)
11537 * without using the Backupable<> template we need to handle the copying
11538 * of the list entries manually, including the creation of peers for the
11539 * new objects. */
11540 bool commitNetworkAdapters = false;
11541 size_t newSize = Global::getMaxNetworkAdapters(mHWData->mChipsetType);
11542 if (mPeer)
11543 {
11544 /* commit everything, even the ones which will go away */
11545 for (size_t slot = 0; slot < mNetworkAdapters.size(); slot++)
11546 mNetworkAdapters[slot]->i_commit();
11547 /* copy over the new entries, creating a peer and uninit the original */
11548 mPeer->mNetworkAdapters.resize(RT_MAX(newSize, mPeer->mNetworkAdapters.size()));
11549 for (size_t slot = 0; slot < newSize; slot++)
11550 {
11551 /* look if this adapter has a peer device */
11552 ComObjPtr<NetworkAdapter> peer = mNetworkAdapters[slot]->i_getPeer();
11553 if (!peer)
11554 {
11555 /* no peer means the adapter is a newly created one;
11556 * create a peer owning data this data share it with */
11557 peer.createObject();
11558 peer->init(mPeer, mNetworkAdapters[slot], true /* aReshare */);
11559 }
11560 mPeer->mNetworkAdapters[slot] = peer;
11561 }
11562 /* uninit any no longer needed network adapters */
11563 for (size_t slot = newSize; slot < mNetworkAdapters.size(); ++slot)
11564 mNetworkAdapters[slot]->uninit();
11565 for (size_t slot = newSize; slot < mPeer->mNetworkAdapters.size(); ++slot)
11566 {
11567 if (mPeer->mNetworkAdapters[slot])
11568 mPeer->mNetworkAdapters[slot]->uninit();
11569 }
11570 /* Keep the original network adapter count until this point, so that
11571 * discarding a chipset type change will not lose settings. */
11572 mNetworkAdapters.resize(newSize);
11573 mPeer->mNetworkAdapters.resize(newSize);
11574 }
11575 else
11576 {
11577 /* we have no peer (our parent is the newly created machine);
11578 * just commit changes to the network adapters */
11579 commitNetworkAdapters = true;
11580 }
11581 if (commitNetworkAdapters)
11582 for (size_t slot = 0; slot < mNetworkAdapters.size(); ++slot)
11583 mNetworkAdapters[slot]->i_commit();
11584
11585 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
11586 mSerialPorts[slot]->i_commit();
11587 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
11588 mParallelPorts[slot]->i_commit();
11589
11590 bool commitStorageControllers = false;
11591
11592 if (mStorageControllers.isBackedUp())
11593 {
11594 mStorageControllers.commit();
11595
11596 if (mPeer)
11597 {
11598 /* Commit all changes to new controllers (this will reshare data with
11599 * peers for those who have peers) */
11600 StorageControllerList *newList = new StorageControllerList();
11601 StorageControllerList::const_iterator it = mStorageControllers->begin();
11602 while (it != mStorageControllers->end())
11603 {
11604 (*it)->i_commit();
11605
11606 /* look if this controller has a peer device */
11607 ComObjPtr<StorageController> peer = (*it)->i_getPeer();
11608 if (!peer)
11609 {
11610 /* no peer means the device is a newly created one;
11611 * create a peer owning data this device share it with */
11612 peer.createObject();
11613 peer->init(mPeer, *it, true /* aReshare */);
11614 }
11615 else
11616 {
11617 /* remove peer from the old list */
11618 mPeer->mStorageControllers->remove(peer);
11619 }
11620 /* and add it to the new list */
11621 newList->push_back(peer);
11622
11623 ++it;
11624 }
11625
11626 /* uninit old peer's controllers that are left */
11627 it = mPeer->mStorageControllers->begin();
11628 while (it != mPeer->mStorageControllers->end())
11629 {
11630 (*it)->uninit();
11631 ++it;
11632 }
11633
11634 /* attach new list of controllers to our peer */
11635 mPeer->mStorageControllers.attach(newList);
11636 }
11637 else
11638 {
11639 /* we have no peer (our parent is the newly created machine);
11640 * just commit changes to devices */
11641 commitStorageControllers = true;
11642 }
11643 }
11644 else
11645 {
11646 /* the list of controllers itself is not changed,
11647 * just commit changes to controllers themselves */
11648 commitStorageControllers = true;
11649 }
11650
11651 if (commitStorageControllers)
11652 {
11653 StorageControllerList::const_iterator it = mStorageControllers->begin();
11654 while (it != mStorageControllers->end())
11655 {
11656 (*it)->i_commit();
11657 ++it;
11658 }
11659 }
11660
11661 bool commitUSBControllers = false;
11662
11663 if (mUSBControllers.isBackedUp())
11664 {
11665 mUSBControllers.commit();
11666
11667 if (mPeer)
11668 {
11669 /* Commit all changes to new controllers (this will reshare data with
11670 * peers for those who have peers) */
11671 USBControllerList *newList = new USBControllerList();
11672 USBControllerList::const_iterator it = mUSBControllers->begin();
11673 while (it != mUSBControllers->end())
11674 {
11675 (*it)->i_commit();
11676
11677 /* look if this controller has a peer device */
11678 ComObjPtr<USBController> peer = (*it)->i_getPeer();
11679 if (!peer)
11680 {
11681 /* no peer means the device is a newly created one;
11682 * create a peer owning data this device share it with */
11683 peer.createObject();
11684 peer->init(mPeer, *it, true /* aReshare */);
11685 }
11686 else
11687 {
11688 /* remove peer from the old list */
11689 mPeer->mUSBControllers->remove(peer);
11690 }
11691 /* and add it to the new list */
11692 newList->push_back(peer);
11693
11694 ++it;
11695 }
11696
11697 /* uninit old peer's controllers that are left */
11698 it = mPeer->mUSBControllers->begin();
11699 while (it != mPeer->mUSBControllers->end())
11700 {
11701 (*it)->uninit();
11702 ++it;
11703 }
11704
11705 /* attach new list of controllers to our peer */
11706 mPeer->mUSBControllers.attach(newList);
11707 }
11708 else
11709 {
11710 /* we have no peer (our parent is the newly created machine);
11711 * just commit changes to devices */
11712 commitUSBControllers = true;
11713 }
11714 }
11715 else
11716 {
11717 /* the list of controllers itself is not changed,
11718 * just commit changes to controllers themselves */
11719 commitUSBControllers = true;
11720 }
11721
11722 if (commitUSBControllers)
11723 {
11724 USBControllerList::const_iterator it = mUSBControllers->begin();
11725 while (it != mUSBControllers->end())
11726 {
11727 (*it)->i_commit();
11728 ++it;
11729 }
11730 }
11731
11732 if (i_isSessionMachine())
11733 {
11734 /* attach new data to the primary machine and reshare it */
11735 mPeer->mUserData.attach(mUserData);
11736 mPeer->mHWData.attach(mHWData);
11737 /* mMediaData is reshared by fixupMedia */
11738 // mPeer->mMediaData.attach(mMediaData);
11739 Assert(mPeer->mMediaData.data() == mMediaData.data());
11740 }
11741}
11742
11743/**
11744 * Copies all the hardware data from the given machine.
11745 *
11746 * Currently, only called when the VM is being restored from a snapshot. In
11747 * particular, this implies that the VM is not running during this method's
11748 * call.
11749 *
11750 * @note This method must be called from under this object's lock.
11751 *
11752 * @note This method doesn't call #commit(), so all data remains backed up and
11753 * unsaved.
11754 */
11755void Machine::i_copyFrom(Machine *aThat)
11756{
11757 AssertReturnVoid(!i_isSnapshotMachine());
11758 AssertReturnVoid(aThat->i_isSnapshotMachine());
11759
11760 AssertReturnVoid(!Global::IsOnline(mData->mMachineState));
11761
11762 mHWData.assignCopy(aThat->mHWData);
11763
11764 // create copies of all shared folders (mHWData after attaching a copy
11765 // contains just references to original objects)
11766 for (HWData::SharedFolderList::iterator it = mHWData->mSharedFolders.begin();
11767 it != mHWData->mSharedFolders.end();
11768 ++it)
11769 {
11770 ComObjPtr<SharedFolder> folder;
11771 folder.createObject();
11772 HRESULT rc = folder->initCopy(i_getMachine(), *it);
11773 AssertComRC(rc);
11774 *it = folder;
11775 }
11776
11777 mBIOSSettings->i_copyFrom(aThat->mBIOSSettings);
11778 mVRDEServer->i_copyFrom(aThat->mVRDEServer);
11779 mAudioAdapter->i_copyFrom(aThat->mAudioAdapter);
11780 mUSBDeviceFilters->i_copyFrom(aThat->mUSBDeviceFilters);
11781 mBandwidthControl->i_copyFrom(aThat->mBandwidthControl);
11782
11783 /* create private copies of all controllers */
11784 mStorageControllers.backup();
11785 mStorageControllers->clear();
11786 for (StorageControllerList::iterator it = aThat->mStorageControllers->begin();
11787 it != aThat->mStorageControllers->end();
11788 ++it)
11789 {
11790 ComObjPtr<StorageController> ctrl;
11791 ctrl.createObject();
11792 ctrl->initCopy(this, *it);
11793 mStorageControllers->push_back(ctrl);
11794 }
11795
11796 /* create private copies of all USB controllers */
11797 mUSBControllers.backup();
11798 mUSBControllers->clear();
11799 for (USBControllerList::iterator it = aThat->mUSBControllers->begin();
11800 it != aThat->mUSBControllers->end();
11801 ++it)
11802 {
11803 ComObjPtr<USBController> ctrl;
11804 ctrl.createObject();
11805 ctrl->initCopy(this, *it);
11806 mUSBControllers->push_back(ctrl);
11807 }
11808
11809 mNetworkAdapters.resize(aThat->mNetworkAdapters.size());
11810 for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
11811 mNetworkAdapters[slot]->i_copyFrom(aThat->mNetworkAdapters[slot]);
11812 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
11813 mSerialPorts[slot]->i_copyFrom(aThat->mSerialPorts[slot]);
11814 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
11815 mParallelPorts[slot]->i_copyFrom(aThat->mParallelPorts[slot]);
11816}
11817
11818/**
11819 * Returns whether the given storage controller is hotplug capable.
11820 *
11821 * @returns true if the controller supports hotplugging
11822 * false otherwise.
11823 * @param enmCtrlType The controller type to check for.
11824 */
11825bool Machine::i_isControllerHotplugCapable(StorageControllerType_T enmCtrlType)
11826{
11827 ComPtr<ISystemProperties> systemProperties;
11828 HRESULT rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
11829 if (FAILED(rc))
11830 return false;
11831
11832 BOOL aHotplugCapable = FALSE;
11833 systemProperties->GetStorageControllerHotplugCapable(enmCtrlType, &aHotplugCapable);
11834
11835 return RT_BOOL(aHotplugCapable);
11836}
11837
11838#ifdef VBOX_WITH_RESOURCE_USAGE_API
11839
11840void Machine::i_getDiskList(MediaList &list)
11841{
11842 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
11843 it != mMediaData->mAttachments.end();
11844 ++it)
11845 {
11846 MediumAttachment* pAttach = *it;
11847 /* just in case */
11848 AssertStmt(pAttach, continue);
11849
11850 AutoCaller localAutoCallerA(pAttach);
11851 if (FAILED(localAutoCallerA.rc())) continue;
11852
11853 AutoReadLock local_alockA(pAttach COMMA_LOCKVAL_SRC_POS);
11854
11855 if (pAttach->i_getType() == DeviceType_HardDisk)
11856 list.push_back(pAttach->i_getMedium());
11857 }
11858}
11859
11860void Machine::i_registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid)
11861{
11862 AssertReturnVoid(isWriteLockOnCurrentThread());
11863 AssertPtrReturnVoid(aCollector);
11864
11865 pm::CollectorHAL *hal = aCollector->getHAL();
11866 /* Create sub metrics */
11867 pm::SubMetric *cpuLoadUser = new pm::SubMetric("CPU/Load/User",
11868 "Percentage of processor time spent in user mode by the VM process.");
11869 pm::SubMetric *cpuLoadKernel = new pm::SubMetric("CPU/Load/Kernel",
11870 "Percentage of processor time spent in kernel mode by the VM process.");
11871 pm::SubMetric *ramUsageUsed = new pm::SubMetric("RAM/Usage/Used",
11872 "Size of resident portion of VM process in memory.");
11873 pm::SubMetric *diskUsageUsed = new pm::SubMetric("Disk/Usage/Used",
11874 "Actual size of all VM disks combined.");
11875 pm::SubMetric *machineNetRx = new pm::SubMetric("Net/Rate/Rx",
11876 "Network receive rate.");
11877 pm::SubMetric *machineNetTx = new pm::SubMetric("Net/Rate/Tx",
11878 "Network transmit rate.");
11879 /* Create and register base metrics */
11880 pm::BaseMetric *cpuLoad = new pm::MachineCpuLoadRaw(hal, aMachine, pid,
11881 cpuLoadUser, cpuLoadKernel);
11882 aCollector->registerBaseMetric(cpuLoad);
11883 pm::BaseMetric *ramUsage = new pm::MachineRamUsage(hal, aMachine, pid,
11884 ramUsageUsed);
11885 aCollector->registerBaseMetric(ramUsage);
11886 MediaList disks;
11887 i_getDiskList(disks);
11888 pm::BaseMetric *diskUsage = new pm::MachineDiskUsage(hal, aMachine, disks,
11889 diskUsageUsed);
11890 aCollector->registerBaseMetric(diskUsage);
11891
11892 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser, 0));
11893 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
11894 new pm::AggregateAvg()));
11895 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
11896 new pm::AggregateMin()));
11897 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
11898 new pm::AggregateMax()));
11899 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel, 0));
11900 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
11901 new pm::AggregateAvg()));
11902 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
11903 new pm::AggregateMin()));
11904 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
11905 new pm::AggregateMax()));
11906
11907 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed, 0));
11908 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
11909 new pm::AggregateAvg()));
11910 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
11911 new pm::AggregateMin()));
11912 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
11913 new pm::AggregateMax()));
11914
11915 aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed, 0));
11916 aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
11917 new pm::AggregateAvg()));
11918 aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
11919 new pm::AggregateMin()));
11920 aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
11921 new pm::AggregateMax()));
11922
11923
11924 /* Guest metrics collector */
11925 mCollectorGuest = new pm::CollectorGuest(aMachine, pid);
11926 aCollector->registerGuest(mCollectorGuest);
11927 LogAleksey(("{%p} " LOG_FN_FMT ": mCollectorGuest=%p\n",
11928 this, __PRETTY_FUNCTION__, mCollectorGuest));
11929
11930 /* Create sub metrics */
11931 pm::SubMetric *guestLoadUser = new pm::SubMetric("Guest/CPU/Load/User",
11932 "Percentage of processor time spent in user mode as seen by the guest.");
11933 pm::SubMetric *guestLoadKernel = new pm::SubMetric("Guest/CPU/Load/Kernel",
11934 "Percentage of processor time spent in kernel mode as seen by the guest.");
11935 pm::SubMetric *guestLoadIdle = new pm::SubMetric("Guest/CPU/Load/Idle",
11936 "Percentage of processor time spent idling as seen by the guest.");
11937
11938 /* The total amount of physical ram is fixed now, but we'll support dynamic guest ram configurations in the future. */
11939 pm::SubMetric *guestMemTotal = new pm::SubMetric("Guest/RAM/Usage/Total", "Total amount of physical guest RAM.");
11940 pm::SubMetric *guestMemFree = new pm::SubMetric("Guest/RAM/Usage/Free", "Free amount of physical guest RAM.");
11941 pm::SubMetric *guestMemBalloon = new pm::SubMetric("Guest/RAM/Usage/Balloon", "Amount of ballooned physical guest RAM.");
11942 pm::SubMetric *guestMemShared = new pm::SubMetric("Guest/RAM/Usage/Shared", "Amount of shared physical guest RAM.");
11943 pm::SubMetric *guestMemCache = new pm::SubMetric(
11944 "Guest/RAM/Usage/Cache", "Total amount of guest (disk) cache memory.");
11945
11946 pm::SubMetric *guestPagedTotal = new pm::SubMetric(
11947 "Guest/Pagefile/Usage/Total", "Total amount of space in the page file.");
11948
11949 /* Create and register base metrics */
11950 pm::BaseMetric *machineNetRate = new pm::MachineNetRate(mCollectorGuest, aMachine,
11951 machineNetRx, machineNetTx);
11952 aCollector->registerBaseMetric(machineNetRate);
11953
11954 pm::BaseMetric *guestCpuLoad = new pm::GuestCpuLoad(mCollectorGuest, aMachine,
11955 guestLoadUser, guestLoadKernel, guestLoadIdle);
11956 aCollector->registerBaseMetric(guestCpuLoad);
11957
11958 pm::BaseMetric *guestCpuMem = new pm::GuestRamUsage(mCollectorGuest, aMachine,
11959 guestMemTotal, guestMemFree,
11960 guestMemBalloon, guestMemShared,
11961 guestMemCache, guestPagedTotal);
11962 aCollector->registerBaseMetric(guestCpuMem);
11963
11964 aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, 0));
11965 aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateAvg()));
11966 aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateMin()));
11967 aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateMax()));
11968
11969 aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, 0));
11970 aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateAvg()));
11971 aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateMin()));
11972 aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateMax()));
11973
11974 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, 0));
11975 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateAvg()));
11976 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMin()));
11977 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMax()));
11978
11979 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, 0));
11980 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateAvg()));
11981 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMin()));
11982 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMax()));
11983
11984 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, 0));
11985 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateAvg()));
11986 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMin()));
11987 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMax()));
11988
11989 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, 0));
11990 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateAvg()));
11991 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMin()));
11992 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMax()));
11993
11994 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, 0));
11995 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateAvg()));
11996 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMin()));
11997 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMax()));
11998
11999 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, 0));
12000 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateAvg()));
12001 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMin()));
12002 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMax()));
12003
12004 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, 0));
12005 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateAvg()));
12006 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMin()));
12007 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMax()));
12008
12009 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, 0));
12010 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateAvg()));
12011 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMin()));
12012 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMax()));
12013
12014 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, 0));
12015 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateAvg()));
12016 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMin()));
12017 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMax()));
12018}
12019
12020void Machine::i_unregisterMetrics(PerformanceCollector *aCollector, Machine *aMachine)
12021{
12022 AssertReturnVoid(isWriteLockOnCurrentThread());
12023
12024 if (aCollector)
12025 {
12026 aCollector->unregisterMetricsFor(aMachine);
12027 aCollector->unregisterBaseMetricsFor(aMachine);
12028 }
12029}
12030
12031#endif /* VBOX_WITH_RESOURCE_USAGE_API */
12032
12033
12034////////////////////////////////////////////////////////////////////////////////
12035
12036DEFINE_EMPTY_CTOR_DTOR(SessionMachine)
12037
12038HRESULT SessionMachine::FinalConstruct()
12039{
12040 LogFlowThisFunc(("\n"));
12041
12042 mClientToken = NULL;
12043
12044 return BaseFinalConstruct();
12045}
12046
12047void SessionMachine::FinalRelease()
12048{
12049 LogFlowThisFunc(("\n"));
12050
12051 Assert(!mClientToken);
12052 /* paranoia, should not hang around any more */
12053 if (mClientToken)
12054 {
12055 delete mClientToken;
12056 mClientToken = NULL;
12057 }
12058
12059 uninit(Uninit::Unexpected);
12060
12061 BaseFinalRelease();
12062}
12063
12064/**
12065 * @note Must be called only by Machine::LockMachine() from its own write lock.
12066 */
12067HRESULT SessionMachine::init(Machine *aMachine)
12068{
12069 LogFlowThisFuncEnter();
12070 LogFlowThisFunc(("mName={%s}\n", aMachine->mUserData->s.strName.c_str()));
12071
12072 AssertReturn(aMachine, E_INVALIDARG);
12073
12074 AssertReturn(aMachine->lockHandle()->isWriteLockOnCurrentThread(), E_FAIL);
12075
12076 /* Enclose the state transition NotReady->InInit->Ready */
12077 AutoInitSpan autoInitSpan(this);
12078 AssertReturn(autoInitSpan.isOk(), E_FAIL);
12079
12080 HRESULT rc = S_OK;
12081
12082 /* create the machine client token */
12083 try
12084 {
12085 mClientToken = new ClientToken(aMachine, this);
12086 if (!mClientToken->isReady())
12087 {
12088 delete mClientToken;
12089 mClientToken = NULL;
12090 rc = E_FAIL;
12091 }
12092 }
12093 catch (std::bad_alloc &)
12094 {
12095 rc = E_OUTOFMEMORY;
12096 }
12097 if (FAILED(rc))
12098 return rc;
12099
12100 /* memorize the peer Machine */
12101 unconst(mPeer) = aMachine;
12102 /* share the parent pointer */
12103 unconst(mParent) = aMachine->mParent;
12104
12105 /* take the pointers to data to share */
12106 mData.share(aMachine->mData);
12107 mSSData.share(aMachine->mSSData);
12108
12109 mUserData.share(aMachine->mUserData);
12110 mHWData.share(aMachine->mHWData);
12111 mMediaData.share(aMachine->mMediaData);
12112
12113 mStorageControllers.allocate();
12114 for (StorageControllerList::const_iterator it = aMachine->mStorageControllers->begin();
12115 it != aMachine->mStorageControllers->end();
12116 ++it)
12117 {
12118 ComObjPtr<StorageController> ctl;
12119 ctl.createObject();
12120 ctl->init(this, *it);
12121 mStorageControllers->push_back(ctl);
12122 }
12123
12124 mUSBControllers.allocate();
12125 for (USBControllerList::const_iterator it = aMachine->mUSBControllers->begin();
12126 it != aMachine->mUSBControllers->end();
12127 ++it)
12128 {
12129 ComObjPtr<USBController> ctl;
12130 ctl.createObject();
12131 ctl->init(this, *it);
12132 mUSBControllers->push_back(ctl);
12133 }
12134
12135 unconst(mBIOSSettings).createObject();
12136 mBIOSSettings->init(this, aMachine->mBIOSSettings);
12137 /* create another VRDEServer object that will be mutable */
12138 unconst(mVRDEServer).createObject();
12139 mVRDEServer->init(this, aMachine->mVRDEServer);
12140 /* create another audio adapter object that will be mutable */
12141 unconst(mAudioAdapter).createObject();
12142 mAudioAdapter->init(this, aMachine->mAudioAdapter);
12143 /* create a list of serial ports that will be mutable */
12144 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
12145 {
12146 unconst(mSerialPorts[slot]).createObject();
12147 mSerialPorts[slot]->init(this, aMachine->mSerialPorts[slot]);
12148 }
12149 /* create a list of parallel ports that will be mutable */
12150 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); ++slot)
12151 {
12152 unconst(mParallelPorts[slot]).createObject();
12153 mParallelPorts[slot]->init(this, aMachine->mParallelPorts[slot]);
12154 }
12155
12156 /* create another USB device filters object that will be mutable */
12157 unconst(mUSBDeviceFilters).createObject();
12158 mUSBDeviceFilters->init(this, aMachine->mUSBDeviceFilters);
12159
12160 /* create a list of network adapters that will be mutable */
12161 mNetworkAdapters.resize(aMachine->mNetworkAdapters.size());
12162 for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12163 {
12164 unconst(mNetworkAdapters[slot]).createObject();
12165 mNetworkAdapters[slot]->init(this, aMachine->mNetworkAdapters[slot]);
12166 }
12167
12168 /* create another bandwidth control object that will be mutable */
12169 unconst(mBandwidthControl).createObject();
12170 mBandwidthControl->init(this, aMachine->mBandwidthControl);
12171
12172 /* default is to delete saved state on Saved -> PoweredOff transition */
12173 mRemoveSavedState = true;
12174
12175 /* Confirm a successful initialization when it's the case */
12176 autoInitSpan.setSucceeded();
12177
12178 miNATNetworksStarted = 0;
12179
12180 LogFlowThisFuncLeave();
12181 return rc;
12182}
12183
12184/**
12185 * Uninitializes this session object. If the reason is other than
12186 * Uninit::Unexpected, then this method MUST be called from #checkForDeath()
12187 * or the client watcher code.
12188 *
12189 * @param aReason uninitialization reason
12190 *
12191 * @note Locks mParent + this object for writing.
12192 */
12193void SessionMachine::uninit(Uninit::Reason aReason)
12194{
12195 LogFlowThisFuncEnter();
12196 LogFlowThisFunc(("reason=%d\n", aReason));
12197
12198 /*
12199 * Strongly reference ourselves to prevent this object deletion after
12200 * mData->mSession.mMachine.setNull() below (which can release the last
12201 * reference and call the destructor). Important: this must be done before
12202 * accessing any members (and before AutoUninitSpan that does it as well).
12203 * This self reference will be released as the very last step on return.
12204 */
12205 ComObjPtr<SessionMachine> selfRef = this;
12206
12207 /* Enclose the state transition Ready->InUninit->NotReady */
12208 AutoUninitSpan autoUninitSpan(this);
12209 if (autoUninitSpan.uninitDone())
12210 {
12211 LogFlowThisFunc(("Already uninitialized\n"));
12212 LogFlowThisFuncLeave();
12213 return;
12214 }
12215
12216 if (autoUninitSpan.initFailed())
12217 {
12218 /* We've been called by init() because it's failed. It's not really
12219 * necessary (nor it's safe) to perform the regular uninit sequence
12220 * below, the following is enough.
12221 */
12222 LogFlowThisFunc(("Initialization failed.\n"));
12223 /* destroy the machine client token */
12224 if (mClientToken)
12225 {
12226 delete mClientToken;
12227 mClientToken = NULL;
12228 }
12229 uninitDataAndChildObjects();
12230 mData.free();
12231 unconst(mParent) = NULL;
12232 unconst(mPeer) = NULL;
12233 LogFlowThisFuncLeave();
12234 return;
12235 }
12236
12237 MachineState_T lastState;
12238 {
12239 AutoReadLock tempLock(this COMMA_LOCKVAL_SRC_POS);
12240 lastState = mData->mMachineState;
12241 }
12242 NOREF(lastState);
12243
12244#ifdef VBOX_WITH_USB
12245 // release all captured USB devices, but do this before requesting the locks below
12246 if (aReason == Uninit::Abnormal && Global::IsOnline(lastState))
12247 {
12248 /* Console::captureUSBDevices() is called in the VM process only after
12249 * setting the machine state to Starting or Restoring.
12250 * Console::detachAllUSBDevices() will be called upon successful
12251 * termination. So, we need to release USB devices only if there was
12252 * an abnormal termination of a running VM.
12253 *
12254 * This is identical to SessionMachine::DetachAllUSBDevices except
12255 * for the aAbnormal argument. */
12256 HRESULT rc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
12257 AssertComRC(rc);
12258 NOREF(rc);
12259
12260 USBProxyService *service = mParent->i_host()->i_usbProxyService();
12261 if (service)
12262 service->detachAllDevicesFromVM(this, true /* aDone */, true /* aAbnormal */);
12263 }
12264#endif /* VBOX_WITH_USB */
12265
12266 // we need to lock this object in uninit() because the lock is shared
12267 // with mPeer (as well as data we modify below). mParent lock is needed
12268 // by several calls to it, and USB needs host lock.
12269 AutoMultiWriteLock3 multilock(mParent, mParent->i_host(), this COMMA_LOCKVAL_SRC_POS);
12270
12271#ifdef VBOX_WITH_RESOURCE_USAGE_API
12272 /*
12273 * It is safe to call Machine::i_unregisterMetrics() here because
12274 * PerformanceCollector::samplerCallback no longer accesses guest methods
12275 * holding the lock.
12276 */
12277 i_unregisterMetrics(mParent->i_performanceCollector(), mPeer);
12278 /* The guest must be unregistered after its metrics (@bugref{5949}). */
12279 LogAleksey(("{%p} " LOG_FN_FMT ": mCollectorGuest=%p\n",
12280 this, __PRETTY_FUNCTION__, mCollectorGuest));
12281 if (mCollectorGuest)
12282 {
12283 mParent->i_performanceCollector()->unregisterGuest(mCollectorGuest);
12284 // delete mCollectorGuest; => CollectorGuestManager::destroyUnregistered()
12285 mCollectorGuest = NULL;
12286 }
12287#endif
12288
12289 if (aReason == Uninit::Abnormal)
12290 {
12291 LogWarningThisFunc(("ABNORMAL client termination! (wasBusy=%d)\n",
12292 Global::IsOnlineOrTransient(lastState)));
12293
12294 /* reset the state to Aborted */
12295 if (mData->mMachineState != MachineState_Aborted)
12296 i_setMachineState(MachineState_Aborted);
12297 }
12298
12299 // any machine settings modified?
12300 if (mData->flModifications)
12301 {
12302 LogWarningThisFunc(("Discarding unsaved settings changes!\n"));
12303 i_rollback(false /* aNotify */);
12304 }
12305
12306 Assert( mConsoleTaskData.strStateFilePath.isEmpty()
12307 || !mConsoleTaskData.mSnapshot);
12308 if (!mConsoleTaskData.strStateFilePath.isEmpty())
12309 {
12310 LogWarningThisFunc(("canceling failed save state request!\n"));
12311 endSavingState(E_FAIL, tr("Machine terminated with pending save state!"));
12312 }
12313 else if (!mConsoleTaskData.mSnapshot.isNull())
12314 {
12315 LogWarningThisFunc(("canceling untaken snapshot!\n"));
12316
12317 /* delete all differencing hard disks created (this will also attach
12318 * their parents back by rolling back mMediaData) */
12319 i_rollbackMedia();
12320
12321 // delete the saved state file (it might have been already created)
12322 // AFTER killing the snapshot so that releaseSavedStateFile() won't
12323 // think it's still in use
12324 Utf8Str strStateFile = mConsoleTaskData.mSnapshot->i_getStateFilePath();
12325 mConsoleTaskData.mSnapshot->uninit();
12326 i_releaseSavedStateFile(strStateFile, NULL /* pSnapshotToIgnore */ );
12327 }
12328
12329 mData->mSession.mPID = NIL_RTPROCESS;
12330
12331 if (aReason == Uninit::Unexpected)
12332 {
12333 /* Uninitialization didn't come from #checkForDeath(), so tell the
12334 * client watcher thread to update the set of machines that have open
12335 * sessions. */
12336 mParent->i_updateClientWatcher();
12337 }
12338
12339 /* uninitialize all remote controls */
12340 if (mData->mSession.mRemoteControls.size())
12341 {
12342 LogFlowThisFunc(("Closing remote sessions (%d):\n",
12343 mData->mSession.mRemoteControls.size()));
12344
12345 Data::Session::RemoteControlList::iterator it =
12346 mData->mSession.mRemoteControls.begin();
12347 while (it != mData->mSession.mRemoteControls.end())
12348 {
12349 LogFlowThisFunc((" Calling remoteControl->Uninitialize()...\n"));
12350 HRESULT rc = (*it)->Uninitialize();
12351 LogFlowThisFunc((" remoteControl->Uninitialize() returned %08X\n", rc));
12352 if (FAILED(rc))
12353 LogWarningThisFunc(("Forgot to close the remote session?\n"));
12354 ++it;
12355 }
12356 mData->mSession.mRemoteControls.clear();
12357 }
12358
12359 /* Remove all references to the NAT network service. The service will stop
12360 * if all references (also from other VMs) are removed. */
12361 for (; miNATNetworksStarted > 0; miNATNetworksStarted--)
12362 {
12363 for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12364 {
12365 NetworkAttachmentType_T type;
12366 HRESULT hrc;
12367
12368 hrc = mNetworkAdapters[slot]->COMGETTER(AttachmentType)(&type);
12369 if ( SUCCEEDED(hrc)
12370 && type == NetworkAttachmentType_NATNetwork)
12371 {
12372 Bstr name;
12373 hrc = mNetworkAdapters[slot]->COMGETTER(NATNetwork)(name.asOutParam());
12374 if (SUCCEEDED(hrc))
12375 {
12376 multilock.release();
12377 LogRel(("VM '%s' stops using NAT network '%ls'\n",
12378 mUserData->s.strName.c_str(), name.raw()));
12379 mParent->i_natNetworkRefDec(name.raw());
12380 multilock.acquire();
12381 }
12382 }
12383 }
12384 }
12385
12386 /*
12387 * An expected uninitialization can come only from #checkForDeath().
12388 * Otherwise it means that something's gone really wrong (for example,
12389 * the Session implementation has released the VirtualBox reference
12390 * before it triggered #OnSessionEnd(), or before releasing IPC semaphore,
12391 * etc). However, it's also possible, that the client releases the IPC
12392 * semaphore correctly (i.e. before it releases the VirtualBox reference),
12393 * but the VirtualBox release event comes first to the server process.
12394 * This case is practically possible, so we should not assert on an
12395 * unexpected uninit, just log a warning.
12396 */
12397
12398 if ((aReason == Uninit::Unexpected))
12399 LogWarningThisFunc(("Unexpected SessionMachine uninitialization!\n"));
12400
12401 if (aReason != Uninit::Normal)
12402 {
12403 mData->mSession.mDirectControl.setNull();
12404 }
12405 else
12406 {
12407 /* this must be null here (see #OnSessionEnd()) */
12408 Assert(mData->mSession.mDirectControl.isNull());
12409 Assert(mData->mSession.mState == SessionState_Unlocking);
12410 Assert(!mData->mSession.mProgress.isNull());
12411 }
12412 if (mData->mSession.mProgress)
12413 {
12414 if (aReason == Uninit::Normal)
12415 mData->mSession.mProgress->i_notifyComplete(S_OK);
12416 else
12417 mData->mSession.mProgress->i_notifyComplete(E_FAIL,
12418 COM_IIDOF(ISession),
12419 getComponentName(),
12420 tr("The VM session was aborted"));
12421 mData->mSession.mProgress.setNull();
12422 }
12423
12424 /* remove the association between the peer machine and this session machine */
12425 Assert( (SessionMachine*)mData->mSession.mMachine == this
12426 || aReason == Uninit::Unexpected);
12427
12428 /* reset the rest of session data */
12429 mData->mSession.mMachine.setNull();
12430 mData->mSession.mState = SessionState_Unlocked;
12431 mData->mSession.mType.setNull();
12432
12433 /* destroy the machine client token before leaving the exclusive lock */
12434 if (mClientToken)
12435 {
12436 delete mClientToken;
12437 mClientToken = NULL;
12438 }
12439
12440 /* fire an event */
12441 mParent->i_onSessionStateChange(mData->mUuid, SessionState_Unlocked);
12442
12443 uninitDataAndChildObjects();
12444
12445 /* free the essential data structure last */
12446 mData.free();
12447
12448 /* release the exclusive lock before setting the below two to NULL */
12449 multilock.release();
12450
12451 unconst(mParent) = NULL;
12452 unconst(mPeer) = NULL;
12453
12454 LogFlowThisFuncLeave();
12455}
12456
12457// util::Lockable interface
12458////////////////////////////////////////////////////////////////////////////////
12459
12460/**
12461 * Overrides VirtualBoxBase::lockHandle() in order to share the lock handle
12462 * with the primary Machine instance (mPeer).
12463 */
12464RWLockHandle *SessionMachine::lockHandle() const
12465{
12466 AssertReturn(mPeer != NULL, NULL);
12467 return mPeer->lockHandle();
12468}
12469
12470// IInternalMachineControl methods
12471////////////////////////////////////////////////////////////////////////////////
12472
12473/**
12474 * Passes collected guest statistics to performance collector object
12475 */
12476STDMETHODIMP SessionMachine::ReportVmStatistics(ULONG aValidStats, ULONG aCpuUser,
12477 ULONG aCpuKernel, ULONG aCpuIdle,
12478 ULONG aMemTotal, ULONG aMemFree,
12479 ULONG aMemBalloon, ULONG aMemShared,
12480 ULONG aMemCache, ULONG aPageTotal,
12481 ULONG aAllocVMM, ULONG aFreeVMM,
12482 ULONG aBalloonedVMM, ULONG aSharedVMM,
12483 ULONG aVmNetRx, ULONG aVmNetTx)
12484{
12485#ifdef VBOX_WITH_RESOURCE_USAGE_API
12486 if (mCollectorGuest)
12487 mCollectorGuest->updateStats(aValidStats, aCpuUser, aCpuKernel, aCpuIdle,
12488 aMemTotal, aMemFree, aMemBalloon, aMemShared,
12489 aMemCache, aPageTotal, aAllocVMM, aFreeVMM,
12490 aBalloonedVMM, aSharedVMM, aVmNetRx, aVmNetTx);
12491
12492 return S_OK;
12493#else
12494 NOREF(aValidStats);
12495 NOREF(aCpuUser);
12496 NOREF(aCpuKernel);
12497 NOREF(aCpuIdle);
12498 NOREF(aMemTotal);
12499 NOREF(aMemFree);
12500 NOREF(aMemBalloon);
12501 NOREF(aMemShared);
12502 NOREF(aMemCache);
12503 NOREF(aPageTotal);
12504 NOREF(aAllocVMM);
12505 NOREF(aFreeVMM);
12506 NOREF(aBalloonedVMM);
12507 NOREF(aSharedVMM);
12508 NOREF(aVmNetRx);
12509 NOREF(aVmNetTx);
12510 return E_NOTIMPL;
12511#endif
12512}
12513
12514/**
12515 * @note Locks this object for writing.
12516 */
12517STDMETHODIMP SessionMachine::SetRemoveSavedStateFile(BOOL aRemove)
12518{
12519 AutoCaller autoCaller(this);
12520 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
12521
12522 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12523
12524 mRemoveSavedState = aRemove;
12525
12526 return S_OK;
12527}
12528
12529/**
12530 * @note Locks the same as #i_setMachineState() does.
12531 */
12532STDMETHODIMP SessionMachine::UpdateState(MachineState_T aMachineState)
12533{
12534 return i_setMachineState(aMachineState);
12535}
12536
12537/**
12538 * @note Locks this object for writing.
12539 */
12540STDMETHODIMP SessionMachine::BeginPowerUp(IProgress *aProgress)
12541{
12542 LogFlowThisFunc(("aProgress=%p\n", aProgress));
12543 AutoCaller autoCaller(this);
12544 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
12545
12546 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12547
12548 if (mData->mSession.mState != SessionState_Locked)
12549 return VBOX_E_INVALID_OBJECT_STATE;
12550
12551 if (!mData->mSession.mProgress.isNull())
12552 mData->mSession.mProgress->setOtherProgressObject(aProgress);
12553
12554 /* If we didn't reference the NAT network service yet, add a reference to
12555 * force a start */
12556 if (miNATNetworksStarted < 1)
12557 {
12558 for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
12559 {
12560 NetworkAttachmentType_T type;
12561 HRESULT hrc;
12562 hrc = mNetworkAdapters[slot]->COMGETTER(AttachmentType)(&type);
12563 if ( SUCCEEDED(hrc)
12564 && type == NetworkAttachmentType_NATNetwork)
12565 {
12566 Bstr name;
12567 hrc = mNetworkAdapters[slot]->COMGETTER(NATNetwork)(name.asOutParam());
12568 if (SUCCEEDED(hrc))
12569 {
12570 LogRel(("VM '%s' starts using NAT network '%ls'\n",
12571 mUserData->s.strName.c_str(), name.raw()));
12572 mPeer->lockHandle()->unlockWrite();
12573 mParent->i_natNetworkRefInc(name.raw());
12574#ifdef RT_LOCK_STRICT
12575 mPeer->lockHandle()->lockWrite(RT_SRC_POS);
12576#else
12577 mPeer->lockHandle()->lockWrite();
12578#endif
12579 }
12580 }
12581 }
12582 miNATNetworksStarted++;
12583 }
12584
12585 LogFlowThisFunc(("returns S_OK.\n"));
12586 return S_OK;
12587}
12588
12589/**
12590 * @note Locks this object for writing.
12591 */
12592STDMETHODIMP SessionMachine::EndPowerUp(LONG iResult)
12593{
12594 AutoCaller autoCaller(this);
12595 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
12596
12597 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12598
12599 if (mData->mSession.mState != SessionState_Locked)
12600 return VBOX_E_INVALID_OBJECT_STATE;
12601
12602 /* Finalize the LaunchVMProcess progress object. */
12603 if (mData->mSession.mProgress)
12604 {
12605 mData->mSession.mProgress->notifyComplete((HRESULT)iResult);
12606 mData->mSession.mProgress.setNull();
12607 }
12608
12609 if (SUCCEEDED((HRESULT)iResult))
12610 {
12611#ifdef VBOX_WITH_RESOURCE_USAGE_API
12612 /* The VM has been powered up successfully, so it makes sense
12613 * now to offer the performance metrics for a running machine
12614 * object. Doing it earlier wouldn't be safe. */
12615 i_registerMetrics(mParent->i_performanceCollector(), mPeer,
12616 mData->mSession.mPID);
12617#endif /* VBOX_WITH_RESOURCE_USAGE_API */
12618 }
12619
12620 return S_OK;
12621}
12622
12623/**
12624 * @note Locks this object for writing.
12625 */
12626STDMETHODIMP SessionMachine::BeginPoweringDown(IProgress **aProgress)
12627{
12628 LogFlowThisFuncEnter();
12629
12630 AutoCaller autoCaller(this);
12631 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
12632
12633 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12634
12635 AssertReturn(mConsoleTaskData.mLastState == MachineState_Null,
12636 E_FAIL);
12637
12638 /* create a progress object to track operation completion */
12639 ComObjPtr<Progress> pProgress;
12640 pProgress.createObject();
12641 pProgress->init(i_getVirtualBox(),
12642 static_cast<IMachine *>(this) /* aInitiator */,
12643 Bstr(tr("Stopping the virtual machine")).raw(),
12644 FALSE /* aCancelable */);
12645
12646 /* fill in the console task data */
12647 mConsoleTaskData.mLastState = mData->mMachineState;
12648 mConsoleTaskData.mProgress = pProgress;
12649
12650 /* set the state to Stopping (this is expected by Console::PowerDown()) */
12651 i_setMachineState(MachineState_Stopping);
12652
12653 pProgress.queryInterfaceTo(aProgress);
12654
12655 return S_OK;
12656}
12657
12658/**
12659 * @note Locks this object for writing.
12660 */
12661STDMETHODIMP SessionMachine::EndPoweringDown(LONG iResult, IN_BSTR aErrMsg)
12662{
12663 LogFlowThisFuncEnter();
12664
12665 AutoCaller autoCaller(this);
12666 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
12667
12668 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12669
12670 AssertReturn( ( (SUCCEEDED(iResult) && mData->mMachineState == MachineState_PoweredOff)
12671 || (FAILED(iResult) && mData->mMachineState == MachineState_Stopping))
12672 && mConsoleTaskData.mLastState != MachineState_Null,
12673 E_FAIL);
12674
12675 /*
12676 * On failure, set the state to the state we had when BeginPoweringDown()
12677 * was called (this is expected by Console::PowerDown() and the associated
12678 * task). On success the VM process already changed the state to
12679 * MachineState_PoweredOff, so no need to do anything.
12680 */
12681 if (FAILED(iResult))
12682 i_setMachineState(mConsoleTaskData.mLastState);
12683
12684 /* notify the progress object about operation completion */
12685 Assert(mConsoleTaskData.mProgress);
12686 if (SUCCEEDED(iResult))
12687 mConsoleTaskData.mProgress->i_notifyComplete(S_OK);
12688 else
12689 {
12690 Utf8Str strErrMsg(aErrMsg);
12691 if (strErrMsg.length())
12692 mConsoleTaskData.mProgress->i_notifyComplete(iResult,
12693 COM_IIDOF(ISession),
12694 getComponentName(),
12695 strErrMsg.c_str());
12696 else
12697 mConsoleTaskData.mProgress->i_notifyComplete(iResult);
12698 }
12699
12700 /* clear out the temporary saved state data */
12701 mConsoleTaskData.mLastState = MachineState_Null;
12702 mConsoleTaskData.mProgress.setNull();
12703
12704 LogFlowThisFuncLeave();
12705 return S_OK;
12706}
12707
12708
12709/**
12710 * Goes through the USB filters of the given machine to see if the given
12711 * device matches any filter or not.
12712 *
12713 * @note Locks the same as USBController::hasMatchingFilter() does.
12714 */
12715STDMETHODIMP SessionMachine::RunUSBDeviceFilters(IUSBDevice *aUSBDevice,
12716 BOOL *aMatched,
12717 ULONG *aMaskedIfs)
12718{
12719 LogFlowThisFunc(("\n"));
12720
12721 AutoCaller autoCaller(this);
12722 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
12723
12724#ifdef VBOX_WITH_USB
12725 *aMatched = mUSBDeviceFilters->i_hasMatchingFilter(aUSBDevice, aMaskedIfs);
12726#else
12727 NOREF(aUSBDevice);
12728 NOREF(aMaskedIfs);
12729 *aMatched = FALSE;
12730#endif
12731
12732 return S_OK;
12733}
12734
12735/**
12736 * @note Locks the same as Host::captureUSBDevice() does.
12737 */
12738STDMETHODIMP SessionMachine::CaptureUSBDevice(IN_BSTR aId)
12739{
12740 LogFlowThisFunc(("\n"));
12741
12742 AutoCaller autoCaller(this);
12743 AssertComRCReturnRC(autoCaller.rc());
12744
12745#ifdef VBOX_WITH_USB
12746 /* if captureDeviceForVM() fails, it must have set extended error info */
12747 clearError();
12748 MultiResult rc = mParent->i_host()->i_checkUSBProxyService();
12749 if (FAILED(rc)) return rc;
12750
12751 USBProxyService *service = mParent->i_host()->i_usbProxyService();
12752 AssertReturn(service, E_FAIL);
12753 return service->captureDeviceForVM(this, Guid(aId).ref());
12754#else
12755 NOREF(aId);
12756 return E_NOTIMPL;
12757#endif
12758}
12759
12760/**
12761 * @note Locks the same as Host::detachUSBDevice() does.
12762 */
12763STDMETHODIMP SessionMachine::DetachUSBDevice(IN_BSTR aId, BOOL aDone)
12764{
12765 LogFlowThisFunc(("\n"));
12766
12767 AutoCaller autoCaller(this);
12768 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
12769
12770#ifdef VBOX_WITH_USB
12771 USBProxyService *service = mParent->i_host()->i_usbProxyService();
12772 AssertReturn(service, E_FAIL);
12773 return service->detachDeviceFromVM(this, Guid(aId).ref(), !!aDone);
12774#else
12775 NOREF(aId);
12776 NOREF(aDone);
12777 return E_NOTIMPL;
12778#endif
12779}
12780
12781/**
12782 * Inserts all machine filters to the USB proxy service and then calls
12783 * Host::autoCaptureUSBDevices().
12784 *
12785 * Called by Console from the VM process upon VM startup.
12786 *
12787 * @note Locks what called methods lock.
12788 */
12789STDMETHODIMP SessionMachine::AutoCaptureUSBDevices()
12790{
12791 LogFlowThisFunc(("\n"));
12792
12793 AutoCaller autoCaller(this);
12794 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
12795
12796#ifdef VBOX_WITH_USB
12797 HRESULT rc = mUSBDeviceFilters->i_notifyProxy(true /* aInsertFilters */);
12798 AssertComRC(rc);
12799 NOREF(rc);
12800
12801 USBProxyService *service = mParent->i_host()->i_usbProxyService();
12802 AssertReturn(service, E_FAIL);
12803 return service->autoCaptureDevicesForVM(this);
12804#else
12805 return S_OK;
12806#endif
12807}
12808
12809/**
12810 * Removes all machine filters from the USB proxy service and then calls
12811 * Host::detachAllUSBDevices().
12812 *
12813 * Called by Console from the VM process upon normal VM termination or by
12814 * SessionMachine::uninit() upon abnormal VM termination (from under the
12815 * Machine/SessionMachine lock).
12816 *
12817 * @note Locks what called methods lock.
12818 */
12819STDMETHODIMP SessionMachine::DetachAllUSBDevices(BOOL aDone)
12820{
12821 LogFlowThisFunc(("\n"));
12822
12823 AutoCaller autoCaller(this);
12824 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
12825
12826#ifdef VBOX_WITH_USB
12827 HRESULT rc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
12828 AssertComRC(rc);
12829 NOREF(rc);
12830
12831 USBProxyService *service = mParent->i_host()->i_usbProxyService();
12832 AssertReturn(service, E_FAIL);
12833 return service->detachAllDevicesFromVM(this, !!aDone, false /* aAbnormal */);
12834#else
12835 NOREF(aDone);
12836 return S_OK;
12837#endif
12838}
12839
12840/**
12841 * @note Locks this object for writing.
12842 */
12843STDMETHODIMP SessionMachine::OnSessionEnd(ISession *aSession,
12844 IProgress **aProgress)
12845{
12846 LogFlowThisFuncEnter();
12847
12848 AssertReturn(aSession, E_INVALIDARG);
12849 AssertReturn(aProgress, E_INVALIDARG);
12850
12851 AutoCaller autoCaller(this);
12852
12853 LogFlowThisFunc(("callerstate=%d\n", getObjectState().getState()));
12854 /*
12855 * We don't assert below because it might happen that a non-direct session
12856 * informs us it is closed right after we've been uninitialized -- it's ok.
12857 */
12858 if (FAILED(autoCaller.rc())) return autoCaller.rc();
12859
12860 /* get IInternalSessionControl interface */
12861 ComPtr<IInternalSessionControl> control(aSession);
12862
12863 ComAssertRet(!control.isNull(), E_INVALIDARG);
12864
12865 /* Creating a Progress object requires the VirtualBox lock, and
12866 * thus locking it here is required by the lock order rules. */
12867 AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
12868
12869 if (control == mData->mSession.mDirectControl)
12870 {
12871 ComAssertRet(aProgress, E_POINTER);
12872
12873 /* The direct session is being normally closed by the client process
12874 * ----------------------------------------------------------------- */
12875
12876 /* go to the closing state (essential for all open*Session() calls and
12877 * for #checkForDeath()) */
12878 Assert(mData->mSession.mState == SessionState_Locked);
12879 mData->mSession.mState = SessionState_Unlocking;
12880
12881 /* set direct control to NULL to release the remote instance */
12882 mData->mSession.mDirectControl.setNull();
12883 LogFlowThisFunc(("Direct control is set to NULL\n"));
12884
12885 if (mData->mSession.mProgress)
12886 {
12887 /* finalize the progress, someone might wait if a frontend
12888 * closes the session before powering on the VM. */
12889 mData->mSession.mProgress->notifyComplete(E_FAIL,
12890 COM_IIDOF(ISession),
12891 getComponentName(),
12892 tr("The VM session was closed before any attempt to power it on"));
12893 mData->mSession.mProgress.setNull();
12894 }
12895
12896 /* Create the progress object the client will use to wait until
12897 * #checkForDeath() is called to uninitialize this session object after
12898 * it releases the IPC semaphore.
12899 * Note! Because we're "reusing" mProgress here, this must be a proxy
12900 * object just like for LaunchVMProcess. */
12901 Assert(mData->mSession.mProgress.isNull());
12902 ComObjPtr<ProgressProxy> progress;
12903 progress.createObject();
12904 ComPtr<IUnknown> pPeer(mPeer);
12905 progress->init(mParent, pPeer,
12906 Bstr(tr("Closing session")).raw(),
12907 FALSE /* aCancelable */);
12908 progress.queryInterfaceTo(aProgress);
12909 mData->mSession.mProgress = progress;
12910 }
12911 else
12912 {
12913 /* the remote session is being normally closed */
12914 Data::Session::RemoteControlList::iterator it =
12915 mData->mSession.mRemoteControls.begin();
12916 while (it != mData->mSession.mRemoteControls.end())
12917 {
12918 if (control == *it)
12919 break;
12920 ++it;
12921 }
12922 BOOL found = it != mData->mSession.mRemoteControls.end();
12923 ComAssertMsgRet(found, ("The session is not found in the session list!"),
12924 E_INVALIDARG);
12925 // This MUST be erase(it), not remove(*it) as the latter triggers a
12926 // very nasty use after free due to the place where the value "lives".
12927 mData->mSession.mRemoteControls.erase(it);
12928 }
12929
12930 /* signal the client watcher thread, because the client is going away */
12931 mParent->i_updateClientWatcher();
12932
12933 LogFlowThisFuncLeave();
12934 return S_OK;
12935}
12936
12937/**
12938 * @note Locks this object for writing.
12939 */
12940STDMETHODIMP SessionMachine::BeginSavingState(IProgress **aProgress, BSTR *aStateFilePath)
12941{
12942 LogFlowThisFuncEnter();
12943
12944 CheckComArgOutPointerValid(aProgress);
12945 CheckComArgOutPointerValid(aStateFilePath);
12946
12947 AutoCaller autoCaller(this);
12948 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
12949
12950 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
12951
12952 AssertReturn( mData->mMachineState == MachineState_Paused
12953 && mConsoleTaskData.mLastState == MachineState_Null
12954 && mConsoleTaskData.strStateFilePath.isEmpty(),
12955 E_FAIL);
12956
12957 /* create a progress object to track operation completion */
12958 ComObjPtr<Progress> pProgress;
12959 pProgress.createObject();
12960 pProgress->init(i_getVirtualBox(),
12961 static_cast<IMachine *>(this) /* aInitiator */,
12962 Bstr(tr("Saving the execution state of the virtual machine")).raw(),
12963 FALSE /* aCancelable */);
12964
12965 Utf8Str strStateFilePath;
12966 /* stateFilePath is null when the machine is not running */
12967 if (mData->mMachineState == MachineState_Paused)
12968 i_composeSavedStateFilename(strStateFilePath);
12969
12970 /* fill in the console task data */
12971 mConsoleTaskData.mLastState = mData->mMachineState;
12972 mConsoleTaskData.strStateFilePath = strStateFilePath;
12973 mConsoleTaskData.mProgress = pProgress;
12974
12975 /* set the state to Saving (this is expected by Console::SaveState()) */
12976 i_setMachineState(MachineState_Saving);
12977
12978 strStateFilePath.cloneTo(aStateFilePath);
12979 pProgress.queryInterfaceTo(aProgress);
12980
12981 return S_OK;
12982}
12983
12984/**
12985 * @note Locks mParent + this object for writing.
12986 */
12987STDMETHODIMP SessionMachine::EndSavingState(LONG iResult, IN_BSTR aErrMsg)
12988{
12989 LogFlowThisFunc(("\n"));
12990
12991 AutoCaller autoCaller(this);
12992 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
12993
12994 /* endSavingState() need mParent lock */
12995 AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
12996
12997 AssertReturn( ( (SUCCEEDED(iResult) && mData->mMachineState == MachineState_Saved)
12998 || (FAILED(iResult) && mData->mMachineState == MachineState_Saving))
12999 && mConsoleTaskData.mLastState != MachineState_Null
13000 && !mConsoleTaskData.strStateFilePath.isEmpty(),
13001 E_FAIL);
13002
13003 /*
13004 * On failure, set the state to the state we had when BeginSavingState()
13005 * was called (this is expected by Console::SaveState() and the associated
13006 * task). On success the VM process already changed the state to
13007 * MachineState_Saved, so no need to do anything.
13008 */
13009 if (FAILED(iResult))
13010 i_setMachineState(mConsoleTaskData.mLastState);
13011
13012 return endSavingState(iResult, aErrMsg);
13013}
13014
13015/**
13016 * @note Locks this object for writing.
13017 */
13018STDMETHODIMP SessionMachine::AdoptSavedState(IN_BSTR aSavedStateFile)
13019{
13020 LogFlowThisFunc(("\n"));
13021
13022 CheckComArgStrNotEmptyOrNull(aSavedStateFile);
13023
13024 AutoCaller autoCaller(this);
13025 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13026
13027 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13028
13029 AssertReturn( mData->mMachineState == MachineState_PoweredOff
13030 || mData->mMachineState == MachineState_Teleported
13031 || mData->mMachineState == MachineState_Aborted
13032 , E_FAIL); /** @todo setError. */
13033
13034 Utf8Str stateFilePathFull = aSavedStateFile;
13035 int vrc = i_calculateFullPath(stateFilePathFull, stateFilePathFull);
13036 if (RT_FAILURE(vrc))
13037 return setError(VBOX_E_FILE_ERROR,
13038 tr("Invalid saved state file path '%ls' (%Rrc)"),
13039 aSavedStateFile,
13040 vrc);
13041
13042 mSSData->strStateFilePath = stateFilePathFull;
13043
13044 /* The below i_setMachineState() will detect the state transition and will
13045 * update the settings file */
13046
13047 return i_setMachineState(MachineState_Saved);
13048}
13049
13050STDMETHODIMP SessionMachine::PullGuestProperties(ComSafeArrayOut(BSTR, aNames),
13051 ComSafeArrayOut(BSTR, aValues),
13052 ComSafeArrayOut(LONG64, aTimestamps),
13053 ComSafeArrayOut(BSTR, aFlags))
13054{
13055 LogFlowThisFunc(("\n"));
13056
13057#ifdef VBOX_WITH_GUEST_PROPS
13058 using namespace guestProp;
13059
13060 AutoCaller autoCaller(this);
13061 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13062
13063 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13064
13065 CheckComArgOutSafeArrayPointerValid(aNames);
13066 CheckComArgOutSafeArrayPointerValid(aValues);
13067 CheckComArgOutSafeArrayPointerValid(aTimestamps);
13068 CheckComArgOutSafeArrayPointerValid(aFlags);
13069
13070 size_t cEntries = mHWData->mGuestProperties.size();
13071 com::SafeArray<BSTR> names(cEntries);
13072 com::SafeArray<BSTR> values(cEntries);
13073 com::SafeArray<LONG64> timestamps(cEntries);
13074 com::SafeArray<BSTR> flags(cEntries);
13075 unsigned i = 0;
13076 for (HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.begin();
13077 it != mHWData->mGuestProperties.end();
13078 ++it)
13079 {
13080 char szFlags[MAX_FLAGS_LEN + 1];
13081 it->first.cloneTo(&names[i]);
13082 it->second.strValue.cloneTo(&values[i]);
13083 timestamps[i] = it->second.mTimestamp;
13084 /* If it is NULL, keep it NULL. */
13085 if (it->second.mFlags)
13086 {
13087 writeFlags(it->second.mFlags, szFlags);
13088 Bstr(szFlags).cloneTo(&flags[i]);
13089 }
13090 else
13091 flags[i] = NULL;
13092 ++i;
13093 }
13094 names.detachTo(ComSafeArrayOutArg(aNames));
13095 values.detachTo(ComSafeArrayOutArg(aValues));
13096 timestamps.detachTo(ComSafeArrayOutArg(aTimestamps));
13097 flags.detachTo(ComSafeArrayOutArg(aFlags));
13098 return S_OK;
13099#else
13100 ReturnComNotImplemented();
13101#endif
13102}
13103
13104STDMETHODIMP SessionMachine::PushGuestProperty(IN_BSTR aName,
13105 IN_BSTR aValue,
13106 LONG64 aTimestamp,
13107 IN_BSTR aFlags)
13108{
13109 LogFlowThisFunc(("\n"));
13110
13111#ifdef VBOX_WITH_GUEST_PROPS
13112 using namespace guestProp;
13113
13114 CheckComArgStrNotEmptyOrNull(aName);
13115 CheckComArgNotNull(aValue);
13116 CheckComArgNotNull(aFlags);
13117
13118 try
13119 {
13120 /*
13121 * Convert input up front.
13122 */
13123 Utf8Str utf8Name(aName);
13124 uint32_t fFlags = NILFLAG;
13125 if (aFlags)
13126 {
13127 Utf8Str utf8Flags(aFlags);
13128 int vrc = validateFlags(utf8Flags.c_str(), &fFlags);
13129 AssertRCReturn(vrc, E_INVALIDARG);
13130 }
13131
13132 /*
13133 * Now grab the object lock, validate the state and do the update.
13134 */
13135 AutoCaller autoCaller(this);
13136 if (FAILED(autoCaller.rc())) return autoCaller.rc();
13137
13138 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13139
13140 switch (mData->mMachineState)
13141 {
13142 case MachineState_Paused:
13143 case MachineState_Running:
13144 case MachineState_Teleporting:
13145 case MachineState_TeleportingPausedVM:
13146 case MachineState_LiveSnapshotting:
13147 case MachineState_DeletingSnapshotOnline:
13148 case MachineState_DeletingSnapshotPaused:
13149 case MachineState_Saving:
13150 case MachineState_Stopping:
13151 break;
13152
13153 default:
13154 AssertMsgFailedReturn(("%s\n", Global::stringifyMachineState(mData->mMachineState)),
13155 VBOX_E_INVALID_VM_STATE);
13156 }
13157
13158 i_setModified(IsModified_MachineData);
13159 mHWData.backup();
13160
13161 bool fDelete = !RT_VALID_PTR(aValue) || *(aValue) == '\0';
13162 HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.find(utf8Name);
13163 if (it != mHWData->mGuestProperties.end())
13164 {
13165 if (!fDelete)
13166 {
13167 it->second.strValue = aValue;
13168 it->second.mTimestamp = aTimestamp;
13169 it->second.mFlags = fFlags;
13170 }
13171 else
13172 mHWData->mGuestProperties.erase(it);
13173
13174 mData->mGuestPropertiesModified = TRUE;
13175 }
13176 else if (!fDelete)
13177 {
13178 HWData::GuestProperty prop;
13179 prop.strValue = aValue;
13180 prop.mTimestamp = aTimestamp;
13181 prop.mFlags = fFlags;
13182
13183 mHWData->mGuestProperties[utf8Name] = prop;
13184 mData->mGuestPropertiesModified = TRUE;
13185 }
13186
13187 /*
13188 * Send a callback notification if appropriate
13189 */
13190 if ( mHWData->mGuestPropertyNotificationPatterns.isEmpty()
13191 || RTStrSimplePatternMultiMatch(mHWData->mGuestPropertyNotificationPatterns.c_str(),
13192 RTSTR_MAX,
13193 utf8Name.c_str(),
13194 RTSTR_MAX, NULL)
13195 )
13196 {
13197 alock.release();
13198
13199 mParent->i_onGuestPropertyChange(mData->mUuid,
13200 aName,
13201 aValue,
13202 aFlags);
13203 }
13204 }
13205 catch (...)
13206 {
13207 return VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
13208 }
13209 return S_OK;
13210#else
13211 ReturnComNotImplemented();
13212#endif
13213}
13214
13215STDMETHODIMP SessionMachine::LockMedia()
13216{
13217 AutoCaller autoCaller(this);
13218 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13219
13220 AutoMultiWriteLock2 alock(this->lockHandle(),
13221 &mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
13222
13223 AssertReturn( mData->mMachineState == MachineState_Starting
13224 || mData->mMachineState == MachineState_Restoring
13225 || mData->mMachineState == MachineState_TeleportingIn, E_FAIL);
13226
13227 clearError();
13228 alock.release();
13229 return lockMedia();
13230}
13231
13232STDMETHODIMP SessionMachine::UnlockMedia()
13233{
13234 HRESULT hrc = unlockMedia();
13235 return hrc;
13236}
13237
13238STDMETHODIMP SessionMachine::EjectMedium(IMediumAttachment *aAttachment,
13239 IMediumAttachment **aNewAttachment)
13240{
13241 CheckComArgNotNull(aAttachment);
13242 CheckComArgOutPointerValid(aNewAttachment);
13243
13244 AutoCaller autoCaller(this);
13245 if (FAILED(autoCaller.rc())) return autoCaller.rc();
13246
13247 // request the host lock first, since might be calling Host methods for getting host drives;
13248 // next, protect the media tree all the while we're in here, as well as our member variables
13249 AutoMultiWriteLock3 multiLock(mParent->i_host()->lockHandle(),
13250 this->lockHandle(),
13251 &mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
13252
13253 ComObjPtr<MediumAttachment> pAttach = static_cast<MediumAttachment *>(aAttachment);
13254
13255 Bstr ctrlName;
13256 LONG lPort;
13257 LONG lDevice;
13258 bool fTempEject;
13259 {
13260 AutoCaller autoAttachCaller(this);
13261 if (FAILED(autoAttachCaller.rc())) return autoAttachCaller.rc();
13262
13263 AutoReadLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13264
13265 /* Need to query the details first, as the IMediumAttachment reference
13266 * might be to the original settings, which we are going to change. */
13267 ctrlName = pAttach->i_getControllerName();
13268 lPort = pAttach->i_getPort();
13269 lDevice = pAttach->i_getDevice();
13270 fTempEject = pAttach->i_getTempEject();
13271 }
13272
13273 if (!fTempEject)
13274 {
13275 /* Remember previously mounted medium. The medium before taking the
13276 * backup is not necessarily the same thing. */
13277 ComObjPtr<Medium> oldmedium;
13278 oldmedium = pAttach->i_getMedium();
13279
13280 i_setModified(IsModified_Storage);
13281 mMediaData.backup();
13282
13283 // The backup operation makes the pAttach reference point to the
13284 // old settings. Re-get the correct reference.
13285 pAttach = i_findAttachment(mMediaData->mAttachments,
13286 ctrlName.raw(),
13287 lPort,
13288 lDevice);
13289
13290 {
13291 AutoCaller autoAttachCaller(this);
13292 if (FAILED(autoAttachCaller.rc())) return autoAttachCaller.rc();
13293
13294 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13295 if (!oldmedium.isNull())
13296 oldmedium->i_removeBackReference(mData->mUuid);
13297
13298 pAttach->i_updateMedium(NULL);
13299 pAttach->i_updateEjected();
13300 }
13301
13302 i_setModified(IsModified_Storage);
13303 }
13304 else
13305 {
13306 {
13307 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
13308 pAttach->i_updateEjected();
13309 }
13310 }
13311
13312 pAttach.queryInterfaceTo(aNewAttachment);
13313
13314 return S_OK;
13315}
13316
13317// public methods only for internal purposes
13318/////////////////////////////////////////////////////////////////////////////
13319
13320#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
13321/**
13322 * Called from the client watcher thread to check for expected or unexpected
13323 * death of the client process that has a direct session to this machine.
13324 *
13325 * On Win32 and on OS/2, this method is called only when we've got the
13326 * mutex (i.e. the client has either died or terminated normally) so it always
13327 * returns @c true (the client is terminated, the session machine is
13328 * uninitialized).
13329 *
13330 * On other platforms, the method returns @c true if the client process has
13331 * terminated normally or abnormally and the session machine was uninitialized,
13332 * and @c false if the client process is still alive.
13333 *
13334 * @note Locks this object for writing.
13335 */
13336bool SessionMachine::i_checkForDeath()
13337{
13338 Uninit::Reason reason;
13339 bool terminated = false;
13340
13341 /* Enclose autoCaller with a block because calling uninit() from under it
13342 * will deadlock. */
13343 {
13344 AutoCaller autoCaller(this);
13345 if (!autoCaller.isOk())
13346 {
13347 /* return true if not ready, to cause the client watcher to exclude
13348 * the corresponding session from watching */
13349 LogFlowThisFunc(("Already uninitialized!\n"));
13350 return true;
13351 }
13352
13353 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13354
13355 /* Determine the reason of death: if the session state is Closing here,
13356 * everything is fine. Otherwise it means that the client did not call
13357 * OnSessionEnd() before it released the IPC semaphore. This may happen
13358 * either because the client process has abnormally terminated, or
13359 * because it simply forgot to call ISession::Close() before exiting. We
13360 * threat the latter also as an abnormal termination (see
13361 * Session::uninit() for details). */
13362 reason = mData->mSession.mState == SessionState_Unlocking ?
13363 Uninit::Normal :
13364 Uninit::Abnormal;
13365
13366 if (mClientToken)
13367 terminated = mClientToken->release();
13368 } /* AutoCaller block */
13369
13370 if (terminated)
13371 uninit(reason);
13372
13373 return terminated;
13374}
13375
13376void SessionMachine::i_getTokenId(Utf8Str &strTokenId)
13377{
13378 LogFlowThisFunc(("\n"));
13379
13380 strTokenId.setNull();
13381
13382 AutoCaller autoCaller(this);
13383 AssertComRCReturnVoid(autoCaller.rc());
13384
13385 Assert(mClientToken);
13386 if (mClientToken)
13387 mClientToken->getId(strTokenId);
13388}
13389#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
13390IToken *SessionMachine::i_getToken()
13391{
13392 LogFlowThisFunc(("\n"));
13393
13394 AutoCaller autoCaller(this);
13395 AssertComRCReturn(autoCaller.rc(), NULL);
13396
13397 Assert(mClientToken);
13398 if (mClientToken)
13399 return mClientToken->getToken();
13400 else
13401 return NULL;
13402}
13403#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
13404
13405Machine::ClientToken *SessionMachine::i_getClientToken()
13406{
13407 LogFlowThisFunc(("\n"));
13408
13409 AutoCaller autoCaller(this);
13410 AssertComRCReturn(autoCaller.rc(), NULL);
13411
13412 return mClientToken;
13413}
13414
13415
13416/**
13417 * @note Locks this object for reading.
13418 */
13419HRESULT SessionMachine::i_onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter)
13420{
13421 LogFlowThisFunc(("\n"));
13422
13423 AutoCaller autoCaller(this);
13424 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13425
13426 ComPtr<IInternalSessionControl> directControl;
13427 {
13428 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13429 directControl = mData->mSession.mDirectControl;
13430 }
13431
13432 /* ignore notifications sent after #OnSessionEnd() is called */
13433 if (!directControl)
13434 return S_OK;
13435
13436 return directControl->OnNetworkAdapterChange(networkAdapter, changeAdapter);
13437}
13438
13439/**
13440 * @note Locks this object for reading.
13441 */
13442HRESULT SessionMachine::i_onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
13443 NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort,
13444 IN_BSTR aGuestIp, LONG aGuestPort)
13445{
13446 LogFlowThisFunc(("\n"));
13447
13448 AutoCaller autoCaller(this);
13449 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13450
13451 ComPtr<IInternalSessionControl> directControl;
13452 {
13453 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13454 directControl = mData->mSession.mDirectControl;
13455 }
13456
13457 /* ignore notifications sent after #OnSessionEnd() is called */
13458 if (!directControl)
13459 return S_OK;
13460 /*
13461 * instead acting like callback we ask IVirtualBox deliver corresponding event
13462 */
13463
13464 mParent->i_onNatRedirectChange(i_getId(), ulSlot, RT_BOOL(aNatRuleRemove), aRuleName, aProto, aHostIp,
13465 (uint16_t)aHostPort, aGuestIp, (uint16_t)aGuestPort);
13466 return S_OK;
13467}
13468
13469/**
13470 * @note Locks this object for reading.
13471 */
13472HRESULT SessionMachine::i_onSerialPortChange(ISerialPort *serialPort)
13473{
13474 LogFlowThisFunc(("\n"));
13475
13476 AutoCaller autoCaller(this);
13477 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13478
13479 ComPtr<IInternalSessionControl> directControl;
13480 {
13481 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13482 directControl = mData->mSession.mDirectControl;
13483 }
13484
13485 /* ignore notifications sent after #OnSessionEnd() is called */
13486 if (!directControl)
13487 return S_OK;
13488
13489 return directControl->OnSerialPortChange(serialPort);
13490}
13491
13492/**
13493 * @note Locks this object for reading.
13494 */
13495HRESULT SessionMachine::i_onParallelPortChange(IParallelPort *parallelPort)
13496{
13497 LogFlowThisFunc(("\n"));
13498
13499 AutoCaller autoCaller(this);
13500 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13501
13502 ComPtr<IInternalSessionControl> directControl;
13503 {
13504 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13505 directControl = mData->mSession.mDirectControl;
13506 }
13507
13508 /* ignore notifications sent after #OnSessionEnd() is called */
13509 if (!directControl)
13510 return S_OK;
13511
13512 return directControl->OnParallelPortChange(parallelPort);
13513}
13514
13515/**
13516 * @note Locks this object for reading.
13517 */
13518HRESULT SessionMachine::i_onStorageControllerChange()
13519{
13520 LogFlowThisFunc(("\n"));
13521
13522 AutoCaller autoCaller(this);
13523 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13524
13525 ComPtr<IInternalSessionControl> directControl;
13526 {
13527 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13528 directControl = mData->mSession.mDirectControl;
13529 }
13530
13531 /* ignore notifications sent after #OnSessionEnd() is called */
13532 if (!directControl)
13533 return S_OK;
13534
13535 return directControl->OnStorageControllerChange();
13536}
13537
13538/**
13539 * @note Locks this object for reading.
13540 */
13541HRESULT SessionMachine::i_onMediumChange(IMediumAttachment *aAttachment, BOOL aForce)
13542{
13543 LogFlowThisFunc(("\n"));
13544
13545 AutoCaller autoCaller(this);
13546 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13547
13548 ComPtr<IInternalSessionControl> directControl;
13549 {
13550 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13551 directControl = mData->mSession.mDirectControl;
13552 }
13553
13554 /* ignore notifications sent after #OnSessionEnd() is called */
13555 if (!directControl)
13556 return S_OK;
13557
13558 return directControl->OnMediumChange(aAttachment, aForce);
13559}
13560
13561/**
13562 * @note Locks this object for reading.
13563 */
13564HRESULT SessionMachine::i_onCPUChange(ULONG aCPU, BOOL aRemove)
13565{
13566 LogFlowThisFunc(("\n"));
13567
13568 AutoCaller autoCaller(this);
13569 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13570
13571 ComPtr<IInternalSessionControl> directControl;
13572 {
13573 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13574 directControl = mData->mSession.mDirectControl;
13575 }
13576
13577 /* ignore notifications sent after #OnSessionEnd() is called */
13578 if (!directControl)
13579 return S_OK;
13580
13581 return directControl->OnCPUChange(aCPU, aRemove);
13582}
13583
13584HRESULT SessionMachine::i_onCPUExecutionCapChange(ULONG aExecutionCap)
13585{
13586 LogFlowThisFunc(("\n"));
13587
13588 AutoCaller autoCaller(this);
13589 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13590
13591 ComPtr<IInternalSessionControl> directControl;
13592 {
13593 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13594 directControl = mData->mSession.mDirectControl;
13595 }
13596
13597 /* ignore notifications sent after #OnSessionEnd() is called */
13598 if (!directControl)
13599 return S_OK;
13600
13601 return directControl->OnCPUExecutionCapChange(aExecutionCap);
13602}
13603
13604/**
13605 * @note Locks this object for reading.
13606 */
13607HRESULT SessionMachine::i_onVRDEServerChange(BOOL aRestart)
13608{
13609 LogFlowThisFunc(("\n"));
13610
13611 AutoCaller autoCaller(this);
13612 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13613
13614 ComPtr<IInternalSessionControl> directControl;
13615 {
13616 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13617 directControl = mData->mSession.mDirectControl;
13618 }
13619
13620 /* ignore notifications sent after #OnSessionEnd() is called */
13621 if (!directControl)
13622 return S_OK;
13623
13624 return directControl->OnVRDEServerChange(aRestart);
13625}
13626
13627/**
13628 * @note Locks this object for reading.
13629 */
13630HRESULT SessionMachine::i_onVideoCaptureChange()
13631{
13632 LogFlowThisFunc(("\n"));
13633
13634 AutoCaller autoCaller(this);
13635 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13636
13637 ComPtr<IInternalSessionControl> directControl;
13638 {
13639 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13640 directControl = mData->mSession.mDirectControl;
13641 }
13642
13643 /* ignore notifications sent after #OnSessionEnd() is called */
13644 if (!directControl)
13645 return S_OK;
13646
13647 return directControl->OnVideoCaptureChange();
13648}
13649
13650/**
13651 * @note Locks this object for reading.
13652 */
13653HRESULT SessionMachine::i_onUSBControllerChange()
13654{
13655 LogFlowThisFunc(("\n"));
13656
13657 AutoCaller autoCaller(this);
13658 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13659
13660 ComPtr<IInternalSessionControl> directControl;
13661 {
13662 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13663 directControl = mData->mSession.mDirectControl;
13664 }
13665
13666 /* ignore notifications sent after #OnSessionEnd() is called */
13667 if (!directControl)
13668 return S_OK;
13669
13670 return directControl->OnUSBControllerChange();
13671}
13672
13673/**
13674 * @note Locks this object for reading.
13675 */
13676HRESULT SessionMachine::i_onSharedFolderChange()
13677{
13678 LogFlowThisFunc(("\n"));
13679
13680 AutoCaller autoCaller(this);
13681 AssertComRCReturnRC(autoCaller.rc());
13682
13683 ComPtr<IInternalSessionControl> directControl;
13684 {
13685 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13686 directControl = mData->mSession.mDirectControl;
13687 }
13688
13689 /* ignore notifications sent after #OnSessionEnd() is called */
13690 if (!directControl)
13691 return S_OK;
13692
13693 return directControl->OnSharedFolderChange(FALSE /* aGlobal */);
13694}
13695
13696/**
13697 * @note Locks this object for reading.
13698 */
13699HRESULT SessionMachine::i_onClipboardModeChange(ClipboardMode_T aClipboardMode)
13700{
13701 LogFlowThisFunc(("\n"));
13702
13703 AutoCaller autoCaller(this);
13704 AssertComRCReturnRC(autoCaller.rc());
13705
13706 ComPtr<IInternalSessionControl> directControl;
13707 {
13708 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13709 directControl = mData->mSession.mDirectControl;
13710 }
13711
13712 /* ignore notifications sent after #OnSessionEnd() is called */
13713 if (!directControl)
13714 return S_OK;
13715
13716 return directControl->OnClipboardModeChange(aClipboardMode);
13717}
13718
13719/**
13720 * @note Locks this object for reading.
13721 */
13722HRESULT SessionMachine::i_onDnDModeChange(DnDMode_T aDnDMode)
13723{
13724 LogFlowThisFunc(("\n"));
13725
13726 AutoCaller autoCaller(this);
13727 AssertComRCReturnRC(autoCaller.rc());
13728
13729 ComPtr<IInternalSessionControl> directControl;
13730 {
13731 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13732 directControl = mData->mSession.mDirectControl;
13733 }
13734
13735 /* ignore notifications sent after #OnSessionEnd() is called */
13736 if (!directControl)
13737 return S_OK;
13738
13739 return directControl->OnDnDModeChange(aDnDMode);
13740}
13741
13742/**
13743 * @note Locks this object for reading.
13744 */
13745HRESULT SessionMachine::i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup)
13746{
13747 LogFlowThisFunc(("\n"));
13748
13749 AutoCaller autoCaller(this);
13750 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13751
13752 ComPtr<IInternalSessionControl> directControl;
13753 {
13754 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13755 directControl = mData->mSession.mDirectControl;
13756 }
13757
13758 /* ignore notifications sent after #OnSessionEnd() is called */
13759 if (!directControl)
13760 return S_OK;
13761
13762 return directControl->OnBandwidthGroupChange(aBandwidthGroup);
13763}
13764
13765/**
13766 * @note Locks this object for reading.
13767 */
13768HRESULT SessionMachine::i_onStorageDeviceChange(IMediumAttachment *aAttachment, BOOL aRemove, BOOL aSilent)
13769{
13770 LogFlowThisFunc(("\n"));
13771
13772 AutoCaller autoCaller(this);
13773 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13774
13775 ComPtr<IInternalSessionControl> directControl;
13776 {
13777 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13778 directControl = mData->mSession.mDirectControl;
13779 }
13780
13781 /* ignore notifications sent after #OnSessionEnd() is called */
13782 if (!directControl)
13783 return S_OK;
13784
13785 return directControl->OnStorageDeviceChange(aAttachment, aRemove, aSilent);
13786}
13787
13788/**
13789 * Returns @c true if this machine's USB controller reports it has a matching
13790 * filter for the given USB device and @c false otherwise.
13791 *
13792 * @note locks this object for reading.
13793 */
13794bool SessionMachine::i_hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
13795{
13796 AutoCaller autoCaller(this);
13797 /* silently return if not ready -- this method may be called after the
13798 * direct machine session has been called */
13799 if (!autoCaller.isOk())
13800 return false;
13801
13802#ifdef VBOX_WITH_USB
13803 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13804
13805 switch (mData->mMachineState)
13806 {
13807 case MachineState_Starting:
13808 case MachineState_Restoring:
13809 case MachineState_TeleportingIn:
13810 case MachineState_Paused:
13811 case MachineState_Running:
13812 /** @todo Live Migration: snapshoting & teleporting. Need to fend things of
13813 * elsewhere... */
13814 alock.release();
13815 return mUSBDeviceFilters->i_hasMatchingFilter(aDevice, aMaskedIfs);
13816 default: break;
13817 }
13818#else
13819 NOREF(aDevice);
13820 NOREF(aMaskedIfs);
13821#endif
13822 return false;
13823}
13824
13825/**
13826 * @note The calls shall hold no locks. Will temporarily lock this object for reading.
13827 */
13828HRESULT SessionMachine::i_onUSBDeviceAttach(IUSBDevice *aDevice,
13829 IVirtualBoxErrorInfo *aError,
13830 ULONG aMaskedIfs)
13831{
13832 LogFlowThisFunc(("\n"));
13833
13834 AutoCaller autoCaller(this);
13835
13836 /* This notification may happen after the machine object has been
13837 * uninitialized (the session was closed), so don't assert. */
13838 if (FAILED(autoCaller.rc())) return autoCaller.rc();
13839
13840 ComPtr<IInternalSessionControl> directControl;
13841 {
13842 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13843 directControl = mData->mSession.mDirectControl;
13844 }
13845
13846 /* fail on notifications sent after #OnSessionEnd() is called, it is
13847 * expected by the caller */
13848 if (!directControl)
13849 return E_FAIL;
13850
13851 /* No locks should be held at this point. */
13852 AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
13853 AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
13854
13855 return directControl->OnUSBDeviceAttach(aDevice, aError, aMaskedIfs);
13856}
13857
13858/**
13859 * @note The calls shall hold no locks. Will temporarily lock this object for reading.
13860 */
13861HRESULT SessionMachine::i_onUSBDeviceDetach(IN_BSTR aId,
13862 IVirtualBoxErrorInfo *aError)
13863{
13864 LogFlowThisFunc(("\n"));
13865
13866 AutoCaller autoCaller(this);
13867
13868 /* This notification may happen after the machine object has been
13869 * uninitialized (the session was closed), so don't assert. */
13870 if (FAILED(autoCaller.rc())) return autoCaller.rc();
13871
13872 ComPtr<IInternalSessionControl> directControl;
13873 {
13874 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
13875 directControl = mData->mSession.mDirectControl;
13876 }
13877
13878 /* fail on notifications sent after #OnSessionEnd() is called, it is
13879 * expected by the caller */
13880 if (!directControl)
13881 return E_FAIL;
13882
13883 /* No locks should be held at this point. */
13884 AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
13885 AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
13886
13887 return directControl->OnUSBDeviceDetach(aId, aError);
13888}
13889
13890// protected methods
13891/////////////////////////////////////////////////////////////////////////////
13892
13893/**
13894 * Helper method to finalize saving the state.
13895 *
13896 * @note Must be called from under this object's lock.
13897 *
13898 * @param aRc S_OK if the snapshot has been taken successfully
13899 * @param aErrMsg human readable error message for failure
13900 *
13901 * @note Locks mParent + this objects for writing.
13902 */
13903HRESULT SessionMachine::endSavingState(HRESULT aRc, const Utf8Str &aErrMsg)
13904{
13905 LogFlowThisFuncEnter();
13906
13907 AutoCaller autoCaller(this);
13908 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
13909
13910 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
13911
13912 HRESULT rc = S_OK;
13913
13914 if (SUCCEEDED(aRc))
13915 {
13916 mSSData->strStateFilePath = mConsoleTaskData.strStateFilePath;
13917
13918 /* save all VM settings */
13919 rc = i_saveSettings(NULL);
13920 // no need to check whether VirtualBox.xml needs saving also since
13921 // we can't have a name change pending at this point
13922 }
13923 else
13924 {
13925 // delete the saved state file (it might have been already created);
13926 // we need not check whether this is shared with a snapshot here because
13927 // we certainly created this saved state file here anew
13928 RTFileDelete(mConsoleTaskData.strStateFilePath.c_str());
13929 }
13930
13931 /* notify the progress object about operation completion */
13932 Assert(mConsoleTaskData.mProgress);
13933 if (SUCCEEDED(aRc))
13934 mConsoleTaskData.mProgress->i_notifyComplete(S_OK);
13935 else
13936 {
13937 if (aErrMsg.length())
13938 mConsoleTaskData.mProgress->i_notifyComplete(aRc,
13939 COM_IIDOF(ISession),
13940 getComponentName(),
13941 aErrMsg.c_str());
13942 else
13943 mConsoleTaskData.mProgress->i_notifyComplete(aRc);
13944 }
13945
13946 /* clear out the temporary saved state data */
13947 mConsoleTaskData.mLastState = MachineState_Null;
13948 mConsoleTaskData.strStateFilePath.setNull();
13949 mConsoleTaskData.mProgress.setNull();
13950
13951 LogFlowThisFuncLeave();
13952 return rc;
13953}
13954
13955/**
13956 * Deletes the given file if it is no longer in use by either the current machine state
13957 * (if the machine is "saved") or any of the machine's snapshots.
13958 *
13959 * Note: This checks mSSData->strStateFilePath, which is shared by the Machine and SessionMachine
13960 * but is different for each SnapshotMachine. When calling this, the order of calling this
13961 * function on the one hand and changing that variable OR the snapshots tree on the other hand
13962 * is therefore critical. I know, it's all rather messy.
13963 *
13964 * @param strStateFile
13965 * @param pSnapshotToIgnore Passed to Snapshot::sharesSavedStateFile(); this snapshot is ignored in
13966 * the test for whether the saved state file is in use.
13967 */
13968void SessionMachine::i_releaseSavedStateFile(const Utf8Str &strStateFile,
13969 Snapshot *pSnapshotToIgnore)
13970{
13971 // it is safe to delete this saved state file if it is not currently in use by the machine ...
13972 if ( (strStateFile.isNotEmpty())
13973 && (strStateFile != mSSData->strStateFilePath) // session machine's saved state
13974 )
13975 // ... and it must also not be shared with other snapshots
13976 if ( !mData->mFirstSnapshot
13977 || !mData->mFirstSnapshot->i_sharesSavedStateFile(strStateFile, pSnapshotToIgnore)
13978 // this checks the SnapshotMachine's state file paths
13979 )
13980 RTFileDelete(strStateFile.c_str());
13981}
13982
13983/**
13984 * Locks the attached media.
13985 *
13986 * All attached hard disks are locked for writing and DVD/floppy are locked for
13987 * reading. Parents of attached hard disks (if any) are locked for reading.
13988 *
13989 * This method also performs accessibility check of all media it locks: if some
13990 * media is inaccessible, the method will return a failure and a bunch of
13991 * extended error info objects per each inaccessible medium.
13992 *
13993 * Note that this method is atomic: if it returns a success, all media are
13994 * locked as described above; on failure no media is locked at all (all
13995 * succeeded individual locks will be undone).
13996 *
13997 * The caller is responsible for doing the necessary state sanity checks.
13998 *
13999 * The locks made by this method must be undone by calling #unlockMedia() when
14000 * no more needed.
14001 */
14002HRESULT SessionMachine::lockMedia()
14003{
14004 AutoCaller autoCaller(this);
14005 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14006
14007 AutoMultiWriteLock2 alock(this->lockHandle(),
14008 &mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
14009
14010 /* bail out if trying to lock things with already set up locking */
14011 AssertReturn(mData->mSession.mLockedMedia.IsEmpty(), E_FAIL);
14012
14013 MultiResult mrc(S_OK);
14014
14015 /* Collect locking information for all medium objects attached to the VM. */
14016 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
14017 it != mMediaData->mAttachments.end();
14018 ++it)
14019 {
14020 MediumAttachment* pAtt = *it;
14021 DeviceType_T devType = pAtt->i_getType();
14022 Medium *pMedium = pAtt->i_getMedium();
14023
14024 MediumLockList *pMediumLockList(new MediumLockList());
14025 // There can be attachments without a medium (floppy/dvd), and thus
14026 // it's impossible to create a medium lock list. It still makes sense
14027 // to have the empty medium lock list in the map in case a medium is
14028 // attached later.
14029 if (pMedium != NULL)
14030 {
14031 MediumType_T mediumType = pMedium->i_getType();
14032 bool fIsReadOnlyLock = mediumType == MediumType_Readonly
14033 || mediumType == MediumType_Shareable;
14034 bool fIsVitalImage = (devType == DeviceType_HardDisk);
14035
14036 alock.release();
14037 mrc = pMedium->i_createMediumLockList(fIsVitalImage /* fFailIfInaccessible */,
14038 !fIsReadOnlyLock /* fMediumLockWrite */,
14039 NULL,
14040 *pMediumLockList);
14041 alock.acquire();
14042 if (FAILED(mrc))
14043 {
14044 delete pMediumLockList;
14045 mData->mSession.mLockedMedia.Clear();
14046 break;
14047 }
14048 }
14049
14050 HRESULT rc = mData->mSession.mLockedMedia.Insert(pAtt, pMediumLockList);
14051 if (FAILED(rc))
14052 {
14053 mData->mSession.mLockedMedia.Clear();
14054 mrc = setError(rc,
14055 tr("Collecting locking information for all attached media failed"));
14056 break;
14057 }
14058 }
14059
14060 if (SUCCEEDED(mrc))
14061 {
14062 /* Now lock all media. If this fails, nothing is locked. */
14063 alock.release();
14064 HRESULT rc = mData->mSession.mLockedMedia.Lock();
14065 alock.acquire();
14066 if (FAILED(rc))
14067 {
14068 mrc = setError(rc,
14069 tr("Locking of attached media failed"));
14070 }
14071 }
14072
14073 return mrc;
14074}
14075
14076/**
14077 * Undoes the locks made by by #lockMedia().
14078 */
14079HRESULT SessionMachine::unlockMedia()
14080{
14081 AutoCaller autoCaller(this);
14082 AssertComRCReturn(autoCaller.rc(),autoCaller.rc());
14083
14084 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
14085
14086 /* we may be holding important error info on the current thread;
14087 * preserve it */
14088 ErrorInfoKeeper eik;
14089
14090 HRESULT rc = mData->mSession.mLockedMedia.Clear();
14091 AssertComRC(rc);
14092 return rc;
14093}
14094
14095/**
14096 * Helper to change the machine state (reimplementation).
14097 *
14098 * @note Locks this object for writing.
14099 * @note This method must not call i_saveSettings or SaveSettings, otherwise
14100 * it can cause crashes in random places due to unexpectedly committing
14101 * the current settings. The caller is responsible for that. The call
14102 * to saveStateSettings is fine, because this method does not commit.
14103 */
14104HRESULT SessionMachine::i_setMachineState(MachineState_T aMachineState)
14105{
14106 LogFlowThisFuncEnter();
14107 LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
14108
14109 AutoCaller autoCaller(this);
14110 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14111
14112 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
14113
14114 MachineState_T oldMachineState = mData->mMachineState;
14115
14116 AssertMsgReturn(oldMachineState != aMachineState,
14117 ("oldMachineState=%s, aMachineState=%s\n",
14118 Global::stringifyMachineState(oldMachineState), Global::stringifyMachineState(aMachineState)),
14119 E_FAIL);
14120
14121 HRESULT rc = S_OK;
14122
14123 int stsFlags = 0;
14124 bool deleteSavedState = false;
14125
14126 /* detect some state transitions */
14127
14128 if ( ( oldMachineState == MachineState_Saved
14129 && aMachineState == MachineState_Restoring)
14130 || ( ( oldMachineState == MachineState_PoweredOff
14131 || oldMachineState == MachineState_Teleported
14132 || oldMachineState == MachineState_Aborted
14133 )
14134 && ( aMachineState == MachineState_TeleportingIn
14135 || aMachineState == MachineState_Starting
14136 )
14137 )
14138 )
14139 {
14140 /* The EMT thread is about to start */
14141
14142 /* Nothing to do here for now... */
14143
14144 /// @todo NEWMEDIA don't let mDVDDrive and other children
14145 /// change anything when in the Starting/Restoring state
14146 }
14147 else if ( ( oldMachineState == MachineState_Running
14148 || oldMachineState == MachineState_Paused
14149 || oldMachineState == MachineState_Teleporting
14150 || oldMachineState == MachineState_LiveSnapshotting
14151 || oldMachineState == MachineState_Stuck
14152 || oldMachineState == MachineState_Starting
14153 || oldMachineState == MachineState_Stopping
14154 || oldMachineState == MachineState_Saving
14155 || oldMachineState == MachineState_Restoring
14156 || oldMachineState == MachineState_TeleportingPausedVM
14157 || oldMachineState == MachineState_TeleportingIn
14158 )
14159 && ( aMachineState == MachineState_PoweredOff
14160 || aMachineState == MachineState_Saved
14161 || aMachineState == MachineState_Teleported
14162 || aMachineState == MachineState_Aborted
14163 )
14164 /* ignore PoweredOff->Saving->PoweredOff transition when taking a
14165 * snapshot */
14166 && ( mConsoleTaskData.mSnapshot.isNull()
14167 || mConsoleTaskData.mLastState >= MachineState_Running /** @todo Live Migration: clean up (lazy bird) */
14168 )
14169 )
14170 {
14171 /* The EMT thread has just stopped, unlock attached media. Note that as
14172 * opposed to locking that is done from Console, we do unlocking here
14173 * because the VM process may have aborted before having a chance to
14174 * properly unlock all media it locked. */
14175
14176 unlockMedia();
14177 }
14178
14179 if (oldMachineState == MachineState_Restoring)
14180 {
14181 if (aMachineState != MachineState_Saved)
14182 {
14183 /*
14184 * delete the saved state file once the machine has finished
14185 * restoring from it (note that Console sets the state from
14186 * Restoring to Saved if the VM couldn't restore successfully,
14187 * to give the user an ability to fix an error and retry --
14188 * we keep the saved state file in this case)
14189 */
14190 deleteSavedState = true;
14191 }
14192 }
14193 else if ( oldMachineState == MachineState_Saved
14194 && ( aMachineState == MachineState_PoweredOff
14195 || aMachineState == MachineState_Aborted
14196 || aMachineState == MachineState_Teleported
14197 )
14198 )
14199 {
14200 /*
14201 * delete the saved state after Console::ForgetSavedState() is called
14202 * or if the VM process (owning a direct VM session) crashed while the
14203 * VM was Saved
14204 */
14205
14206 /// @todo (dmik)
14207 // Not sure that deleting the saved state file just because of the
14208 // client death before it attempted to restore the VM is a good
14209 // thing. But when it crashes we need to go to the Aborted state
14210 // which cannot have the saved state file associated... The only
14211 // way to fix this is to make the Aborted condition not a VM state
14212 // but a bool flag: i.e., when a crash occurs, set it to true and
14213 // change the state to PoweredOff or Saved depending on the
14214 // saved state presence.
14215
14216 deleteSavedState = true;
14217 mData->mCurrentStateModified = TRUE;
14218 stsFlags |= SaveSTS_CurStateModified;
14219 }
14220
14221 if ( aMachineState == MachineState_Starting
14222 || aMachineState == MachineState_Restoring
14223 || aMachineState == MachineState_TeleportingIn
14224 )
14225 {
14226 /* set the current state modified flag to indicate that the current
14227 * state is no more identical to the state in the
14228 * current snapshot */
14229 if (!mData->mCurrentSnapshot.isNull())
14230 {
14231 mData->mCurrentStateModified = TRUE;
14232 stsFlags |= SaveSTS_CurStateModified;
14233 }
14234 }
14235
14236 if (deleteSavedState)
14237 {
14238 if (mRemoveSavedState)
14239 {
14240 Assert(!mSSData->strStateFilePath.isEmpty());
14241
14242 // it is safe to delete the saved state file if ...
14243 if ( !mData->mFirstSnapshot // ... we have no snapshots or
14244 || !mData->mFirstSnapshot->i_sharesSavedStateFile(mSSData->strStateFilePath, NULL /* pSnapshotToIgnore */)
14245 // ... none of the snapshots share the saved state file
14246 )
14247 RTFileDelete(mSSData->strStateFilePath.c_str());
14248 }
14249
14250 mSSData->strStateFilePath.setNull();
14251 stsFlags |= SaveSTS_StateFilePath;
14252 }
14253
14254 /* redirect to the underlying peer machine */
14255 mPeer->i_setMachineState(aMachineState);
14256
14257 if ( aMachineState == MachineState_PoweredOff
14258 || aMachineState == MachineState_Teleported
14259 || aMachineState == MachineState_Aborted
14260 || aMachineState == MachineState_Saved)
14261 {
14262 /* the machine has stopped execution
14263 * (or the saved state file was adopted) */
14264 stsFlags |= SaveSTS_StateTimeStamp;
14265 }
14266
14267 if ( ( oldMachineState == MachineState_PoweredOff
14268 || oldMachineState == MachineState_Aborted
14269 || oldMachineState == MachineState_Teleported
14270 )
14271 && aMachineState == MachineState_Saved)
14272 {
14273 /* the saved state file was adopted */
14274 Assert(!mSSData->strStateFilePath.isEmpty());
14275 stsFlags |= SaveSTS_StateFilePath;
14276 }
14277
14278#ifdef VBOX_WITH_GUEST_PROPS
14279 if ( aMachineState == MachineState_PoweredOff
14280 || aMachineState == MachineState_Aborted
14281 || aMachineState == MachineState_Teleported)
14282 {
14283 /* Make sure any transient guest properties get removed from the
14284 * property store on shutdown. */
14285
14286 HWData::GuestPropertyMap::const_iterator it;
14287 BOOL fNeedsSaving = mData->mGuestPropertiesModified;
14288 if (!fNeedsSaving)
14289 for (it = mHWData->mGuestProperties.begin();
14290 it != mHWData->mGuestProperties.end(); ++it)
14291 if ( (it->second.mFlags & guestProp::TRANSIENT)
14292 || (it->second.mFlags & guestProp::TRANSRESET))
14293 {
14294 fNeedsSaving = true;
14295 break;
14296 }
14297 if (fNeedsSaving)
14298 {
14299 mData->mCurrentStateModified = TRUE;
14300 stsFlags |= SaveSTS_CurStateModified;
14301 }
14302 }
14303#endif
14304
14305 rc = i_saveStateSettings(stsFlags);
14306
14307 if ( ( oldMachineState != MachineState_PoweredOff
14308 && oldMachineState != MachineState_Aborted
14309 && oldMachineState != MachineState_Teleported
14310 )
14311 && ( aMachineState == MachineState_PoweredOff
14312 || aMachineState == MachineState_Aborted
14313 || aMachineState == MachineState_Teleported
14314 )
14315 )
14316 {
14317 /* we've been shut down for any reason */
14318 /* no special action so far */
14319 }
14320
14321 LogFlowThisFunc(("rc=%Rhrc [%s]\n", rc, Global::stringifyMachineState(mData->mMachineState) ));
14322 LogFlowThisFuncLeave();
14323 return rc;
14324}
14325
14326/**
14327 * Sends the current machine state value to the VM process.
14328 *
14329 * @note Locks this object for reading, then calls a client process.
14330 */
14331HRESULT SessionMachine::i_updateMachineStateOnClient()
14332{
14333 AutoCaller autoCaller(this);
14334 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
14335
14336 ComPtr<IInternalSessionControl> directControl;
14337 {
14338 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
14339 AssertReturn(!!mData, E_FAIL);
14340 directControl = mData->mSession.mDirectControl;
14341
14342 /* directControl may be already set to NULL here in #OnSessionEnd()
14343 * called too early by the direct session process while there is still
14344 * some operation (like deleting the snapshot) in progress. The client
14345 * process in this case is waiting inside Session::close() for the
14346 * "end session" process object to complete, while #uninit() called by
14347 * #checkForDeath() on the Watcher thread is waiting for the pending
14348 * operation to complete. For now, we accept this inconsistent behavior
14349 * and simply do nothing here. */
14350
14351 if (mData->mSession.mState == SessionState_Unlocking)
14352 return S_OK;
14353
14354 AssertReturn(!directControl.isNull(), E_FAIL);
14355 }
14356
14357 return directControl->UpdateMachineState(mData->mMachineState);
14358}
14359
14360HRESULT Machine::setRemoveSavedStateFile(BOOL aRemove)
14361{
14362 NOREF(aRemove);
14363 ReturnComNotImplemented();
14364}
14365
14366HRESULT Machine::updateState(MachineState_T aState)
14367{
14368 NOREF(aState);
14369 ReturnComNotImplemented();
14370}
14371
14372HRESULT Machine::beginPowerUp(const ComPtr<IProgress> &aProgress)
14373{
14374 NOREF(aProgress);
14375 ReturnComNotImplemented();
14376}
14377
14378HRESULT Machine::endPowerUp(LONG aResult)
14379{
14380 NOREF(aResult);
14381 ReturnComNotImplemented();
14382}
14383
14384HRESULT Machine::beginPoweringDown(ComPtr<IProgress> &aProgress)
14385{
14386 NOREF(aProgress);
14387 ReturnComNotImplemented();
14388}
14389
14390HRESULT Machine::endPoweringDown(LONG aResult,
14391 const com::Utf8Str &aErrMsg)
14392{
14393 NOREF(aResult);
14394 NOREF(aErrMsg);
14395 ReturnComNotImplemented();
14396}
14397
14398HRESULT Machine::runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
14399 BOOL *aMatched,
14400 ULONG *aMaskedInterfaces)
14401{
14402 NOREF(aDevice);
14403 NOREF(aMatched);
14404 NOREF(aMaskedInterfaces);
14405 ReturnComNotImplemented();
14406
14407}
14408
14409HRESULT Machine::captureUSBDevice(const com::Guid &aId)
14410{
14411 NOREF(aId);
14412 ReturnComNotImplemented();
14413}
14414
14415HRESULT Machine::detachUSBDevice(const com::Guid &aId,
14416 BOOL aDone)
14417{
14418 NOREF(aId);
14419 NOREF(aDone);
14420 ReturnComNotImplemented();
14421}
14422
14423HRESULT Machine::autoCaptureUSBDevices()
14424{
14425 ReturnComNotImplemented();
14426}
14427
14428HRESULT Machine::detachAllUSBDevices(BOOL aDone)
14429{
14430 NOREF(aDone);
14431 ReturnComNotImplemented();
14432}
14433
14434HRESULT Machine::onSessionEnd(const ComPtr<ISession> &aSession,
14435 ComPtr<IProgress> &aProgress)
14436{
14437 NOREF(aSession);
14438 NOREF(aProgress);
14439 ReturnComNotImplemented();
14440}
14441
14442HRESULT Machine::beginSavingState(ComPtr<IProgress> &aProgress,
14443 com::Utf8Str &aStateFilePath)
14444{
14445 NOREF(aProgress);
14446 NOREF(aStateFilePath);
14447 ReturnComNotImplemented();
14448}
14449
14450HRESULT Machine::endSavingState(LONG aResult,
14451 const com::Utf8Str &aErrMsg)
14452{
14453 NOREF(aResult);
14454 NOREF(aErrMsg);
14455 ReturnComNotImplemented();
14456}
14457
14458HRESULT Machine::adoptSavedState(const com::Utf8Str &aSavedStateFile)
14459{
14460 NOREF(aSavedStateFile);
14461 ReturnComNotImplemented();
14462}
14463
14464HRESULT Machine::beginTakingSnapshot(const ComPtr<IConsole> &aInitiator,
14465 const com::Utf8Str &aName,
14466 const com::Utf8Str &aDescription,
14467 const ComPtr<IProgress> &aConsoleProgress,
14468 BOOL aFTakingSnapshotOnline,
14469 com::Utf8Str &aStateFilePath)
14470{
14471 NOREF(aInitiator);
14472 NOREF(aName);
14473 NOREF(aDescription);
14474 NOREF(aConsoleProgress);
14475 NOREF(aFTakingSnapshotOnline);
14476 NOREF(aStateFilePath);
14477 ReturnComNotImplemented();
14478}
14479
14480HRESULT Machine::endTakingSnapshot(BOOL aSuccess)
14481{
14482 NOREF(aSuccess);
14483 ReturnComNotImplemented();
14484}
14485
14486HRESULT Machine::deleteSnapshot(const ComPtr<IConsole> &aInitiator,
14487 const com::Guid &aStartId,
14488 const com::Guid &aEndId,
14489 BOOL aDeleteAllChildren,
14490 MachineState_T *aMachineState,
14491 ComPtr<IProgress> &aProgress)
14492{
14493 NOREF(aInitiator);
14494 NOREF(aStartId);
14495 NOREF(aEndId);
14496 NOREF(aDeleteAllChildren);
14497 NOREF(aMachineState);
14498 NOREF(aProgress);
14499 ReturnComNotImplemented();
14500}
14501
14502HRESULT Machine::finishOnlineMergeMedium()
14503{
14504 ReturnComNotImplemented();
14505}
14506
14507HRESULT Machine::restoreSnapshot(const ComPtr<IConsole> &aInitiator,
14508 const ComPtr<ISnapshot> &aSnapshot,
14509 MachineState_T *aMachineState,
14510 ComPtr<IProgress> &aProgress)
14511{
14512 NOREF(aInitiator);
14513 NOREF(aSnapshot);
14514 NOREF(aMachineState);
14515 NOREF(aProgress);
14516 ReturnComNotImplemented();
14517}
14518
14519HRESULT Machine::pullGuestProperties(std::vector<com::Utf8Str> &aNames,
14520 std::vector<com::Utf8Str> &aValues,
14521 std::vector<LONG64> &aTimestamps,
14522 std::vector<com::Utf8Str> &aFlags)
14523{
14524 NOREF(aNames);
14525 NOREF(aValues);
14526 NOREF(aTimestamps);
14527 NOREF(aFlags);
14528 ReturnComNotImplemented();
14529}
14530
14531HRESULT Machine::pushGuestProperty(const com::Utf8Str &aName,
14532 const com::Utf8Str &aValue,
14533 LONG64 aTimestamp,
14534 const com::Utf8Str &aFlags)
14535{
14536 NOREF(aName);
14537 NOREF(aValue);
14538 NOREF(aTimestamp);
14539 NOREF(aFlags);
14540 ReturnComNotImplemented();
14541}
14542
14543HRESULT Machine::lockMedia()
14544{
14545 ReturnComNotImplemented();
14546}
14547
14548HRESULT Machine::unlockMedia()
14549{
14550 ReturnComNotImplemented();
14551}
14552
14553HRESULT Machine::ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
14554 ComPtr<IMediumAttachment> &aNewAttachment)
14555{
14556 NOREF(aAttachment);
14557 NOREF(aNewAttachment);
14558 ReturnComNotImplemented();
14559}
14560
14561HRESULT Machine::reportVmStatistics(ULONG aValidStats,
14562 ULONG aCpuUser,
14563 ULONG aCpuKernel,
14564 ULONG aCpuIdle,
14565 ULONG aMemTotal,
14566 ULONG aMemFree,
14567 ULONG aMemBalloon,
14568 ULONG aMemShared,
14569 ULONG aMemCache,
14570 ULONG aPagedTotal,
14571 ULONG aMemAllocTotal,
14572 ULONG aMemFreeTotal,
14573 ULONG aMemBalloonTotal,
14574 ULONG aMemSharedTotal,
14575 ULONG aVmNetRx,
14576 ULONG aVmNetTx)
14577{
14578 NOREF(aValidStats);
14579 NOREF(aCpuUser);
14580 NOREF(aCpuKernel);
14581 NOREF(aCpuIdle);
14582 NOREF(aMemTotal);
14583 NOREF(aMemFree);
14584 NOREF(aMemBalloon);
14585 NOREF(aMemShared);
14586 NOREF(aMemCache);
14587 NOREF(aPagedTotal);
14588 NOREF(aMemAllocTotal);
14589 NOREF(aMemFreeTotal);
14590 NOREF(aMemBalloonTotal);
14591 NOREF(aMemSharedTotal);
14592 NOREF(aVmNetRx);
14593 NOREF(aVmNetTx);
14594 ReturnComNotImplemented();
14595}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette