VirtualBox

source: vbox/trunk/src/VBox/Main/MachineImpl.cpp@ 33067

Last change on this file since 33067 was 33067, checked in by vboxsync, 14 years ago

Main: fix broken per-machine media registry for OVF-import-from-vbox:Machine case (trunk regression)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 381.1 KB
Line 
1/* $Id: MachineImpl.cpp 33067 2010-10-12 13:39:13Z vboxsync $ */
2/** @file
3 * Implementation of IMachine in VBoxSVC.
4 */
5
6/*
7 * Copyright (C) 2006-2010 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#ifdef VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
27# include <errno.h>
28# include <sys/types.h>
29# include <sys/stat.h>
30# include <sys/ipc.h>
31# include <sys/sem.h>
32#endif
33
34#include "Logging.h"
35#include "VirtualBoxImpl.h"
36#include "MachineImpl.h"
37#include "ProgressImpl.h"
38#include "ProgressProxyImpl.h"
39#include "MediumAttachmentImpl.h"
40#include "MediumImpl.h"
41#include "MediumLock.h"
42#include "USBControllerImpl.h"
43#include "HostImpl.h"
44#include "SharedFolderImpl.h"
45#include "GuestOSTypeImpl.h"
46#include "VirtualBoxErrorInfoImpl.h"
47#include "GuestImpl.h"
48#include "StorageControllerImpl.h"
49#include "DisplayImpl.h"
50#include "DisplayUtils.h"
51
52#ifdef VBOX_WITH_USB
53# include "USBProxyService.h"
54#endif
55
56#include "AutoCaller.h"
57#include "Performance.h"
58
59#include <iprt/asm.h>
60#include <iprt/path.h>
61#include <iprt/dir.h>
62#include <iprt/env.h>
63#include <iprt/lockvalidator.h>
64#include <iprt/process.h>
65#include <iprt/cpp/utils.h>
66#include <iprt/cpp/xml.h> /* xml::XmlFileWriter::s_psz*Suff. */
67#include <iprt/string.h>
68
69#include <VBox/com/array.h>
70
71#include <VBox/err.h>
72#include <VBox/param.h>
73#include <VBox/settings.h>
74#include <VBox/ssm.h>
75
76#ifdef VBOX_WITH_GUEST_PROPS
77# include <VBox/HostServices/GuestPropertySvc.h>
78# include <VBox/com/array.h>
79#endif
80
81#include "VBox/com/MultiResult.h"
82
83#include <algorithm>
84
85#include <typeinfo>
86
87#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
88# define HOSTSUFF_EXE ".exe"
89#else /* !RT_OS_WINDOWS */
90# define HOSTSUFF_EXE ""
91#endif /* !RT_OS_WINDOWS */
92
93// defines / prototypes
94/////////////////////////////////////////////////////////////////////////////
95
96/////////////////////////////////////////////////////////////////////////////
97// Machine::Data structure
98/////////////////////////////////////////////////////////////////////////////
99
100Machine::Data::Data()
101{
102 mRegistered = FALSE;
103 pMachineConfigFile = NULL;
104 flModifications = 0;
105 mAccessible = FALSE;
106 /* mUuid is initialized in Machine::init() */
107
108 mMachineState = MachineState_PoweredOff;
109 RTTimeNow(&mLastStateChange);
110
111 mMachineStateDeps = 0;
112 mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
113 mMachineStateChangePending = 0;
114
115 mCurrentStateModified = TRUE;
116 mGuestPropertiesModified = FALSE;
117
118 mSession.mPid = NIL_RTPROCESS;
119 mSession.mState = SessionState_Unlocked;
120}
121
122Machine::Data::~Data()
123{
124 if (mMachineStateDepsSem != NIL_RTSEMEVENTMULTI)
125 {
126 RTSemEventMultiDestroy(mMachineStateDepsSem);
127 mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
128 }
129 if (pMachineConfigFile)
130 {
131 delete pMachineConfigFile;
132 pMachineConfigFile = NULL;
133 }
134}
135
136/////////////////////////////////////////////////////////////////////////////
137// Machine::HWData structure
138/////////////////////////////////////////////////////////////////////////////
139
140Machine::HWData::HWData()
141{
142 /* default values for a newly created machine */
143 mHWVersion = "2"; /** @todo get the default from the schema if that is possible. */
144 mMemorySize = 128;
145 mCPUCount = 1;
146 mCPUHotPlugEnabled = false;
147 mMemoryBalloonSize = 0;
148 mPageFusionEnabled = false;
149 mVRAMSize = 8;
150 mAccelerate3DEnabled = false;
151 mAccelerate2DVideoEnabled = false;
152 mMonitorCount = 1;
153 mHWVirtExEnabled = true;
154 mHWVirtExNestedPagingEnabled = true;
155#if HC_ARCH_BITS == 64
156 /* Default value decision pending. */
157 mHWVirtExLargePagesEnabled = false;
158#else
159 /* Not supported on 32 bits hosts. */
160 mHWVirtExLargePagesEnabled = false;
161#endif
162 mHWVirtExVPIDEnabled = true;
163 mHWVirtExForceEnabled = false;
164#if defined(RT_OS_DARWIN) || defined(RT_OS_WINDOWS)
165 mHWVirtExExclusive = false;
166#else
167 mHWVirtExExclusive = true;
168#endif
169#if HC_ARCH_BITS == 64 || defined(RT_OS_WINDOWS) || defined(RT_OS_DARWIN)
170 mPAEEnabled = true;
171#else
172 mPAEEnabled = false;
173#endif
174 mSyntheticCpu = false;
175 mHpetEnabled = false;
176
177 /* default boot order: floppy - DVD - HDD */
178 mBootOrder[0] = DeviceType_Floppy;
179 mBootOrder[1] = DeviceType_DVD;
180 mBootOrder[2] = DeviceType_HardDisk;
181 for (size_t i = 3; i < RT_ELEMENTS(mBootOrder); ++i)
182 mBootOrder[i] = DeviceType_Null;
183
184 mClipboardMode = ClipboardMode_Bidirectional;
185 mGuestPropertyNotificationPatterns = "";
186
187 mFirmwareType = FirmwareType_BIOS;
188 mKeyboardHidType = KeyboardHidType_PS2Keyboard;
189 mPointingHidType = PointingHidType_PS2Mouse;
190 mChipsetType = ChipsetType_PIIX3;
191
192 for (size_t i = 0; i < RT_ELEMENTS(mCPUAttached); i++)
193 mCPUAttached[i] = false;
194
195 mIoCacheEnabled = true;
196 mIoCacheSize = 5; /* 5MB */
197
198 /* Maximum CPU execution cap by default. */
199 mCpuExecutionCap = 100;
200}
201
202Machine::HWData::~HWData()
203{
204}
205
206/////////////////////////////////////////////////////////////////////////////
207// Machine::HDData structure
208/////////////////////////////////////////////////////////////////////////////
209
210Machine::MediaData::MediaData()
211{
212}
213
214Machine::MediaData::~MediaData()
215{
216}
217
218/////////////////////////////////////////////////////////////////////////////
219// Machine class
220/////////////////////////////////////////////////////////////////////////////
221
222// constructor / destructor
223/////////////////////////////////////////////////////////////////////////////
224
225Machine::Machine()
226 : mGuestHAL(NULL),
227 mPeer(NULL),
228 mParent(NULL)
229{}
230
231Machine::~Machine()
232{}
233
234HRESULT Machine::FinalConstruct()
235{
236 LogFlowThisFunc(("\n"));
237 return S_OK;
238}
239
240void Machine::FinalRelease()
241{
242 LogFlowThisFunc(("\n"));
243 uninit();
244}
245
246/**
247 * Initializes a new machine instance; this init() variant creates a new, empty machine.
248 * This gets called from VirtualBox::CreateMachine() or VirtualBox::CreateLegacyMachine().
249 *
250 * @param aParent Associated parent object
251 * @param strConfigFile Local file system path to the VM settings file (can
252 * be relative to the VirtualBox config directory).
253 * @param strName name for the machine
254 * @param aId UUID for the new machine.
255 * @param aOsType Optional OS Type of this machine.
256 * @param aOverride |TRUE| to override VM config file existence checks.
257 * |FALSE| refuses to overwrite existing VM configs.
258 * @param aNameSync |TRUE| to automatically sync settings dir and file
259 * name with the machine name. |FALSE| is used for legacy
260 * machines where the file name is specified by the
261 * user and should never change.
262 *
263 * @return Success indicator. if not S_OK, the machine object is invalid
264 */
265HRESULT Machine::init(VirtualBox *aParent,
266 const Utf8Str &strConfigFile,
267 const Utf8Str &strName,
268 const Guid &aId,
269 GuestOSType *aOsType /* = NULL */,
270 BOOL aOverride /* = FALSE */,
271 BOOL aNameSync /* = TRUE */)
272{
273 LogFlowThisFuncEnter();
274 LogFlowThisFunc(("(Init_New) aConfigFile='%s'\n", strConfigFile.c_str()));
275
276 /* Enclose the state transition NotReady->InInit->Ready */
277 AutoInitSpan autoInitSpan(this);
278 AssertReturn(autoInitSpan.isOk(), E_FAIL);
279
280 HRESULT rc = initImpl(aParent, strConfigFile);
281 if (FAILED(rc)) return rc;
282
283 rc = tryCreateMachineConfigFile(aOverride);
284 if (FAILED(rc)) return rc;
285
286 if (SUCCEEDED(rc))
287 {
288 // create an empty machine config
289 mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
290
291 rc = initDataAndChildObjects();
292 }
293
294 if (SUCCEEDED(rc))
295 {
296 // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
297 mData->mAccessible = TRUE;
298
299 unconst(mData->mUuid) = aId;
300
301 mUserData->s.strName = strName;
302 mUserData->s.fNameSync = !!aNameSync;
303
304 /* initialize the default snapshots folder
305 * (note: depends on the name value set above!) */
306 rc = COMSETTER(SnapshotFolder)(NULL);
307 AssertComRC(rc);
308
309 if (aOsType)
310 {
311 /* Store OS type */
312 mUserData->s.strOsType = aOsType->id();
313
314 /* Apply BIOS defaults */
315 mBIOSSettings->applyDefaults(aOsType);
316
317 /* Apply network adapters defaults */
318 for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); ++slot)
319 mNetworkAdapters[slot]->applyDefaults(aOsType);
320
321 /* Apply serial port defaults */
322 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
323 mSerialPorts[slot]->applyDefaults(aOsType);
324 }
325
326 /* commit all changes made during the initialization */
327 commit();
328 }
329
330 /* Confirm a successful initialization when it's the case */
331 if (SUCCEEDED(rc))
332 {
333 if (mData->mAccessible)
334 autoInitSpan.setSucceeded();
335 else
336 autoInitSpan.setLimited();
337 }
338
339 LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool, rc=%08X\n",
340 !!mUserData ? mUserData->s.strName.c_str() : "NULL",
341 mData->mRegistered,
342 mData->mAccessible,
343 rc));
344
345 LogFlowThisFuncLeave();
346
347 return rc;
348}
349
350/**
351 * Initializes a new instance with data from machine XML (formerly Init_Registered).
352 * Gets called in two modes:
353 *
354 * -- from VirtualBox::initMachines() during VirtualBox startup; in that case, the
355 * UUID is specified and we mark the machine as "registered";
356 *
357 * -- from the public VirtualBox::OpenMachine() API, in which case the UUID is NULL
358 * and the machine remains unregistered until RegisterMachine() is called.
359 *
360 * @param aParent Associated parent object
361 * @param aConfigFile Local file system path to the VM settings file (can
362 * be relative to the VirtualBox config directory).
363 * @param aId UUID of the machine or NULL (see above).
364 *
365 * @return Success indicator. if not S_OK, the machine object is invalid
366 */
367HRESULT Machine::init(VirtualBox *aParent,
368 const Utf8Str &strConfigFile,
369 const Guid *aId)
370{
371 LogFlowThisFuncEnter();
372 LogFlowThisFunc(("(Init_Registered) aConfigFile='%s\n", strConfigFile.c_str()));
373
374 /* Enclose the state transition NotReady->InInit->Ready */
375 AutoInitSpan autoInitSpan(this);
376 AssertReturn(autoInitSpan.isOk(), E_FAIL);
377
378 HRESULT rc = initImpl(aParent, strConfigFile);
379 if (FAILED(rc)) return rc;
380
381 if (aId)
382 {
383 // loading a registered VM:
384 unconst(mData->mUuid) = *aId;
385 mData->mRegistered = TRUE;
386 // now load the settings from XML:
387 rc = registeredInit();
388 // this calls initDataAndChildObjects() and loadSettings()
389 }
390 else
391 {
392 // opening an unregistered VM (VirtualBox::OpenMachine()):
393 rc = initDataAndChildObjects();
394
395 if (SUCCEEDED(rc))
396 {
397 // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
398 mData->mAccessible = TRUE;
399
400 try
401 {
402 // load and parse machine XML; this will throw on XML or logic errors
403 mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
404
405 // use UUID from machine config
406 unconst(mData->mUuid) = mData->pMachineConfigFile->uuid;
407
408 rc = loadMachineDataFromSettings(*mData->pMachineConfigFile,
409 NULL /* puuidRegistry */);
410 if (FAILED(rc)) throw rc;
411
412 commit();
413 }
414 catch (HRESULT err)
415 {
416 /* we assume that error info is set by the thrower */
417 rc = err;
418 }
419 catch (...)
420 {
421 rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
422 }
423 }
424 }
425
426 /* Confirm a successful initialization when it's the case */
427 if (SUCCEEDED(rc))
428 {
429 if (mData->mAccessible)
430 autoInitSpan.setSucceeded();
431 else
432 {
433 autoInitSpan.setLimited();
434
435 // uninit media from this machine's media registry, or else
436 // reloading the settings will fail
437 mParent->unregisterMachineMedia(getId());
438 }
439 }
440
441 LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
442 "rc=%08X\n",
443 !!mUserData ? mUserData->s.strName.c_str() : "NULL",
444 mData->mRegistered, mData->mAccessible, rc));
445
446 LogFlowThisFuncLeave();
447
448 return rc;
449}
450
451/**
452 * Initializes a new instance from a machine config that is already in memory
453 * (import OVF case). Since we are importing, the UUID in the machine
454 * config is ignored and we always generate a fresh one.
455 *
456 * @param strName Name for the new machine; this overrides what is specified in config and is used
457 * for the settings file as well.
458 * @param config Machine configuration loaded and parsed from XML.
459 *
460 * @return Success indicator. if not S_OK, the machine object is invalid
461 */
462HRESULT Machine::init(VirtualBox *aParent,
463 const Utf8Str &strName,
464 const settings::MachineConfigFile &config)
465{
466 LogFlowThisFuncEnter();
467
468 /* Enclose the state transition NotReady->InInit->Ready */
469 AutoInitSpan autoInitSpan(this);
470 AssertReturn(autoInitSpan.isOk(), E_FAIL);
471
472 Utf8Str strConfigFile;
473 aParent->getDefaultMachineFolder(strConfigFile);
474 strConfigFile.append(RTPATH_DELIMITER);
475 strConfigFile.append(strName);
476 strConfigFile.append(RTPATH_DELIMITER);
477 strConfigFile.append(strName);
478 strConfigFile.append(".vbox");
479
480 HRESULT rc = initImpl(aParent, strConfigFile);
481 if (FAILED(rc)) return rc;
482
483 rc = tryCreateMachineConfigFile(FALSE /* aOverride */);
484 if (FAILED(rc)) return rc;
485
486 rc = initDataAndChildObjects();
487
488 if (SUCCEEDED(rc))
489 {
490 // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
491 mData->mAccessible = TRUE;
492
493 // create empty machine config for instance data
494 mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
495
496 // generate fresh UUID, ignore machine config
497 unconst(mData->mUuid).create();
498
499 rc = loadMachineDataFromSettings(config,
500 &mData->mUuid); // puuidRegistry: initialize media with this registry ID
501
502 // override VM name as well, it may be different
503 mUserData->s.strName = strName;
504
505 /* commit all changes made during the initialization */
506 if (SUCCEEDED(rc))
507 commit();
508 }
509
510 /* Confirm a successful initialization when it's the case */
511 if (SUCCEEDED(rc))
512 {
513 if (mData->mAccessible)
514 autoInitSpan.setSucceeded();
515 else
516 {
517 autoInitSpan.setLimited();
518
519 // uninit media from this machine's media registry, or else
520 // reloading the settings will fail
521 mParent->unregisterMachineMedia(getId());
522 }
523 }
524
525 LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
526 "rc=%08X\n",
527 !!mUserData ? mUserData->s.strName.c_str() : "NULL",
528 mData->mRegistered, mData->mAccessible, rc));
529
530 LogFlowThisFuncLeave();
531
532 return rc;
533}
534
535/**
536 * Shared code between the various init() implementations.
537 * @param aParent
538 * @return
539 */
540HRESULT Machine::initImpl(VirtualBox *aParent,
541 const Utf8Str &strConfigFile)
542{
543 LogFlowThisFuncEnter();
544
545 AssertReturn(aParent, E_INVALIDARG);
546 AssertReturn(!strConfigFile.isEmpty(), E_INVALIDARG);
547
548 HRESULT rc = S_OK;
549
550 /* share the parent weakly */
551 unconst(mParent) = aParent;
552
553 /* allocate the essential machine data structure (the rest will be
554 * allocated later by initDataAndChildObjects() */
555 mData.allocate();
556
557 /* memorize the config file name (as provided) */
558 mData->m_strConfigFile = strConfigFile;
559
560 /* get the full file name */
561 int vrc1 = mParent->calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
562 if (RT_FAILURE(vrc1))
563 return setError(VBOX_E_FILE_ERROR,
564 tr("Invalid machine settings file name '%s' (%Rrc)"),
565 strConfigFile.c_str(),
566 vrc1);
567
568 LogFlowThisFuncLeave();
569
570 return rc;
571}
572
573/**
574 * Tries to create a machine settings file in the path stored in the machine
575 * instance data. Used when a new machine is created to fail gracefully if
576 * the settings file could not be written (e.g. because machine dir is read-only).
577 * @return
578 */
579HRESULT Machine::tryCreateMachineConfigFile(BOOL aOverride)
580{
581 HRESULT rc = S_OK;
582
583 // when we create a new machine, we must be able to create the settings file
584 RTFILE f = NIL_RTFILE;
585 int vrc = RTFileOpen(&f, mData->m_strConfigFileFull.c_str(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
586 if ( RT_SUCCESS(vrc)
587 || vrc == VERR_SHARING_VIOLATION
588 )
589 {
590 if (RT_SUCCESS(vrc))
591 RTFileClose(f);
592 if (!aOverride)
593 rc = setError(VBOX_E_FILE_ERROR,
594 tr("Machine settings file '%s' already exists"),
595 mData->m_strConfigFileFull.c_str());
596 else
597 {
598 /* try to delete the config file, as otherwise the creation
599 * of a new settings file will fail. */
600 int vrc2 = RTFileDelete(mData->m_strConfigFileFull.c_str());
601 if (RT_FAILURE(vrc2))
602 rc = setError(VBOX_E_FILE_ERROR,
603 tr("Could not delete the existing settings file '%s' (%Rrc)"),
604 mData->m_strConfigFileFull.c_str(), vrc2);
605 }
606 }
607 else if ( vrc != VERR_FILE_NOT_FOUND
608 && vrc != VERR_PATH_NOT_FOUND
609 )
610 rc = setError(VBOX_E_FILE_ERROR,
611 tr("Invalid machine settings file name '%s' (%Rrc)"),
612 mData->m_strConfigFileFull.c_str(),
613 vrc);
614 return rc;
615}
616
617/**
618 * Initializes the registered machine by loading the settings file.
619 * This method is separated from #init() in order to make it possible to
620 * retry the operation after VirtualBox startup instead of refusing to
621 * startup the whole VirtualBox server in case if the settings file of some
622 * registered VM is invalid or inaccessible.
623 *
624 * @note Must be always called from this object's write lock
625 * (unless called from #init() that doesn't need any locking).
626 * @note Locks the mUSBController method for writing.
627 * @note Subclasses must not call this method.
628 */
629HRESULT Machine::registeredInit()
630{
631 AssertReturn(!isSessionMachine(), E_FAIL);
632 AssertReturn(!isSnapshotMachine(), E_FAIL);
633 AssertReturn(!mData->mUuid.isEmpty(), E_FAIL);
634 AssertReturn(!mData->mAccessible, E_FAIL);
635
636 HRESULT rc = initDataAndChildObjects();
637
638 if (SUCCEEDED(rc))
639 {
640 /* Temporarily reset the registered flag in order to let setters
641 * potentially called from loadSettings() succeed (isMutable() used in
642 * all setters will return FALSE for a Machine instance if mRegistered
643 * is TRUE). */
644 mData->mRegistered = FALSE;
645
646 try
647 {
648 // load and parse machine XML; this will throw on XML or logic errors
649 mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
650
651 if (mData->mUuid != mData->pMachineConfigFile->uuid)
652 throw setError(E_FAIL,
653 tr("Machine UUID {%RTuuid} in '%s' doesn't match its UUID {%s} in the registry file '%s'"),
654 mData->pMachineConfigFile->uuid.raw(),
655 mData->m_strConfigFileFull.c_str(),
656 mData->mUuid.toString().c_str(),
657 mParent->settingsFilePath().c_str());
658
659 rc = loadMachineDataFromSettings(*mData->pMachineConfigFile,
660 NULL /* const Guid *puuidRegistry */);
661 if (FAILED(rc)) throw rc;
662 }
663 catch (HRESULT err)
664 {
665 /* we assume that error info is set by the thrower */
666 rc = err;
667 }
668 catch (...)
669 {
670 rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
671 }
672
673 /* Restore the registered flag (even on failure) */
674 mData->mRegistered = TRUE;
675 }
676
677 if (SUCCEEDED(rc))
678 {
679 /* Set mAccessible to TRUE only if we successfully locked and loaded
680 * the settings file */
681 mData->mAccessible = TRUE;
682
683 /* commit all changes made during loading the settings file */
684 commit(); // @todo r=dj why do we need a commit during init?!? this is very expensive
685 }
686 else
687 {
688 /* If the machine is registered, then, instead of returning a
689 * failure, we mark it as inaccessible and set the result to
690 * success to give it a try later */
691
692 /* fetch the current error info */
693 mData->mAccessError = com::ErrorInfo();
694 LogWarning(("Machine {%RTuuid} is inaccessible! [%ls]\n",
695 mData->mUuid.raw(),
696 mData->mAccessError.getText().raw()));
697
698 /* rollback all changes */
699 rollback(false /* aNotify */);
700
701 // uninit media from this machine's media registry, or else
702 // reloading the settings will fail
703 mParent->unregisterMachineMedia(getId());
704
705 /* uninitialize the common part to make sure all data is reset to
706 * default (null) values */
707 uninitDataAndChildObjects();
708
709 rc = S_OK;
710 }
711
712 return rc;
713}
714
715/**
716 * Uninitializes the instance.
717 * Called either from FinalRelease() or by the parent when it gets destroyed.
718 *
719 * @note The caller of this method must make sure that this object
720 * a) doesn't have active callers on the current thread and b) is not locked
721 * by the current thread; otherwise uninit() will hang either a) due to
722 * AutoUninitSpan waiting for a number of calls to drop to zero or b) due to
723 * a dead-lock caused by this thread waiting for all callers on the other
724 * threads are done but preventing them from doing so by holding a lock.
725 */
726void Machine::uninit()
727{
728 LogFlowThisFuncEnter();
729
730 Assert(!isWriteLockOnCurrentThread());
731
732 /* Enclose the state transition Ready->InUninit->NotReady */
733 AutoUninitSpan autoUninitSpan(this);
734 if (autoUninitSpan.uninitDone())
735 return;
736
737 Assert(!isSnapshotMachine());
738 Assert(!isSessionMachine());
739 Assert(!!mData);
740
741 LogFlowThisFunc(("initFailed()=%d\n", autoUninitSpan.initFailed()));
742 LogFlowThisFunc(("mRegistered=%d\n", mData->mRegistered));
743
744 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
745
746 if (!mData->mSession.mMachine.isNull())
747 {
748 /* Theoretically, this can only happen if the VirtualBox server has been
749 * terminated while there were clients running that owned open direct
750 * sessions. Since in this case we are definitely called by
751 * VirtualBox::uninit(), we may be sure that SessionMachine::uninit()
752 * won't happen on the client watcher thread (because it does
753 * VirtualBox::addCaller() for the duration of the
754 * SessionMachine::checkForDeath() call, so that VirtualBox::uninit()
755 * cannot happen until the VirtualBox caller is released). This is
756 * important, because SessionMachine::uninit() cannot correctly operate
757 * after we return from this method (it expects the Machine instance is
758 * still valid). We'll call it ourselves below.
759 */
760 LogWarningThisFunc(("Session machine is not NULL (%p), the direct session is still open!\n",
761 (SessionMachine*)mData->mSession.mMachine));
762
763 if (Global::IsOnlineOrTransient(mData->mMachineState))
764 {
765 LogWarningThisFunc(("Setting state to Aborted!\n"));
766 /* set machine state using SessionMachine reimplementation */
767 static_cast<Machine*>(mData->mSession.mMachine)->setMachineState(MachineState_Aborted);
768 }
769
770 /*
771 * Uninitialize SessionMachine using public uninit() to indicate
772 * an unexpected uninitialization.
773 */
774 mData->mSession.mMachine->uninit();
775 /* SessionMachine::uninit() must set mSession.mMachine to null */
776 Assert(mData->mSession.mMachine.isNull());
777 }
778
779 // uninit media from this machine's media registry, if they're still there
780 mParent->unregisterMachineMedia(getId());
781
782 /* the lock is no more necessary (SessionMachine is uninitialized) */
783 alock.leave();
784
785 // has machine been modified?
786 if (mData->flModifications)
787 {
788 LogWarningThisFunc(("Discarding unsaved settings changes!\n"));
789 rollback(false /* aNotify */);
790 }
791
792 if (mData->mAccessible)
793 uninitDataAndChildObjects();
794
795 /* free the essential data structure last */
796 mData.free();
797
798 LogFlowThisFuncLeave();
799}
800
801// IMachine properties
802/////////////////////////////////////////////////////////////////////////////
803
804STDMETHODIMP Machine::COMGETTER(Parent)(IVirtualBox **aParent)
805{
806 CheckComArgOutPointerValid(aParent);
807
808 AutoLimitedCaller autoCaller(this);
809 if (FAILED(autoCaller.rc())) return autoCaller.rc();
810
811 /* mParent is constant during life time, no need to lock */
812 ComObjPtr<VirtualBox> pVirtualBox(mParent);
813 pVirtualBox.queryInterfaceTo(aParent);
814
815 return S_OK;
816}
817
818STDMETHODIMP Machine::COMGETTER(Accessible)(BOOL *aAccessible)
819{
820 CheckComArgOutPointerValid(aAccessible);
821
822 AutoLimitedCaller autoCaller(this);
823 if (FAILED(autoCaller.rc())) return autoCaller.rc();
824
825 LogFlowThisFunc(("ENTER\n"));
826
827 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
828
829 HRESULT rc = S_OK;
830
831 if (!mData->mAccessible)
832 {
833 /* try to initialize the VM once more if not accessible */
834
835 AutoReinitSpan autoReinitSpan(this);
836 AssertReturn(autoReinitSpan.isOk(), E_FAIL);
837
838#ifdef DEBUG
839 LogFlowThisFunc(("Dumping media backreferences\n"));
840 mParent->dumpAllBackRefs();
841#endif
842
843 if (mData->pMachineConfigFile)
844 {
845 // reset the XML file to force loadSettings() (called from registeredInit())
846 // to parse it again; the file might have changed
847 delete mData->pMachineConfigFile;
848 mData->pMachineConfigFile = NULL;
849 }
850
851 rc = registeredInit();
852
853 if (SUCCEEDED(rc) && mData->mAccessible)
854 {
855 autoReinitSpan.setSucceeded();
856
857 /* make sure interesting parties will notice the accessibility
858 * state change */
859 mParent->onMachineStateChange(mData->mUuid, mData->mMachineState);
860 mParent->onMachineDataChange(mData->mUuid);
861 }
862 }
863
864 if (SUCCEEDED(rc))
865 *aAccessible = mData->mAccessible;
866
867 LogFlowThisFuncLeave();
868
869 return rc;
870}
871
872STDMETHODIMP Machine::COMGETTER(AccessError)(IVirtualBoxErrorInfo **aAccessError)
873{
874 CheckComArgOutPointerValid(aAccessError);
875
876 AutoLimitedCaller autoCaller(this);
877 if (FAILED(autoCaller.rc())) return autoCaller.rc();
878
879 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
880
881 if (mData->mAccessible || !mData->mAccessError.isBasicAvailable())
882 {
883 /* return shortly */
884 aAccessError = NULL;
885 return S_OK;
886 }
887
888 HRESULT rc = S_OK;
889
890 ComObjPtr<VirtualBoxErrorInfo> errorInfo;
891 rc = errorInfo.createObject();
892 if (SUCCEEDED(rc))
893 {
894 errorInfo->init(mData->mAccessError.getResultCode(),
895 mData->mAccessError.getInterfaceID().ref(),
896 Utf8Str(mData->mAccessError.getComponent()).c_str(),
897 Utf8Str(mData->mAccessError.getText()));
898 rc = errorInfo.queryInterfaceTo(aAccessError);
899 }
900
901 return rc;
902}
903
904STDMETHODIMP Machine::COMGETTER(Name)(BSTR *aName)
905{
906 CheckComArgOutPointerValid(aName);
907
908 AutoCaller autoCaller(this);
909 if (FAILED(autoCaller.rc())) return autoCaller.rc();
910
911 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
912
913 mUserData->s.strName.cloneTo(aName);
914
915 return S_OK;
916}
917
918STDMETHODIMP Machine::COMSETTER(Name)(IN_BSTR aName)
919{
920 CheckComArgStrNotEmptyOrNull(aName);
921
922 AutoCaller autoCaller(this);
923 if (FAILED(autoCaller.rc())) return autoCaller.rc();
924
925 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
926
927 HRESULT rc = checkStateDependency(MutableStateDep);
928 if (FAILED(rc)) return rc;
929
930 setModified(IsModified_MachineData);
931 mUserData.backup();
932 mUserData->s.strName = aName;
933
934 return S_OK;
935}
936
937STDMETHODIMP Machine::COMGETTER(Description)(BSTR *aDescription)
938{
939 CheckComArgOutPointerValid(aDescription);
940
941 AutoCaller autoCaller(this);
942 if (FAILED(autoCaller.rc())) return autoCaller.rc();
943
944 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
945
946 mUserData->s.strDescription.cloneTo(aDescription);
947
948 return S_OK;
949}
950
951STDMETHODIMP Machine::COMSETTER(Description)(IN_BSTR aDescription)
952{
953 AutoCaller autoCaller(this);
954 if (FAILED(autoCaller.rc())) return autoCaller.rc();
955
956 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
957
958 HRESULT rc = checkStateDependency(MutableStateDep);
959 if (FAILED(rc)) return rc;
960
961 setModified(IsModified_MachineData);
962 mUserData.backup();
963 mUserData->s.strDescription = aDescription;
964
965 return S_OK;
966}
967
968STDMETHODIMP Machine::COMGETTER(Id)(BSTR *aId)
969{
970 CheckComArgOutPointerValid(aId);
971
972 AutoLimitedCaller autoCaller(this);
973 if (FAILED(autoCaller.rc())) return autoCaller.rc();
974
975 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
976
977 mData->mUuid.toUtf16().cloneTo(aId);
978
979 return S_OK;
980}
981
982STDMETHODIMP Machine::COMGETTER(OSTypeId)(BSTR *aOSTypeId)
983{
984 CheckComArgOutPointerValid(aOSTypeId);
985
986 AutoCaller autoCaller(this);
987 if (FAILED(autoCaller.rc())) return autoCaller.rc();
988
989 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
990
991 mUserData->s.strOsType.cloneTo(aOSTypeId);
992
993 return S_OK;
994}
995
996STDMETHODIMP Machine::COMSETTER(OSTypeId)(IN_BSTR aOSTypeId)
997{
998 CheckComArgStrNotEmptyOrNull(aOSTypeId);
999
1000 AutoCaller autoCaller(this);
1001 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1002
1003 /* look up the object by Id to check it is valid */
1004 ComPtr<IGuestOSType> guestOSType;
1005 HRESULT rc = mParent->GetGuestOSType(aOSTypeId, guestOSType.asOutParam());
1006 if (FAILED(rc)) return rc;
1007
1008 /* when setting, always use the "etalon" value for consistency -- lookup
1009 * by ID is case-insensitive and the input value may have different case */
1010 Bstr osTypeId;
1011 rc = guestOSType->COMGETTER(Id)(osTypeId.asOutParam());
1012 if (FAILED(rc)) return rc;
1013
1014 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1015
1016 rc = checkStateDependency(MutableStateDep);
1017 if (FAILED(rc)) return rc;
1018
1019 setModified(IsModified_MachineData);
1020 mUserData.backup();
1021 mUserData->s.strOsType = osTypeId;
1022
1023 return S_OK;
1024}
1025
1026
1027STDMETHODIMP Machine::COMGETTER(FirmwareType)(FirmwareType_T *aFirmwareType)
1028{
1029 CheckComArgOutPointerValid(aFirmwareType);
1030
1031 AutoCaller autoCaller(this);
1032 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1033
1034 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1035
1036 *aFirmwareType = mHWData->mFirmwareType;
1037
1038 return S_OK;
1039}
1040
1041STDMETHODIMP Machine::COMSETTER(FirmwareType)(FirmwareType_T aFirmwareType)
1042{
1043 AutoCaller autoCaller(this);
1044 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1045 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1046
1047 int rc = checkStateDependency(MutableStateDep);
1048 if (FAILED(rc)) return rc;
1049
1050 setModified(IsModified_MachineData);
1051 mHWData.backup();
1052 mHWData->mFirmwareType = aFirmwareType;
1053
1054 return S_OK;
1055}
1056
1057STDMETHODIMP Machine::COMGETTER(KeyboardHidType)(KeyboardHidType_T *aKeyboardHidType)
1058{
1059 CheckComArgOutPointerValid(aKeyboardHidType);
1060
1061 AutoCaller autoCaller(this);
1062 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1063
1064 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1065
1066 *aKeyboardHidType = mHWData->mKeyboardHidType;
1067
1068 return S_OK;
1069}
1070
1071STDMETHODIMP Machine::COMSETTER(KeyboardHidType)(KeyboardHidType_T aKeyboardHidType)
1072{
1073 AutoCaller autoCaller(this);
1074 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1075 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1076
1077 int rc = checkStateDependency(MutableStateDep);
1078 if (FAILED(rc)) return rc;
1079
1080 setModified(IsModified_MachineData);
1081 mHWData.backup();
1082 mHWData->mKeyboardHidType = aKeyboardHidType;
1083
1084 return S_OK;
1085}
1086
1087STDMETHODIMP Machine::COMGETTER(PointingHidType)(PointingHidType_T *aPointingHidType)
1088{
1089 CheckComArgOutPointerValid(aPointingHidType);
1090
1091 AutoCaller autoCaller(this);
1092 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1093
1094 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1095
1096 *aPointingHidType = mHWData->mPointingHidType;
1097
1098 return S_OK;
1099}
1100
1101STDMETHODIMP Machine::COMSETTER(PointingHidType)(PointingHidType_T aPointingHidType)
1102{
1103 AutoCaller autoCaller(this);
1104 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1105 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1106
1107 int rc = checkStateDependency(MutableStateDep);
1108 if (FAILED(rc)) return rc;
1109
1110 setModified(IsModified_MachineData);
1111 mHWData.backup();
1112 mHWData->mPointingHidType = aPointingHidType;
1113
1114 return S_OK;
1115}
1116
1117STDMETHODIMP Machine::COMGETTER(ChipsetType)(ChipsetType_T *aChipsetType)
1118{
1119 CheckComArgOutPointerValid(aChipsetType);
1120
1121 AutoCaller autoCaller(this);
1122 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1123
1124 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1125
1126 *aChipsetType = mHWData->mChipsetType;
1127
1128 return S_OK;
1129}
1130
1131STDMETHODIMP Machine::COMSETTER(ChipsetType)(ChipsetType_T aChipsetType)
1132{
1133 AutoCaller autoCaller(this);
1134 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1135 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1136
1137 int rc = checkStateDependency(MutableStateDep);
1138 if (FAILED(rc)) return rc;
1139
1140 setModified(IsModified_MachineData);
1141 mHWData.backup();
1142 mHWData->mChipsetType = aChipsetType;
1143
1144 return S_OK;
1145}
1146
1147STDMETHODIMP Machine::COMGETTER(HardwareVersion)(BSTR *aHWVersion)
1148{
1149 if (!aHWVersion)
1150 return E_POINTER;
1151
1152 AutoCaller autoCaller(this);
1153 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1154
1155 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1156
1157 mHWData->mHWVersion.cloneTo(aHWVersion);
1158
1159 return S_OK;
1160}
1161
1162STDMETHODIMP Machine::COMSETTER(HardwareVersion)(IN_BSTR aHWVersion)
1163{
1164 /* check known version */
1165 Utf8Str hwVersion = aHWVersion;
1166 if ( hwVersion.compare("1") != 0
1167 && hwVersion.compare("2") != 0)
1168 return setError(E_INVALIDARG,
1169 tr("Invalid hardware version: %ls\n"), aHWVersion);
1170
1171 AutoCaller autoCaller(this);
1172 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1173
1174 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1175
1176 HRESULT rc = checkStateDependency(MutableStateDep);
1177 if (FAILED(rc)) return rc;
1178
1179 setModified(IsModified_MachineData);
1180 mHWData.backup();
1181 mHWData->mHWVersion = hwVersion;
1182
1183 return S_OK;
1184}
1185
1186STDMETHODIMP Machine::COMGETTER(HardwareUUID)(BSTR *aUUID)
1187{
1188 CheckComArgOutPointerValid(aUUID);
1189
1190 AutoCaller autoCaller(this);
1191 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1192
1193 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1194
1195 if (!mHWData->mHardwareUUID.isEmpty())
1196 mHWData->mHardwareUUID.toUtf16().cloneTo(aUUID);
1197 else
1198 mData->mUuid.toUtf16().cloneTo(aUUID);
1199
1200 return S_OK;
1201}
1202
1203STDMETHODIMP Machine::COMSETTER(HardwareUUID)(IN_BSTR aUUID)
1204{
1205 Guid hardwareUUID(aUUID);
1206 if (hardwareUUID.isEmpty())
1207 return E_INVALIDARG;
1208
1209 AutoCaller autoCaller(this);
1210 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1211
1212 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1213
1214 HRESULT rc = checkStateDependency(MutableStateDep);
1215 if (FAILED(rc)) return rc;
1216
1217 setModified(IsModified_MachineData);
1218 mHWData.backup();
1219 if (hardwareUUID == mData->mUuid)
1220 mHWData->mHardwareUUID.clear();
1221 else
1222 mHWData->mHardwareUUID = hardwareUUID;
1223
1224 return S_OK;
1225}
1226
1227STDMETHODIMP Machine::COMGETTER(MemorySize)(ULONG *memorySize)
1228{
1229 if (!memorySize)
1230 return E_POINTER;
1231
1232 AutoCaller autoCaller(this);
1233 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1234
1235 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1236
1237 *memorySize = mHWData->mMemorySize;
1238
1239 return S_OK;
1240}
1241
1242STDMETHODIMP Machine::COMSETTER(MemorySize)(ULONG memorySize)
1243{
1244 /* check RAM limits */
1245 if ( memorySize < MM_RAM_MIN_IN_MB
1246 || memorySize > MM_RAM_MAX_IN_MB
1247 )
1248 return setError(E_INVALIDARG,
1249 tr("Invalid RAM size: %lu MB (must be in range [%lu, %lu] MB)"),
1250 memorySize, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
1251
1252 AutoCaller autoCaller(this);
1253 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1254
1255 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1256
1257 HRESULT rc = checkStateDependency(MutableStateDep);
1258 if (FAILED(rc)) return rc;
1259
1260 setModified(IsModified_MachineData);
1261 mHWData.backup();
1262 mHWData->mMemorySize = memorySize;
1263
1264 return S_OK;
1265}
1266
1267STDMETHODIMP Machine::COMGETTER(CPUCount)(ULONG *CPUCount)
1268{
1269 if (!CPUCount)
1270 return E_POINTER;
1271
1272 AutoCaller autoCaller(this);
1273 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1274
1275 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1276
1277 *CPUCount = mHWData->mCPUCount;
1278
1279 return S_OK;
1280}
1281
1282STDMETHODIMP Machine::COMSETTER(CPUCount)(ULONG CPUCount)
1283{
1284 /* check CPU limits */
1285 if ( CPUCount < SchemaDefs::MinCPUCount
1286 || CPUCount > SchemaDefs::MaxCPUCount
1287 )
1288 return setError(E_INVALIDARG,
1289 tr("Invalid virtual CPU count: %lu (must be in range [%lu, %lu])"),
1290 CPUCount, SchemaDefs::MinCPUCount, SchemaDefs::MaxCPUCount);
1291
1292 AutoCaller autoCaller(this);
1293 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1294
1295 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1296
1297 /* We cant go below the current number of CPUs if hotplug is enabled*/
1298 if (mHWData->mCPUHotPlugEnabled)
1299 {
1300 for (unsigned idx = CPUCount; idx < SchemaDefs::MaxCPUCount; idx++)
1301 {
1302 if (mHWData->mCPUAttached[idx])
1303 return setError(E_INVALIDARG,
1304 tr(": %lu (must be higher than or equal to %lu)"),
1305 CPUCount, idx+1);
1306 }
1307 }
1308
1309 HRESULT rc = checkStateDependency(MutableStateDep);
1310 if (FAILED(rc)) return rc;
1311
1312 setModified(IsModified_MachineData);
1313 mHWData.backup();
1314 mHWData->mCPUCount = CPUCount;
1315
1316 return S_OK;
1317}
1318
1319STDMETHODIMP Machine::COMGETTER(CPUExecutionCap)(ULONG *aExecutionCap)
1320{
1321 if (!aExecutionCap)
1322 return E_POINTER;
1323
1324 AutoCaller autoCaller(this);
1325 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1326
1327 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1328
1329 *aExecutionCap = mHWData->mCpuExecutionCap;
1330
1331 return S_OK;
1332}
1333
1334STDMETHODIMP Machine::COMSETTER(CPUExecutionCap)(ULONG aExecutionCap)
1335{
1336 HRESULT rc = S_OK;
1337
1338 /* check throttle limits */
1339 if ( aExecutionCap < 1
1340 || aExecutionCap > 100
1341 )
1342 return setError(E_INVALIDARG,
1343 tr("Invalid CPU execution cap value: %lu (must be in range [%lu, %lu])"),
1344 aExecutionCap, 1, 100);
1345
1346 AutoCaller autoCaller(this);
1347 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1348
1349 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1350
1351 alock.release();
1352 rc = onCPUExecutionCapChange(aExecutionCap);
1353 alock.acquire();
1354 if (FAILED(rc)) return rc;
1355
1356 setModified(IsModified_MachineData);
1357 mHWData.backup();
1358 mHWData->mCpuExecutionCap = aExecutionCap;
1359
1360 /* Save settings if online - todo why is this required?? */
1361 if (Global::IsOnline(mData->mMachineState))
1362 saveSettings(NULL);
1363
1364 return S_OK;
1365}
1366
1367
1368STDMETHODIMP Machine::COMGETTER(CPUHotPlugEnabled)(BOOL *enabled)
1369{
1370 if (!enabled)
1371 return E_POINTER;
1372
1373 AutoCaller autoCaller(this);
1374 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1375
1376 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1377
1378 *enabled = mHWData->mCPUHotPlugEnabled;
1379
1380 return S_OK;
1381}
1382
1383STDMETHODIMP Machine::COMSETTER(CPUHotPlugEnabled)(BOOL enabled)
1384{
1385 HRESULT rc = S_OK;
1386
1387 AutoCaller autoCaller(this);
1388 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1389
1390 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1391
1392 rc = checkStateDependency(MutableStateDep);
1393 if (FAILED(rc)) return rc;
1394
1395 if (mHWData->mCPUHotPlugEnabled != enabled)
1396 {
1397 if (enabled)
1398 {
1399 setModified(IsModified_MachineData);
1400 mHWData.backup();
1401
1402 /* Add the amount of CPUs currently attached */
1403 for (unsigned i = 0; i < mHWData->mCPUCount; i++)
1404 {
1405 mHWData->mCPUAttached[i] = true;
1406 }
1407 }
1408 else
1409 {
1410 /*
1411 * We can disable hotplug only if the amount of maximum CPUs is equal
1412 * to the amount of attached CPUs
1413 */
1414 unsigned cCpusAttached = 0;
1415 unsigned iHighestId = 0;
1416
1417 for (unsigned i = 0; i < SchemaDefs::MaxCPUCount; i++)
1418 {
1419 if (mHWData->mCPUAttached[i])
1420 {
1421 cCpusAttached++;
1422 iHighestId = i;
1423 }
1424 }
1425
1426 if ( (cCpusAttached != mHWData->mCPUCount)
1427 || (iHighestId >= mHWData->mCPUCount))
1428 return setError(E_INVALIDARG,
1429 tr("CPU hotplugging can't be disabled because the maximum number of CPUs is not equal to the amount of CPUs attached\n"));
1430
1431 setModified(IsModified_MachineData);
1432 mHWData.backup();
1433 }
1434 }
1435
1436 mHWData->mCPUHotPlugEnabled = enabled;
1437
1438 return rc;
1439}
1440
1441STDMETHODIMP Machine::COMGETTER(HpetEnabled)(BOOL *enabled)
1442{
1443 CheckComArgOutPointerValid(enabled);
1444
1445 AutoCaller autoCaller(this);
1446 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1447 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1448
1449 *enabled = mHWData->mHpetEnabled;
1450
1451 return S_OK;
1452}
1453
1454STDMETHODIMP Machine::COMSETTER(HpetEnabled)(BOOL enabled)
1455{
1456 HRESULT rc = S_OK;
1457
1458 AutoCaller autoCaller(this);
1459 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1460 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1461
1462 rc = checkStateDependency(MutableStateDep);
1463 if (FAILED(rc)) return rc;
1464
1465 setModified(IsModified_MachineData);
1466 mHWData.backup();
1467
1468 mHWData->mHpetEnabled = enabled;
1469
1470 return rc;
1471}
1472
1473STDMETHODIMP Machine::COMGETTER(VRAMSize)(ULONG *memorySize)
1474{
1475 if (!memorySize)
1476 return E_POINTER;
1477
1478 AutoCaller autoCaller(this);
1479 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1480
1481 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1482
1483 *memorySize = mHWData->mVRAMSize;
1484
1485 return S_OK;
1486}
1487
1488STDMETHODIMP Machine::COMSETTER(VRAMSize)(ULONG memorySize)
1489{
1490 /* check VRAM limits */
1491 if (memorySize < SchemaDefs::MinGuestVRAM ||
1492 memorySize > SchemaDefs::MaxGuestVRAM)
1493 return setError(E_INVALIDARG,
1494 tr("Invalid VRAM size: %lu MB (must be in range [%lu, %lu] MB)"),
1495 memorySize, SchemaDefs::MinGuestVRAM, SchemaDefs::MaxGuestVRAM);
1496
1497 AutoCaller autoCaller(this);
1498 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1499
1500 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1501
1502 HRESULT rc = checkStateDependency(MutableStateDep);
1503 if (FAILED(rc)) return rc;
1504
1505 setModified(IsModified_MachineData);
1506 mHWData.backup();
1507 mHWData->mVRAMSize = memorySize;
1508
1509 return S_OK;
1510}
1511
1512/** @todo this method should not be public */
1513STDMETHODIMP Machine::COMGETTER(MemoryBalloonSize)(ULONG *memoryBalloonSize)
1514{
1515 if (!memoryBalloonSize)
1516 return E_POINTER;
1517
1518 AutoCaller autoCaller(this);
1519 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1520
1521 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1522
1523 *memoryBalloonSize = mHWData->mMemoryBalloonSize;
1524
1525 return S_OK;
1526}
1527
1528/**
1529 * Set the memory balloon size.
1530 *
1531 * This method is also called from IGuest::COMSETTER(MemoryBalloonSize) so
1532 * we have to make sure that we never call IGuest from here.
1533 */
1534STDMETHODIMP Machine::COMSETTER(MemoryBalloonSize)(ULONG memoryBalloonSize)
1535{
1536 /* This must match GMMR0Init; currently we only support memory ballooning on all 64-bit hosts except Mac OS X */
1537#if HC_ARCH_BITS == 64 && (defined(RT_OS_WINDOWS) || defined(RT_OS_SOLARIS) || defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD))
1538 /* check limits */
1539 if (memoryBalloonSize >= VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize))
1540 return setError(E_INVALIDARG,
1541 tr("Invalid memory balloon size: %lu MB (must be in range [%lu, %lu] MB)"),
1542 memoryBalloonSize, 0, VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize));
1543
1544 AutoCaller autoCaller(this);
1545 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1546
1547 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1548
1549 setModified(IsModified_MachineData);
1550 mHWData.backup();
1551 mHWData->mMemoryBalloonSize = memoryBalloonSize;
1552
1553 return S_OK;
1554#else
1555 NOREF(memoryBalloonSize);
1556 return setError(E_NOTIMPL, tr("Memory ballooning is only supported on 64-bit hosts"));
1557#endif
1558}
1559
1560STDMETHODIMP Machine::COMGETTER(PageFusionEnabled) (BOOL *enabled)
1561{
1562 if (!enabled)
1563 return E_POINTER;
1564
1565 AutoCaller autoCaller(this);
1566 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1567
1568 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1569
1570 *enabled = mHWData->mPageFusionEnabled;
1571 return S_OK;
1572}
1573
1574STDMETHODIMP Machine::COMSETTER(PageFusionEnabled) (BOOL enabled)
1575{
1576#ifdef VBOX_WITH_PAGE_SHARING
1577 AutoCaller autoCaller(this);
1578 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1579
1580 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1581
1582 /** @todo must support changes for running vms and keep this in sync with IGuest. */
1583 setModified(IsModified_MachineData);
1584 mHWData.backup();
1585 mHWData->mPageFusionEnabled = enabled;
1586 return S_OK;
1587#else
1588 NOREF(enabled);
1589 return setError(E_NOTIMPL, tr("Page fusion is only supported on 64-bit hosts"));
1590#endif
1591}
1592
1593STDMETHODIMP Machine::COMGETTER(Accelerate3DEnabled)(BOOL *enabled)
1594{
1595 if (!enabled)
1596 return E_POINTER;
1597
1598 AutoCaller autoCaller(this);
1599 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1600
1601 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1602
1603 *enabled = mHWData->mAccelerate3DEnabled;
1604
1605 return S_OK;
1606}
1607
1608STDMETHODIMP Machine::COMSETTER(Accelerate3DEnabled)(BOOL enable)
1609{
1610 AutoCaller autoCaller(this);
1611 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1612
1613 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1614
1615 HRESULT rc = checkStateDependency(MutableStateDep);
1616 if (FAILED(rc)) return rc;
1617
1618 /** @todo check validity! */
1619
1620 setModified(IsModified_MachineData);
1621 mHWData.backup();
1622 mHWData->mAccelerate3DEnabled = enable;
1623
1624 return S_OK;
1625}
1626
1627
1628STDMETHODIMP Machine::COMGETTER(Accelerate2DVideoEnabled)(BOOL *enabled)
1629{
1630 if (!enabled)
1631 return E_POINTER;
1632
1633 AutoCaller autoCaller(this);
1634 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1635
1636 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1637
1638 *enabled = mHWData->mAccelerate2DVideoEnabled;
1639
1640 return S_OK;
1641}
1642
1643STDMETHODIMP Machine::COMSETTER(Accelerate2DVideoEnabled)(BOOL enable)
1644{
1645 AutoCaller autoCaller(this);
1646 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1647
1648 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1649
1650 HRESULT rc = checkStateDependency(MutableStateDep);
1651 if (FAILED(rc)) return rc;
1652
1653 /** @todo check validity! */
1654
1655 setModified(IsModified_MachineData);
1656 mHWData.backup();
1657 mHWData->mAccelerate2DVideoEnabled = enable;
1658
1659 return S_OK;
1660}
1661
1662STDMETHODIMP Machine::COMGETTER(MonitorCount)(ULONG *monitorCount)
1663{
1664 if (!monitorCount)
1665 return E_POINTER;
1666
1667 AutoCaller autoCaller(this);
1668 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1669
1670 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1671
1672 *monitorCount = mHWData->mMonitorCount;
1673
1674 return S_OK;
1675}
1676
1677STDMETHODIMP Machine::COMSETTER(MonitorCount)(ULONG monitorCount)
1678{
1679 /* make sure monitor count is a sensible number */
1680 if (monitorCount < 1 || monitorCount > SchemaDefs::MaxGuestMonitors)
1681 return setError(E_INVALIDARG,
1682 tr("Invalid monitor count: %lu (must be in range [%lu, %lu])"),
1683 monitorCount, 1, SchemaDefs::MaxGuestMonitors);
1684
1685 AutoCaller autoCaller(this);
1686 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1687
1688 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1689
1690 HRESULT rc = checkStateDependency(MutableStateDep);
1691 if (FAILED(rc)) return rc;
1692
1693 setModified(IsModified_MachineData);
1694 mHWData.backup();
1695 mHWData->mMonitorCount = monitorCount;
1696
1697 return S_OK;
1698}
1699
1700STDMETHODIMP Machine::COMGETTER(BIOSSettings)(IBIOSSettings **biosSettings)
1701{
1702 if (!biosSettings)
1703 return E_POINTER;
1704
1705 AutoCaller autoCaller(this);
1706 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1707
1708 /* mBIOSSettings is constant during life time, no need to lock */
1709 mBIOSSettings.queryInterfaceTo(biosSettings);
1710
1711 return S_OK;
1712}
1713
1714STDMETHODIMP Machine::GetCPUProperty(CPUPropertyType_T property, BOOL *aVal)
1715{
1716 if (!aVal)
1717 return E_POINTER;
1718
1719 AutoCaller autoCaller(this);
1720 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1721
1722 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1723
1724 switch(property)
1725 {
1726 case CPUPropertyType_PAE:
1727 *aVal = mHWData->mPAEEnabled;
1728 break;
1729
1730 case CPUPropertyType_Synthetic:
1731 *aVal = mHWData->mSyntheticCpu;
1732 break;
1733
1734 default:
1735 return E_INVALIDARG;
1736 }
1737 return S_OK;
1738}
1739
1740STDMETHODIMP Machine::SetCPUProperty(CPUPropertyType_T property, BOOL aVal)
1741{
1742 AutoCaller autoCaller(this);
1743 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1744
1745 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1746
1747 HRESULT rc = checkStateDependency(MutableStateDep);
1748 if (FAILED(rc)) return rc;
1749
1750 switch(property)
1751 {
1752 case CPUPropertyType_PAE:
1753 setModified(IsModified_MachineData);
1754 mHWData.backup();
1755 mHWData->mPAEEnabled = !!aVal;
1756 break;
1757
1758 case CPUPropertyType_Synthetic:
1759 setModified(IsModified_MachineData);
1760 mHWData.backup();
1761 mHWData->mSyntheticCpu = !!aVal;
1762 break;
1763
1764 default:
1765 return E_INVALIDARG;
1766 }
1767 return S_OK;
1768}
1769
1770STDMETHODIMP Machine::GetCPUIDLeaf(ULONG aId, ULONG *aValEax, ULONG *aValEbx, ULONG *aValEcx, ULONG *aValEdx)
1771{
1772 CheckComArgOutPointerValid(aValEax);
1773 CheckComArgOutPointerValid(aValEbx);
1774 CheckComArgOutPointerValid(aValEcx);
1775 CheckComArgOutPointerValid(aValEdx);
1776
1777 AutoCaller autoCaller(this);
1778 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1779
1780 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1781
1782 switch(aId)
1783 {
1784 case 0x0:
1785 case 0x1:
1786 case 0x2:
1787 case 0x3:
1788 case 0x4:
1789 case 0x5:
1790 case 0x6:
1791 case 0x7:
1792 case 0x8:
1793 case 0x9:
1794 case 0xA:
1795 if (mHWData->mCpuIdStdLeafs[aId].ulId != aId)
1796 return setError(E_INVALIDARG, tr("CpuId override leaf %#x is not set"), aId);
1797
1798 *aValEax = mHWData->mCpuIdStdLeafs[aId].ulEax;
1799 *aValEbx = mHWData->mCpuIdStdLeafs[aId].ulEbx;
1800 *aValEcx = mHWData->mCpuIdStdLeafs[aId].ulEcx;
1801 *aValEdx = mHWData->mCpuIdStdLeafs[aId].ulEdx;
1802 break;
1803
1804 case 0x80000000:
1805 case 0x80000001:
1806 case 0x80000002:
1807 case 0x80000003:
1808 case 0x80000004:
1809 case 0x80000005:
1810 case 0x80000006:
1811 case 0x80000007:
1812 case 0x80000008:
1813 case 0x80000009:
1814 case 0x8000000A:
1815 if (mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId != aId)
1816 return setError(E_INVALIDARG, tr("CpuId override leaf %#x is not set"), aId);
1817
1818 *aValEax = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax;
1819 *aValEbx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx;
1820 *aValEcx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx;
1821 *aValEdx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx;
1822 break;
1823
1824 default:
1825 return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
1826 }
1827 return S_OK;
1828}
1829
1830STDMETHODIMP Machine::SetCPUIDLeaf(ULONG aId, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
1831{
1832 AutoCaller autoCaller(this);
1833 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1834
1835 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1836
1837 HRESULT rc = checkStateDependency(MutableStateDep);
1838 if (FAILED(rc)) return rc;
1839
1840 switch(aId)
1841 {
1842 case 0x0:
1843 case 0x1:
1844 case 0x2:
1845 case 0x3:
1846 case 0x4:
1847 case 0x5:
1848 case 0x6:
1849 case 0x7:
1850 case 0x8:
1851 case 0x9:
1852 case 0xA:
1853 AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xA);
1854 AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
1855 setModified(IsModified_MachineData);
1856 mHWData.backup();
1857 mHWData->mCpuIdStdLeafs[aId].ulId = aId;
1858 mHWData->mCpuIdStdLeafs[aId].ulEax = aValEax;
1859 mHWData->mCpuIdStdLeafs[aId].ulEbx = aValEbx;
1860 mHWData->mCpuIdStdLeafs[aId].ulEcx = aValEcx;
1861 mHWData->mCpuIdStdLeafs[aId].ulEdx = aValEdx;
1862 break;
1863
1864 case 0x80000000:
1865 case 0x80000001:
1866 case 0x80000002:
1867 case 0x80000003:
1868 case 0x80000004:
1869 case 0x80000005:
1870 case 0x80000006:
1871 case 0x80000007:
1872 case 0x80000008:
1873 case 0x80000009:
1874 case 0x8000000A:
1875 AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xA);
1876 AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
1877 setModified(IsModified_MachineData);
1878 mHWData.backup();
1879 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId = aId;
1880 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax = aValEax;
1881 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx = aValEbx;
1882 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx = aValEcx;
1883 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx = aValEdx;
1884 break;
1885
1886 default:
1887 return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
1888 }
1889 return S_OK;
1890}
1891
1892STDMETHODIMP Machine::RemoveCPUIDLeaf(ULONG aId)
1893{
1894 AutoCaller autoCaller(this);
1895 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1896
1897 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1898
1899 HRESULT rc = checkStateDependency(MutableStateDep);
1900 if (FAILED(rc)) return rc;
1901
1902 switch(aId)
1903 {
1904 case 0x0:
1905 case 0x1:
1906 case 0x2:
1907 case 0x3:
1908 case 0x4:
1909 case 0x5:
1910 case 0x6:
1911 case 0x7:
1912 case 0x8:
1913 case 0x9:
1914 case 0xA:
1915 AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xA);
1916 AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
1917 setModified(IsModified_MachineData);
1918 mHWData.backup();
1919 /* Invalidate leaf. */
1920 mHWData->mCpuIdStdLeafs[aId].ulId = UINT32_MAX;
1921 break;
1922
1923 case 0x80000000:
1924 case 0x80000001:
1925 case 0x80000002:
1926 case 0x80000003:
1927 case 0x80000004:
1928 case 0x80000005:
1929 case 0x80000006:
1930 case 0x80000007:
1931 case 0x80000008:
1932 case 0x80000009:
1933 case 0x8000000A:
1934 AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xA);
1935 AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
1936 setModified(IsModified_MachineData);
1937 mHWData.backup();
1938 /* Invalidate leaf. */
1939 mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId = UINT32_MAX;
1940 break;
1941
1942 default:
1943 return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
1944 }
1945 return S_OK;
1946}
1947
1948STDMETHODIMP Machine::RemoveAllCPUIDLeaves()
1949{
1950 AutoCaller autoCaller(this);
1951 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1952
1953 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1954
1955 HRESULT rc = checkStateDependency(MutableStateDep);
1956 if (FAILED(rc)) return rc;
1957
1958 setModified(IsModified_MachineData);
1959 mHWData.backup();
1960
1961 /* Invalidate all standard leafs. */
1962 for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mCpuIdStdLeafs); i++)
1963 mHWData->mCpuIdStdLeafs[i].ulId = UINT32_MAX;
1964
1965 /* Invalidate all extended leafs. */
1966 for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mCpuIdExtLeafs); i++)
1967 mHWData->mCpuIdExtLeafs[i].ulId = UINT32_MAX;
1968
1969 return S_OK;
1970}
1971
1972STDMETHODIMP Machine::GetHWVirtExProperty(HWVirtExPropertyType_T property, BOOL *aVal)
1973{
1974 if (!aVal)
1975 return E_POINTER;
1976
1977 AutoCaller autoCaller(this);
1978 if (FAILED(autoCaller.rc())) return autoCaller.rc();
1979
1980 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1981
1982 switch(property)
1983 {
1984 case HWVirtExPropertyType_Enabled:
1985 *aVal = mHWData->mHWVirtExEnabled;
1986 break;
1987
1988 case HWVirtExPropertyType_Exclusive:
1989 *aVal = mHWData->mHWVirtExExclusive;
1990 break;
1991
1992 case HWVirtExPropertyType_VPID:
1993 *aVal = mHWData->mHWVirtExVPIDEnabled;
1994 break;
1995
1996 case HWVirtExPropertyType_NestedPaging:
1997 *aVal = mHWData->mHWVirtExNestedPagingEnabled;
1998 break;
1999
2000 case HWVirtExPropertyType_LargePages:
2001 *aVal = mHWData->mHWVirtExLargePagesEnabled;
2002 break;
2003
2004 case HWVirtExPropertyType_Force:
2005 *aVal = mHWData->mHWVirtExForceEnabled;
2006 break;
2007
2008 default:
2009 return E_INVALIDARG;
2010 }
2011 return S_OK;
2012}
2013
2014STDMETHODIMP Machine::SetHWVirtExProperty(HWVirtExPropertyType_T property, BOOL aVal)
2015{
2016 AutoCaller autoCaller(this);
2017 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2018
2019 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2020
2021 HRESULT rc = checkStateDependency(MutableStateDep);
2022 if (FAILED(rc)) return rc;
2023
2024 switch(property)
2025 {
2026 case HWVirtExPropertyType_Enabled:
2027 setModified(IsModified_MachineData);
2028 mHWData.backup();
2029 mHWData->mHWVirtExEnabled = !!aVal;
2030 break;
2031
2032 case HWVirtExPropertyType_Exclusive:
2033 setModified(IsModified_MachineData);
2034 mHWData.backup();
2035 mHWData->mHWVirtExExclusive = !!aVal;
2036 break;
2037
2038 case HWVirtExPropertyType_VPID:
2039 setModified(IsModified_MachineData);
2040 mHWData.backup();
2041 mHWData->mHWVirtExVPIDEnabled = !!aVal;
2042 break;
2043
2044 case HWVirtExPropertyType_NestedPaging:
2045 setModified(IsModified_MachineData);
2046 mHWData.backup();
2047 mHWData->mHWVirtExNestedPagingEnabled = !!aVal;
2048 break;
2049
2050 case HWVirtExPropertyType_LargePages:
2051 setModified(IsModified_MachineData);
2052 mHWData.backup();
2053 mHWData->mHWVirtExLargePagesEnabled = !!aVal;
2054 break;
2055
2056 case HWVirtExPropertyType_Force:
2057 setModified(IsModified_MachineData);
2058 mHWData.backup();
2059 mHWData->mHWVirtExForceEnabled = !!aVal;
2060 break;
2061
2062 default:
2063 return E_INVALIDARG;
2064 }
2065
2066 return S_OK;
2067}
2068
2069STDMETHODIMP Machine::COMGETTER(SnapshotFolder)(BSTR *aSnapshotFolder)
2070{
2071 CheckComArgOutPointerValid(aSnapshotFolder);
2072
2073 AutoCaller autoCaller(this);
2074 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2075
2076 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2077
2078 mUserData->m_strSnapshotFolderFull.cloneTo(aSnapshotFolder);
2079
2080 return S_OK;
2081}
2082
2083STDMETHODIMP Machine::COMSETTER(SnapshotFolder)(IN_BSTR aSnapshotFolder)
2084{
2085 /* @todo (r=dmik):
2086 * 1. Allow to change the name of the snapshot folder containing snapshots
2087 * 2. Rename the folder on disk instead of just changing the property
2088 * value (to be smart and not to leave garbage). Note that it cannot be
2089 * done here because the change may be rolled back. Thus, the right
2090 * place is #saveSettings().
2091 */
2092
2093 AutoCaller autoCaller(this);
2094 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2095
2096 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2097
2098 HRESULT rc = checkStateDependency(MutableStateDep);
2099 if (FAILED(rc)) return rc;
2100
2101 if (!mData->mCurrentSnapshot.isNull())
2102 return setError(E_FAIL,
2103 tr("The snapshot folder of a machine with snapshots cannot be changed (please delete all snapshots first)"));
2104
2105 Utf8Str strSnapshotFolder0(aSnapshotFolder); // keep original
2106 Utf8Str strSnapshotFolder(strSnapshotFolder0);
2107
2108 if (strSnapshotFolder.isEmpty())
2109 {
2110 if (isInOwnDir())
2111 /* the default snapshots folder is 'Snapshots' in the machine dir */
2112 strSnapshotFolder = "Snapshots";
2113 else
2114 /* the default snapshots folder is {UUID}, for backwards
2115 * compatibility and to resolve conflicts */
2116 strSnapshotFolder = Utf8StrFmt("{%RTuuid}", mData->mUuid.raw());
2117 }
2118
2119 int vrc = calculateFullPath(strSnapshotFolder, strSnapshotFolder);
2120 if (RT_FAILURE(vrc))
2121 return setError(E_FAIL,
2122 tr("Invalid snapshot folder '%ls' (%Rrc)"),
2123 aSnapshotFolder, vrc);
2124
2125 setModified(IsModified_MachineData);
2126 mUserData.backup();
2127 mUserData->s.strSnapshotFolder = strSnapshotFolder0;
2128 mUserData->m_strSnapshotFolderFull = strSnapshotFolder;
2129
2130 return S_OK;
2131}
2132
2133STDMETHODIMP Machine::COMGETTER(MediumAttachments)(ComSafeArrayOut(IMediumAttachment*, aAttachments))
2134{
2135 if (ComSafeArrayOutIsNull(aAttachments))
2136 return E_POINTER;
2137
2138 AutoCaller autoCaller(this);
2139 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2140
2141 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2142
2143 SafeIfaceArray<IMediumAttachment> attachments(mMediaData->mAttachments);
2144 attachments.detachTo(ComSafeArrayOutArg(aAttachments));
2145
2146 return S_OK;
2147}
2148
2149STDMETHODIMP Machine::COMGETTER(VRDPServer)(IVRDPServer **vrdpServer)
2150{
2151#ifdef VBOX_WITH_VRDP
2152 if (!vrdpServer)
2153 return E_POINTER;
2154
2155 AutoCaller autoCaller(this);
2156 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2157
2158 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2159
2160 Assert(!!mVRDPServer);
2161 mVRDPServer.queryInterfaceTo(vrdpServer);
2162
2163 return S_OK;
2164#else
2165 NOREF(vrdpServer);
2166 ReturnComNotImplemented();
2167#endif
2168}
2169
2170STDMETHODIMP Machine::COMGETTER(AudioAdapter)(IAudioAdapter **audioAdapter)
2171{
2172 if (!audioAdapter)
2173 return E_POINTER;
2174
2175 AutoCaller autoCaller(this);
2176 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2177
2178 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2179
2180 mAudioAdapter.queryInterfaceTo(audioAdapter);
2181 return S_OK;
2182}
2183
2184STDMETHODIMP Machine::COMGETTER(USBController)(IUSBController **aUSBController)
2185{
2186#ifdef VBOX_WITH_VUSB
2187 CheckComArgOutPointerValid(aUSBController);
2188
2189 AutoCaller autoCaller(this);
2190 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2191 MultiResult rc(S_OK);
2192
2193# ifdef VBOX_WITH_USB
2194 rc = mParent->host()->checkUSBProxyService();
2195 if (FAILED(rc)) return rc;
2196# endif
2197
2198 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2199
2200 return rc = mUSBController.queryInterfaceTo(aUSBController);
2201#else
2202 /* Note: The GUI depends on this method returning E_NOTIMPL with no
2203 * extended error info to indicate that USB is simply not available
2204 * (w/o treting it as a failure), for example, as in OSE */
2205 NOREF(aUSBController);
2206 ReturnComNotImplemented();
2207#endif /* VBOX_WITH_VUSB */
2208}
2209
2210STDMETHODIMP Machine::COMGETTER(SettingsFilePath)(BSTR *aFilePath)
2211{
2212 CheckComArgOutPointerValid(aFilePath);
2213
2214 AutoLimitedCaller autoCaller(this);
2215 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2216
2217 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2218
2219 mData->m_strConfigFileFull.cloneTo(aFilePath);
2220 return S_OK;
2221}
2222
2223STDMETHODIMP Machine::COMGETTER(SettingsModified)(BOOL *aModified)
2224{
2225 CheckComArgOutPointerValid(aModified);
2226
2227 AutoCaller autoCaller(this);
2228 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2229
2230 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2231
2232 HRESULT rc = checkStateDependency(MutableStateDep);
2233 if (FAILED(rc)) return rc;
2234
2235 if (!mData->pMachineConfigFile->fileExists())
2236 // this is a new machine, and no config file exists yet:
2237 *aModified = TRUE;
2238 else
2239 *aModified = (mData->flModifications != 0);
2240
2241 return S_OK;
2242}
2243
2244STDMETHODIMP Machine::COMGETTER(SessionState)(SessionState_T *aSessionState)
2245{
2246 CheckComArgOutPointerValid(aSessionState);
2247
2248 AutoCaller autoCaller(this);
2249 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2250
2251 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2252
2253 *aSessionState = mData->mSession.mState;
2254
2255 return S_OK;
2256}
2257
2258STDMETHODIMP Machine::COMGETTER(SessionType)(BSTR *aSessionType)
2259{
2260 CheckComArgOutPointerValid(aSessionType);
2261
2262 AutoCaller autoCaller(this);
2263 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2264
2265 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2266
2267 mData->mSession.mType.cloneTo(aSessionType);
2268
2269 return S_OK;
2270}
2271
2272STDMETHODIMP Machine::COMGETTER(SessionPid)(ULONG *aSessionPid)
2273{
2274 CheckComArgOutPointerValid(aSessionPid);
2275
2276 AutoCaller autoCaller(this);
2277 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2278
2279 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2280
2281 *aSessionPid = mData->mSession.mPid;
2282
2283 return S_OK;
2284}
2285
2286STDMETHODIMP Machine::COMGETTER(State)(MachineState_T *machineState)
2287{
2288 if (!machineState)
2289 return E_POINTER;
2290
2291 AutoCaller autoCaller(this);
2292 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2293
2294 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2295
2296 *machineState = mData->mMachineState;
2297
2298 return S_OK;
2299}
2300
2301STDMETHODIMP Machine::COMGETTER(LastStateChange)(LONG64 *aLastStateChange)
2302{
2303 CheckComArgOutPointerValid(aLastStateChange);
2304
2305 AutoCaller autoCaller(this);
2306 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2307
2308 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2309
2310 *aLastStateChange = RTTimeSpecGetMilli(&mData->mLastStateChange);
2311
2312 return S_OK;
2313}
2314
2315STDMETHODIMP Machine::COMGETTER(StateFilePath)(BSTR *aStateFilePath)
2316{
2317 CheckComArgOutPointerValid(aStateFilePath);
2318
2319 AutoCaller autoCaller(this);
2320 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2321
2322 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2323
2324 mSSData->mStateFilePath.cloneTo(aStateFilePath);
2325
2326 return S_OK;
2327}
2328
2329STDMETHODIMP Machine::COMGETTER(LogFolder)(BSTR *aLogFolder)
2330{
2331 CheckComArgOutPointerValid(aLogFolder);
2332
2333 AutoCaller autoCaller(this);
2334 AssertComRCReturnRC(autoCaller.rc());
2335
2336 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2337
2338 Utf8Str logFolder;
2339 getLogFolder(logFolder);
2340
2341 Bstr (logFolder).cloneTo(aLogFolder);
2342
2343 return S_OK;
2344}
2345
2346STDMETHODIMP Machine::COMGETTER(CurrentSnapshot) (ISnapshot **aCurrentSnapshot)
2347{
2348 CheckComArgOutPointerValid(aCurrentSnapshot);
2349
2350 AutoCaller autoCaller(this);
2351 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2352
2353 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2354
2355 mData->mCurrentSnapshot.queryInterfaceTo(aCurrentSnapshot);
2356
2357 return S_OK;
2358}
2359
2360STDMETHODIMP Machine::COMGETTER(SnapshotCount)(ULONG *aSnapshotCount)
2361{
2362 CheckComArgOutPointerValid(aSnapshotCount);
2363
2364 AutoCaller autoCaller(this);
2365 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2366
2367 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2368
2369 *aSnapshotCount = mData->mFirstSnapshot.isNull()
2370 ? 0
2371 : mData->mFirstSnapshot->getAllChildrenCount() + 1;
2372
2373 return S_OK;
2374}
2375
2376STDMETHODIMP Machine::COMGETTER(CurrentStateModified)(BOOL *aCurrentStateModified)
2377{
2378 CheckComArgOutPointerValid(aCurrentStateModified);
2379
2380 AutoCaller autoCaller(this);
2381 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2382
2383 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2384
2385 /* Note: for machines with no snapshots, we always return FALSE
2386 * (mData->mCurrentStateModified will be TRUE in this case, for historical
2387 * reasons :) */
2388
2389 *aCurrentStateModified = mData->mFirstSnapshot.isNull()
2390 ? FALSE
2391 : mData->mCurrentStateModified;
2392
2393 return S_OK;
2394}
2395
2396STDMETHODIMP Machine::COMGETTER(SharedFolders)(ComSafeArrayOut(ISharedFolder *, aSharedFolders))
2397{
2398 CheckComArgOutSafeArrayPointerValid(aSharedFolders);
2399
2400 AutoCaller autoCaller(this);
2401 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2402
2403 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2404
2405 SafeIfaceArray<ISharedFolder> folders(mHWData->mSharedFolders);
2406 folders.detachTo(ComSafeArrayOutArg(aSharedFolders));
2407
2408 return S_OK;
2409}
2410
2411STDMETHODIMP Machine::COMGETTER(ClipboardMode)(ClipboardMode_T *aClipboardMode)
2412{
2413 CheckComArgOutPointerValid(aClipboardMode);
2414
2415 AutoCaller autoCaller(this);
2416 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2417
2418 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2419
2420 *aClipboardMode = mHWData->mClipboardMode;
2421
2422 return S_OK;
2423}
2424
2425STDMETHODIMP
2426Machine::COMSETTER(ClipboardMode)(ClipboardMode_T aClipboardMode)
2427{
2428 AutoCaller autoCaller(this);
2429 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2430
2431 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2432
2433 HRESULT rc = checkStateDependency(MutableStateDep);
2434 if (FAILED(rc)) return rc;
2435
2436 setModified(IsModified_MachineData);
2437 mHWData.backup();
2438 mHWData->mClipboardMode = aClipboardMode;
2439
2440 return S_OK;
2441}
2442
2443STDMETHODIMP
2444Machine::COMGETTER(GuestPropertyNotificationPatterns)(BSTR *aPatterns)
2445{
2446 CheckComArgOutPointerValid(aPatterns);
2447
2448 AutoCaller autoCaller(this);
2449 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2450
2451 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2452
2453 try
2454 {
2455 mHWData->mGuestPropertyNotificationPatterns.cloneTo(aPatterns);
2456 }
2457 catch (...)
2458 {
2459 return VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
2460 }
2461
2462 return S_OK;
2463}
2464
2465STDMETHODIMP
2466Machine::COMSETTER(GuestPropertyNotificationPatterns)(IN_BSTR aPatterns)
2467{
2468 AutoCaller autoCaller(this);
2469 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2470
2471 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2472
2473 HRESULT rc = checkStateDependency(MutableStateDep);
2474 if (FAILED(rc)) return rc;
2475
2476 setModified(IsModified_MachineData);
2477 mHWData.backup();
2478 mHWData->mGuestPropertyNotificationPatterns = aPatterns;
2479 return rc;
2480}
2481
2482STDMETHODIMP
2483Machine::COMGETTER(StorageControllers)(ComSafeArrayOut(IStorageController *, aStorageControllers))
2484{
2485 CheckComArgOutSafeArrayPointerValid(aStorageControllers);
2486
2487 AutoCaller autoCaller(this);
2488 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2489
2490 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2491
2492 SafeIfaceArray<IStorageController> ctrls(*mStorageControllers.data());
2493 ctrls.detachTo(ComSafeArrayOutArg(aStorageControllers));
2494
2495 return S_OK;
2496}
2497
2498STDMETHODIMP
2499Machine::COMGETTER(TeleporterEnabled)(BOOL *aEnabled)
2500{
2501 CheckComArgOutPointerValid(aEnabled);
2502
2503 AutoCaller autoCaller(this);
2504 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2505
2506 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2507
2508 *aEnabled = mUserData->s.fTeleporterEnabled;
2509
2510 return S_OK;
2511}
2512
2513STDMETHODIMP Machine::COMSETTER(TeleporterEnabled)(BOOL aEnabled)
2514{
2515 AutoCaller autoCaller(this);
2516 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2517
2518 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2519
2520 /* Only allow it to be set to true when PoweredOff or Aborted.
2521 (Clearing it is always permitted.) */
2522 if ( aEnabled
2523 && mData->mRegistered
2524 && ( !isSessionMachine()
2525 || ( mData->mMachineState != MachineState_PoweredOff
2526 && mData->mMachineState != MachineState_Teleported
2527 && mData->mMachineState != MachineState_Aborted
2528 )
2529 )
2530 )
2531 return setError(VBOX_E_INVALID_VM_STATE,
2532 tr("The machine is not powered off (state is %s)"),
2533 Global::stringifyMachineState(mData->mMachineState));
2534
2535 setModified(IsModified_MachineData);
2536 mUserData.backup();
2537 mUserData->s.fTeleporterEnabled = !!aEnabled;
2538
2539 return S_OK;
2540}
2541
2542STDMETHODIMP Machine::COMGETTER(TeleporterPort)(ULONG *aPort)
2543{
2544 CheckComArgOutPointerValid(aPort);
2545
2546 AutoCaller autoCaller(this);
2547 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2548
2549 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2550
2551 *aPort = (ULONG)mUserData->s.uTeleporterPort;
2552
2553 return S_OK;
2554}
2555
2556STDMETHODIMP Machine::COMSETTER(TeleporterPort)(ULONG aPort)
2557{
2558 if (aPort >= _64K)
2559 return setError(E_INVALIDARG, tr("Invalid port number %d"), aPort);
2560
2561 AutoCaller autoCaller(this);
2562 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2563
2564 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2565
2566 HRESULT rc = checkStateDependency(MutableStateDep);
2567 if (FAILED(rc)) return rc;
2568
2569 setModified(IsModified_MachineData);
2570 mUserData.backup();
2571 mUserData->s.uTeleporterPort = (uint32_t)aPort;
2572
2573 return S_OK;
2574}
2575
2576STDMETHODIMP Machine::COMGETTER(TeleporterAddress)(BSTR *aAddress)
2577{
2578 CheckComArgOutPointerValid(aAddress);
2579
2580 AutoCaller autoCaller(this);
2581 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2582
2583 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2584
2585 mUserData->s.strTeleporterAddress.cloneTo(aAddress);
2586
2587 return S_OK;
2588}
2589
2590STDMETHODIMP Machine::COMSETTER(TeleporterAddress)(IN_BSTR aAddress)
2591{
2592 AutoCaller autoCaller(this);
2593 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2594
2595 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2596
2597 HRESULT rc = checkStateDependency(MutableStateDep);
2598 if (FAILED(rc)) return rc;
2599
2600 setModified(IsModified_MachineData);
2601 mUserData.backup();
2602 mUserData->s.strTeleporterAddress = aAddress;
2603
2604 return S_OK;
2605}
2606
2607STDMETHODIMP Machine::COMGETTER(TeleporterPassword)(BSTR *aPassword)
2608{
2609 CheckComArgOutPointerValid(aPassword);
2610
2611 AutoCaller autoCaller(this);
2612 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2613
2614 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2615
2616 mUserData->s.strTeleporterPassword.cloneTo(aPassword);
2617
2618 return S_OK;
2619}
2620
2621STDMETHODIMP Machine::COMSETTER(TeleporterPassword)(IN_BSTR aPassword)
2622{
2623 AutoCaller autoCaller(this);
2624 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2625
2626 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2627
2628 HRESULT rc = checkStateDependency(MutableStateDep);
2629 if (FAILED(rc)) return rc;
2630
2631 setModified(IsModified_MachineData);
2632 mUserData.backup();
2633 mUserData->s.strTeleporterPassword = aPassword;
2634
2635 return S_OK;
2636}
2637
2638STDMETHODIMP Machine::COMGETTER(FaultToleranceState)(FaultToleranceState_T *aState)
2639{
2640 CheckComArgOutPointerValid(aState);
2641
2642 AutoCaller autoCaller(this);
2643 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2644
2645 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2646
2647 *aState = mUserData->s.enmFaultToleranceState;
2648 return S_OK;
2649}
2650
2651STDMETHODIMP Machine::COMSETTER(FaultToleranceState)(FaultToleranceState_T aState)
2652{
2653 AutoCaller autoCaller(this);
2654 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2655
2656 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2657
2658 /* @todo deal with running state change. */
2659 HRESULT rc = checkStateDependency(MutableStateDep);
2660 if (FAILED(rc)) return rc;
2661
2662 setModified(IsModified_MachineData);
2663 mUserData.backup();
2664 mUserData->s.enmFaultToleranceState = aState;
2665 return S_OK;
2666}
2667
2668STDMETHODIMP Machine::COMGETTER(FaultToleranceAddress)(BSTR *aAddress)
2669{
2670 CheckComArgOutPointerValid(aAddress);
2671
2672 AutoCaller autoCaller(this);
2673 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2674
2675 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2676
2677 mUserData->s.strFaultToleranceAddress.cloneTo(aAddress);
2678 return S_OK;
2679}
2680
2681STDMETHODIMP Machine::COMSETTER(FaultToleranceAddress)(IN_BSTR aAddress)
2682{
2683 AutoCaller autoCaller(this);
2684 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2685
2686 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2687
2688 /* @todo deal with running state change. */
2689 HRESULT rc = checkStateDependency(MutableStateDep);
2690 if (FAILED(rc)) return rc;
2691
2692 setModified(IsModified_MachineData);
2693 mUserData.backup();
2694 mUserData->s.strFaultToleranceAddress = aAddress;
2695 return S_OK;
2696}
2697
2698STDMETHODIMP Machine::COMGETTER(FaultTolerancePort)(ULONG *aPort)
2699{
2700 CheckComArgOutPointerValid(aPort);
2701
2702 AutoCaller autoCaller(this);
2703 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2704
2705 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2706
2707 *aPort = mUserData->s.uFaultTolerancePort;
2708 return S_OK;
2709}
2710
2711STDMETHODIMP Machine::COMSETTER(FaultTolerancePort)(ULONG aPort)
2712{
2713 AutoCaller autoCaller(this);
2714 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2715
2716 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2717
2718 /* @todo deal with running state change. */
2719 HRESULT rc = checkStateDependency(MutableStateDep);
2720 if (FAILED(rc)) return rc;
2721
2722 setModified(IsModified_MachineData);
2723 mUserData.backup();
2724 mUserData->s.uFaultTolerancePort = aPort;
2725 return S_OK;
2726}
2727
2728STDMETHODIMP Machine::COMGETTER(FaultTolerancePassword)(BSTR *aPassword)
2729{
2730 CheckComArgOutPointerValid(aPassword);
2731
2732 AutoCaller autoCaller(this);
2733 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2734
2735 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2736
2737 mUserData->s.strFaultTolerancePassword.cloneTo(aPassword);
2738
2739 return S_OK;
2740}
2741
2742STDMETHODIMP Machine::COMSETTER(FaultTolerancePassword)(IN_BSTR aPassword)
2743{
2744 AutoCaller autoCaller(this);
2745 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2746
2747 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2748
2749 /* @todo deal with running state change. */
2750 HRESULT rc = checkStateDependency(MutableStateDep);
2751 if (FAILED(rc)) return rc;
2752
2753 setModified(IsModified_MachineData);
2754 mUserData.backup();
2755 mUserData->s.strFaultTolerancePassword = aPassword;
2756
2757 return S_OK;
2758}
2759
2760STDMETHODIMP Machine::COMGETTER(FaultToleranceSyncInterval)(ULONG *aInterval)
2761{
2762 CheckComArgOutPointerValid(aInterval);
2763
2764 AutoCaller autoCaller(this);
2765 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2766
2767 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2768
2769 *aInterval = mUserData->s.uFaultToleranceInterval;
2770 return S_OK;
2771}
2772
2773STDMETHODIMP Machine::COMSETTER(FaultToleranceSyncInterval)(ULONG aInterval)
2774{
2775 AutoCaller autoCaller(this);
2776 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2777
2778 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2779
2780 /* @todo deal with running state change. */
2781 HRESULT rc = checkStateDependency(MutableStateDep);
2782 if (FAILED(rc)) return rc;
2783
2784 setModified(IsModified_MachineData);
2785 mUserData.backup();
2786 mUserData->s.uFaultToleranceInterval = aInterval;
2787 return S_OK;
2788}
2789
2790STDMETHODIMP Machine::COMGETTER(RTCUseUTC)(BOOL *aEnabled)
2791{
2792 CheckComArgOutPointerValid(aEnabled);
2793
2794 AutoCaller autoCaller(this);
2795 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2796
2797 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2798
2799 *aEnabled = mUserData->s.fRTCUseUTC;
2800
2801 return S_OK;
2802}
2803
2804STDMETHODIMP Machine::COMSETTER(RTCUseUTC)(BOOL aEnabled)
2805{
2806 AutoCaller autoCaller(this);
2807 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2808
2809 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2810
2811 /* Only allow it to be set to true when PoweredOff or Aborted.
2812 (Clearing it is always permitted.) */
2813 if ( aEnabled
2814 && mData->mRegistered
2815 && ( !isSessionMachine()
2816 || ( mData->mMachineState != MachineState_PoweredOff
2817 && mData->mMachineState != MachineState_Teleported
2818 && mData->mMachineState != MachineState_Aborted
2819 )
2820 )
2821 )
2822 return setError(VBOX_E_INVALID_VM_STATE,
2823 tr("The machine is not powered off (state is %s)"),
2824 Global::stringifyMachineState(mData->mMachineState));
2825
2826 setModified(IsModified_MachineData);
2827 mUserData.backup();
2828 mUserData->s.fRTCUseUTC = !!aEnabled;
2829
2830 return S_OK;
2831}
2832
2833STDMETHODIMP Machine::COMGETTER(IoCacheEnabled)(BOOL *aEnabled)
2834{
2835 CheckComArgOutPointerValid(aEnabled);
2836
2837 AutoCaller autoCaller(this);
2838 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2839
2840 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2841
2842 *aEnabled = mHWData->mIoCacheEnabled;
2843
2844 return S_OK;
2845}
2846
2847STDMETHODIMP Machine::COMSETTER(IoCacheEnabled)(BOOL aEnabled)
2848{
2849 AutoCaller autoCaller(this);
2850 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2851
2852 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2853
2854 HRESULT rc = checkStateDependency(MutableStateDep);
2855 if (FAILED(rc)) return rc;
2856
2857 setModified(IsModified_MachineData);
2858 mHWData.backup();
2859 mHWData->mIoCacheEnabled = aEnabled;
2860
2861 return S_OK;
2862}
2863
2864STDMETHODIMP Machine::COMGETTER(IoCacheSize)(ULONG *aIoCacheSize)
2865{
2866 CheckComArgOutPointerValid(aIoCacheSize);
2867
2868 AutoCaller autoCaller(this);
2869 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2870
2871 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2872
2873 *aIoCacheSize = mHWData->mIoCacheSize;
2874
2875 return S_OK;
2876}
2877
2878STDMETHODIMP Machine::COMSETTER(IoCacheSize)(ULONG aIoCacheSize)
2879{
2880 AutoCaller autoCaller(this);
2881 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2882
2883 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2884
2885 HRESULT rc = checkStateDependency(MutableStateDep);
2886 if (FAILED(rc)) return rc;
2887
2888 setModified(IsModified_MachineData);
2889 mHWData.backup();
2890 mHWData->mIoCacheSize = aIoCacheSize;
2891
2892 return S_OK;
2893}
2894
2895
2896/**
2897 * @note Locks objects!
2898 */
2899STDMETHODIMP Machine::LockMachine(ISession *aSession,
2900 LockType_T lockType)
2901{
2902 CheckComArgNotNull(aSession);
2903
2904 AutoCaller autoCaller(this);
2905 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2906
2907 /* check the session state */
2908 SessionState_T state;
2909 HRESULT rc = aSession->COMGETTER(State)(&state);
2910 if (FAILED(rc)) return rc;
2911
2912 if (state != SessionState_Unlocked)
2913 return setError(VBOX_E_INVALID_OBJECT_STATE,
2914 tr("The given session is busy"));
2915
2916 // get the client's IInternalSessionControl interface
2917 ComPtr<IInternalSessionControl> pSessionControl = aSession;
2918 ComAssertMsgRet(!!pSessionControl, ("No IInternalSessionControl interface"),
2919 E_INVALIDARG);
2920
2921 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2922
2923 if (!mData->mRegistered)
2924 return setError(E_UNEXPECTED,
2925 tr("The machine '%s' is not registered"),
2926 mUserData->s.strName.c_str());
2927
2928 LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
2929
2930 SessionState_T oldState = mData->mSession.mState;
2931 /* Hack: in case the session is closing and there is a progress object
2932 * which allows waiting for the session to be closed, take the opportunity
2933 * and do a limited wait (max. 1 second). This helps a lot when the system
2934 * is busy and thus session closing can take a little while. */
2935 if ( mData->mSession.mState == SessionState_Unlocking
2936 && mData->mSession.mProgress)
2937 {
2938 alock.release();
2939 mData->mSession.mProgress->WaitForCompletion(1000);
2940 alock.acquire();
2941 LogFlowThisFunc(("after waiting: mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
2942 }
2943
2944 // try again now
2945 if ( (mData->mSession.mState == SessionState_Locked) // machine is write-locked already (i.e. session machine exists)
2946 && (lockType == LockType_Shared) // caller wants a shared link to the existing session that holds the write lock:
2947 )
2948 {
2949 // OK, share the session... we are now dealing with three processes:
2950 // 1) VBoxSVC (where this code runs);
2951 // 2) process C: the caller's client process (who wants a shared session);
2952 // 3) process W: the process which already holds the write lock on the machine (write-locking session)
2953
2954 // copy pointers to W (the write-locking session) before leaving lock (these must not be NULL)
2955 ComPtr<IInternalSessionControl> pSessionW = mData->mSession.mDirectControl;
2956 ComAssertRet(!pSessionW.isNull(), E_FAIL);
2957 ComObjPtr<SessionMachine> pSessionMachine = mData->mSession.mMachine;
2958 AssertReturn(!pSessionMachine.isNull(), E_FAIL);
2959
2960 /*
2961 * Leave the lock before calling the client process. It's safe here
2962 * since the only thing to do after we get the lock again is to add
2963 * the remote control to the list (which doesn't directly influence
2964 * anything).
2965 */
2966 alock.leave();
2967
2968 // get the console of the session holding the write lock (this is a remote call)
2969 ComPtr<IConsole> pConsoleW;
2970 LogFlowThisFunc(("Calling GetRemoteConsole()...\n"));
2971 rc = pSessionW->GetRemoteConsole(pConsoleW.asOutParam());
2972 LogFlowThisFunc(("GetRemoteConsole() returned %08X\n", rc));
2973 if (FAILED(rc))
2974 // the failure may occur w/o any error info (from RPC), so provide one
2975 return setError(VBOX_E_VM_ERROR,
2976 tr("Failed to get a console object from the direct session (%Rrc)"), rc);
2977
2978 ComAssertRet(!pConsoleW.isNull(), E_FAIL);
2979
2980 // share the session machine and W's console with the caller's session
2981 LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
2982 rc = pSessionControl->AssignRemoteMachine(pSessionMachine, pConsoleW);
2983 LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
2984
2985 if (FAILED(rc))
2986 // the failure may occur w/o any error info (from RPC), so provide one
2987 return setError(VBOX_E_VM_ERROR,
2988 tr("Failed to assign the machine to the session (%Rrc)"), rc);
2989 alock.enter();
2990
2991 // need to revalidate the state after entering the lock again
2992 if (mData->mSession.mState != SessionState_Locked)
2993 {
2994 pSessionControl->Uninitialize();
2995 return setError(VBOX_E_INVALID_SESSION_STATE,
2996 tr("The machine '%s' was unlocked unexpectedly while attempting to share its session"),
2997 mUserData->s.strName.c_str());
2998 }
2999
3000 // add the caller's session to the list
3001 mData->mSession.mRemoteControls.push_back(pSessionControl);
3002 }
3003 else if ( mData->mSession.mState == SessionState_Locked
3004 || mData->mSession.mState == SessionState_Unlocking
3005 )
3006 {
3007 // sharing not permitted, or machine still unlocking:
3008 return setError(VBOX_E_INVALID_OBJECT_STATE,
3009 tr("The machine '%s' is already locked for a session (or being unlocked)"),
3010 mUserData->s.strName.c_str());
3011 }
3012 else
3013 {
3014 // machine is not locked: then write-lock the machine (create the session machine)
3015
3016 // must not be busy
3017 AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
3018
3019 // get the caller's session PID
3020 RTPROCESS pid = NIL_RTPROCESS;
3021 AssertCompile(sizeof(ULONG) == sizeof(RTPROCESS));
3022 pSessionControl->GetPID((ULONG*)&pid);
3023 Assert(pid != NIL_RTPROCESS);
3024
3025 bool fLaunchingVMProcess = (mData->mSession.mState == SessionState_Spawning);
3026
3027 if (fLaunchingVMProcess)
3028 {
3029 // this machine is awaiting for a spawning session to be opened:
3030 // then the calling process must be the one that got started by
3031 // launchVMProcess()
3032
3033 LogFlowThisFunc(("mSession.mPid=%d(0x%x)\n", mData->mSession.mPid, mData->mSession.mPid));
3034 LogFlowThisFunc(("session.pid=%d(0x%x)\n", pid, pid));
3035
3036 if (mData->mSession.mPid != pid)
3037 return setError(E_ACCESSDENIED,
3038 tr("An unexpected process (PID=0x%08X) has tried to lock the "
3039 "machine '%s', while only the process started by launchVMProcess (PID=0x%08X) is allowed"),
3040 pid, mUserData->s.strName.c_str(), mData->mSession.mPid);
3041 }
3042
3043 // create the mutable SessionMachine from the current machine
3044 ComObjPtr<SessionMachine> sessionMachine;
3045 sessionMachine.createObject();
3046 rc = sessionMachine->init(this);
3047 AssertComRC(rc);
3048
3049 /* NOTE: doing return from this function after this point but
3050 * before the end is forbidden since it may call SessionMachine::uninit()
3051 * (through the ComObjPtr's destructor) which requests the VirtualBox write
3052 * lock while still holding the Machine lock in alock so that a deadlock
3053 * is possible due to the wrong lock order. */
3054
3055 if (SUCCEEDED(rc))
3056 {
3057 /*
3058 * Set the session state to Spawning to protect against subsequent
3059 * attempts to open a session and to unregister the machine after
3060 * we leave the lock.
3061 */
3062 SessionState_T origState = mData->mSession.mState;
3063 mData->mSession.mState = SessionState_Spawning;
3064
3065 /*
3066 * Leave the lock before calling the client process -- it will call
3067 * Machine/SessionMachine methods. Leaving the lock here is quite safe
3068 * because the state is Spawning, so that openRemotesession() and
3069 * openExistingSession() calls will fail. This method, called before we
3070 * enter the lock again, will fail because of the wrong PID.
3071 *
3072 * Note that mData->mSession.mRemoteControls accessed outside
3073 * the lock may not be modified when state is Spawning, so it's safe.
3074 */
3075 alock.leave();
3076
3077 LogFlowThisFunc(("Calling AssignMachine()...\n"));
3078 rc = pSessionControl->AssignMachine(sessionMachine);
3079 LogFlowThisFunc(("AssignMachine() returned %08X\n", rc));
3080
3081 /* The failure may occur w/o any error info (from RPC), so provide one */
3082 if (FAILED(rc))
3083 setError(VBOX_E_VM_ERROR,
3084 tr("Failed to assign the machine to the session (%Rrc)"), rc);
3085
3086 if ( SUCCEEDED(rc)
3087 && fLaunchingVMProcess
3088 )
3089 {
3090 /* complete the remote session initialization */
3091
3092 /* get the console from the direct session */
3093 ComPtr<IConsole> console;
3094 rc = pSessionControl->GetRemoteConsole(console.asOutParam());
3095 ComAssertComRC(rc);
3096
3097 if (SUCCEEDED(rc) && !console)
3098 {
3099 ComAssert(!!console);
3100 rc = E_FAIL;
3101 }
3102
3103 /* assign machine & console to the remote session */
3104 if (SUCCEEDED(rc))
3105 {
3106 /*
3107 * after openRemoteSession(), the first and the only
3108 * entry in remoteControls is that remote session
3109 */
3110 LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
3111 rc = mData->mSession.mRemoteControls.front()->AssignRemoteMachine(sessionMachine, console);
3112 LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
3113
3114 /* The failure may occur w/o any error info (from RPC), so provide one */
3115 if (FAILED(rc))
3116 setError(VBOX_E_VM_ERROR,
3117 tr("Failed to assign the machine to the remote session (%Rrc)"), rc);
3118 }
3119
3120 if (FAILED(rc))
3121 pSessionControl->Uninitialize();
3122 }
3123
3124 /* enter the lock again */
3125 alock.enter();
3126
3127 /* Restore the session state */
3128 mData->mSession.mState = origState;
3129 }
3130
3131 // finalize spawning anyway (this is why we don't return on errors above)
3132 if (fLaunchingVMProcess)
3133 {
3134 /* Note that the progress object is finalized later */
3135 /** @todo Consider checking mData->mSession.mProgress for cancellation
3136 * around here. */
3137
3138 /* We don't reset mSession.mPid here because it is necessary for
3139 * SessionMachine::uninit() to reap the child process later. */
3140
3141 if (FAILED(rc))
3142 {
3143 /* Close the remote session, remove the remote control from the list
3144 * and reset session state to Closed (@note keep the code in sync
3145 * with the relevant part in openSession()). */
3146
3147 Assert(mData->mSession.mRemoteControls.size() == 1);
3148 if (mData->mSession.mRemoteControls.size() == 1)
3149 {
3150 ErrorInfoKeeper eik;
3151 mData->mSession.mRemoteControls.front()->Uninitialize();
3152 }
3153
3154 mData->mSession.mRemoteControls.clear();
3155 mData->mSession.mState = SessionState_Unlocked;
3156 }
3157 }
3158 else
3159 {
3160 /* memorize PID of the directly opened session */
3161 if (SUCCEEDED(rc))
3162 mData->mSession.mPid = pid;
3163 }
3164
3165 if (SUCCEEDED(rc))
3166 {
3167 /* memorize the direct session control and cache IUnknown for it */
3168 mData->mSession.mDirectControl = pSessionControl;
3169 mData->mSession.mState = SessionState_Locked;
3170 /* associate the SessionMachine with this Machine */
3171 mData->mSession.mMachine = sessionMachine;
3172
3173 /* request an IUnknown pointer early from the remote party for later
3174 * identity checks (it will be internally cached within mDirectControl
3175 * at least on XPCOM) */
3176 ComPtr<IUnknown> unk = mData->mSession.mDirectControl;
3177 NOREF(unk);
3178 }
3179
3180 /* Leave the lock since SessionMachine::uninit() locks VirtualBox which
3181 * would break the lock order */
3182 alock.leave();
3183
3184 /* uninitialize the created session machine on failure */
3185 if (FAILED(rc))
3186 sessionMachine->uninit();
3187
3188 }
3189
3190 if (SUCCEEDED(rc))
3191 {
3192 /*
3193 * tell the client watcher thread to update the set of
3194 * machines that have open sessions
3195 */
3196 mParent->updateClientWatcher();
3197
3198 if (oldState != SessionState_Locked)
3199 /* fire an event */
3200 mParent->onSessionStateChange(getId(), SessionState_Locked);
3201 }
3202
3203 return rc;
3204}
3205
3206/**
3207 * @note Locks objects!
3208 */
3209STDMETHODIMP Machine::LaunchVMProcess(ISession *aSession,
3210 IN_BSTR aType,
3211 IN_BSTR aEnvironment,
3212 IProgress **aProgress)
3213{
3214 CheckComArgNotNull(aSession);
3215 CheckComArgStrNotEmptyOrNull(aType);
3216 CheckComArgOutSafeArrayPointerValid(aProgress);
3217
3218 AutoCaller autoCaller(this);
3219 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3220
3221 /* check the session state */
3222 SessionState_T state;
3223 HRESULT rc = aSession->COMGETTER(State)(&state);
3224 if (FAILED(rc)) return rc;
3225
3226 if (state != SessionState_Unlocked)
3227 return setError(VBOX_E_INVALID_OBJECT_STATE,
3228 tr("The given session is busy"));
3229
3230 /* get the IInternalSessionControl interface */
3231 ComPtr<IInternalSessionControl> control = aSession;
3232 ComAssertMsgRet(!!control, ("No IInternalSessionControl interface"),
3233 E_INVALIDARG);
3234
3235 /* get the teleporter enable state for the progress object init. */
3236 BOOL fTeleporterEnabled;
3237 rc = COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
3238 if (FAILED(rc))
3239 return rc;
3240
3241 /* create a progress object */
3242 ComObjPtr<ProgressProxy> progress;
3243 progress.createObject();
3244 rc = progress->init(mParent,
3245 static_cast<IMachine*>(this),
3246 Bstr(tr("Spawning session")).raw(),
3247 TRUE /* aCancelable */,
3248 fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
3249 Bstr(tr("Spawning session")).raw(),
3250 2 /* uFirstOperationWeight */,
3251 fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
3252 if (SUCCEEDED(rc))
3253 {
3254 rc = openRemoteSession(control, aType, aEnvironment, progress);
3255 if (SUCCEEDED(rc))
3256 {
3257 progress.queryInterfaceTo(aProgress);
3258
3259 /* signal the client watcher thread */
3260 mParent->updateClientWatcher();
3261
3262 /* fire an event */
3263 mParent->onSessionStateChange(getId(), SessionState_Spawning);
3264 }
3265 }
3266
3267 return rc;
3268}
3269
3270STDMETHODIMP Machine::SetBootOrder(ULONG aPosition, DeviceType_T aDevice)
3271{
3272 if (aPosition < 1 || aPosition > SchemaDefs::MaxBootPosition)
3273 return setError(E_INVALIDARG,
3274 tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3275 aPosition, SchemaDefs::MaxBootPosition);
3276
3277 if (aDevice == DeviceType_USB)
3278 return setError(E_NOTIMPL,
3279 tr("Booting from USB device is currently not supported"));
3280
3281 AutoCaller autoCaller(this);
3282 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3283
3284 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3285
3286 HRESULT rc = checkStateDependency(MutableStateDep);
3287 if (FAILED(rc)) return rc;
3288
3289 setModified(IsModified_MachineData);
3290 mHWData.backup();
3291 mHWData->mBootOrder[aPosition - 1] = aDevice;
3292
3293 return S_OK;
3294}
3295
3296STDMETHODIMP Machine::GetBootOrder(ULONG aPosition, DeviceType_T *aDevice)
3297{
3298 if (aPosition < 1 || aPosition > SchemaDefs::MaxBootPosition)
3299 return setError(E_INVALIDARG,
3300 tr("Invalid boot position: %lu (must be in range [1, %lu])"),
3301 aPosition, SchemaDefs::MaxBootPosition);
3302
3303 AutoCaller autoCaller(this);
3304 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3305
3306 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3307
3308 *aDevice = mHWData->mBootOrder[aPosition - 1];
3309
3310 return S_OK;
3311}
3312
3313STDMETHODIMP Machine::AttachDevice(IN_BSTR aControllerName,
3314 LONG aControllerPort,
3315 LONG aDevice,
3316 DeviceType_T aType,
3317 IMedium *aMedium)
3318{
3319 LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d aType=%d aId=\"%ls\"\n",
3320 aControllerName, aControllerPort, aDevice, aType, aMedium));
3321
3322 CheckComArgStrNotEmptyOrNull(aControllerName);
3323
3324 AutoCaller autoCaller(this);
3325 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3326
3327 // if this becomes true then we need to call saveSettings in the end
3328 // @todo r=dj there is no error handling so far...
3329 bool fNeedsGlobalSaveSettings = false;
3330
3331 // request the host lock first, since might be calling Host methods for getting host drives;
3332 // next, protect the media tree all the while we're in here, as well as our member variables
3333 AutoMultiWriteLock2 alock(mParent->host()->lockHandle(),
3334 this->lockHandle() COMMA_LOCKVAL_SRC_POS);
3335 AutoWriteLock treeLock(&mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
3336
3337 HRESULT rc = checkStateDependency(MutableStateDep);
3338 if (FAILED(rc)) return rc;
3339
3340 /// @todo NEWMEDIA implicit machine registration
3341 if (!mData->mRegistered)
3342 return setError(VBOX_E_INVALID_OBJECT_STATE,
3343 tr("Cannot attach storage devices to an unregistered machine"));
3344
3345 AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3346
3347 if (Global::IsOnlineOrTransient(mData->mMachineState))
3348 return setError(VBOX_E_INVALID_VM_STATE,
3349 tr("Invalid machine state: %s"),
3350 Global::stringifyMachineState(mData->mMachineState));
3351
3352 /* Check for an existing controller. */
3353 ComObjPtr<StorageController> ctl;
3354 rc = getStorageControllerByName(aControllerName, ctl, true /* aSetError */);
3355 if (FAILED(rc)) return rc;
3356
3357 // check that the port and device are not out of range
3358 rc = ctl->checkPortAndDeviceValid(aControllerPort, aDevice);
3359 if (FAILED(rc)) return rc;
3360
3361 /* check if the device slot is already busy */
3362 MediumAttachment *pAttachTemp;
3363 if ((pAttachTemp = findAttachment(mMediaData->mAttachments,
3364 aControllerName,
3365 aControllerPort,
3366 aDevice)))
3367 {
3368 Medium *pMedium = pAttachTemp->getMedium();
3369 if (pMedium)
3370 {
3371 AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
3372 return setError(VBOX_E_OBJECT_IN_USE,
3373 tr("Medium '%s' is already attached to port %d, device %d of controller '%ls' of this virtual machine"),
3374 pMedium->getLocationFull().c_str(),
3375 aControllerPort,
3376 aDevice,
3377 aControllerName);
3378 }
3379 else
3380 return setError(VBOX_E_OBJECT_IN_USE,
3381 tr("Device is already attached to port %d, device %d of controller '%ls' of this virtual machine"),
3382 aControllerPort, aDevice, aControllerName);
3383 }
3384
3385 ComObjPtr<Medium> medium = static_cast<Medium*>(aMedium);
3386 if (aMedium && medium.isNull())
3387 return setError(E_INVALIDARG, "The given medium pointer is invalid");
3388
3389 AutoCaller mediumCaller(medium);
3390 if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3391
3392 AutoWriteLock mediumLock(medium COMMA_LOCKVAL_SRC_POS);
3393
3394 if ( (pAttachTemp = findAttachment(mMediaData->mAttachments, medium))
3395 && !medium.isNull()
3396 )
3397 return setError(VBOX_E_OBJECT_IN_USE,
3398 tr("Medium '%s' is already attached to this virtual machine"),
3399 medium->getLocationFull().c_str());
3400
3401 bool fIndirect = false;
3402 if (!medium.isNull())
3403 fIndirect = medium->isReadOnly();
3404 bool associate = true;
3405
3406 do
3407 {
3408 if ( aType == DeviceType_HardDisk
3409 && mMediaData.isBackedUp())
3410 {
3411 const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
3412
3413 /* check if the medium was attached to the VM before we started
3414 * changing attachments in which case the attachment just needs to
3415 * be restored */
3416 if ((pAttachTemp = findAttachment(oldAtts, medium)))
3417 {
3418 AssertReturn(!fIndirect, E_FAIL);
3419
3420 /* see if it's the same bus/channel/device */
3421 if (pAttachTemp->matches(aControllerName, aControllerPort, aDevice))
3422 {
3423 /* the simplest case: restore the whole attachment
3424 * and return, nothing else to do */
3425 mMediaData->mAttachments.push_back(pAttachTemp);
3426 return S_OK;
3427 }
3428
3429 /* bus/channel/device differ; we need a new attachment object,
3430 * but don't try to associate it again */
3431 associate = false;
3432 break;
3433 }
3434 }
3435
3436 /* go further only if the attachment is to be indirect */
3437 if (!fIndirect)
3438 break;
3439
3440 /* perform the so called smart attachment logic for indirect
3441 * attachments. Note that smart attachment is only applicable to base
3442 * hard disks. */
3443
3444 if (medium->getParent().isNull())
3445 {
3446 /* first, investigate the backup copy of the current hard disk
3447 * attachments to make it possible to re-attach existing diffs to
3448 * another device slot w/o losing their contents */
3449 if (mMediaData.isBackedUp())
3450 {
3451 const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
3452
3453 MediaData::AttachmentList::const_iterator foundIt = oldAtts.end();
3454 uint32_t foundLevel = 0;
3455
3456 for (MediaData::AttachmentList::const_iterator it = oldAtts.begin();
3457 it != oldAtts.end();
3458 ++it)
3459 {
3460 uint32_t level = 0;
3461 MediumAttachment *pAttach = *it;
3462 ComObjPtr<Medium> pMedium = pAttach->getMedium();
3463 Assert(!pMedium.isNull() || pAttach->getType() != DeviceType_HardDisk);
3464 if (pMedium.isNull())
3465 continue;
3466
3467 if (pMedium->getBase(&level) == medium)
3468 {
3469 /* skip the hard disk if its currently attached (we
3470 * cannot attach the same hard disk twice) */
3471 if (findAttachment(mMediaData->mAttachments,
3472 pMedium))
3473 continue;
3474
3475 /* matched device, channel and bus (i.e. attached to the
3476 * same place) will win and immediately stop the search;
3477 * otherwise the attachment that has the youngest
3478 * descendant of medium will be used
3479 */
3480 if (pAttach->matches(aControllerName, aControllerPort, aDevice))
3481 {
3482 /* the simplest case: restore the whole attachment
3483 * and return, nothing else to do */
3484 mMediaData->mAttachments.push_back(*it);
3485 return S_OK;
3486 }
3487 else if ( foundIt == oldAtts.end()
3488 || level > foundLevel /* prefer younger */
3489 )
3490 {
3491 foundIt = it;
3492 foundLevel = level;
3493 }
3494 }
3495 }
3496
3497 if (foundIt != oldAtts.end())
3498 {
3499 /* use the previously attached hard disk */
3500 medium = (*foundIt)->getMedium();
3501 mediumCaller.attach(medium);
3502 if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3503 mediumLock.attach(medium);
3504 /* not implicit, doesn't require association with this VM */
3505 fIndirect = false;
3506 associate = false;
3507 /* go right to the MediumAttachment creation */
3508 break;
3509 }
3510 }
3511
3512 /* must give up the medium lock and medium tree lock as below we
3513 * go over snapshots, which needs a lock with higher lock order. */
3514 mediumLock.release();
3515 treeLock.release();
3516
3517 /* then, search through snapshots for the best diff in the given
3518 * hard disk's chain to base the new diff on */
3519
3520 ComObjPtr<Medium> base;
3521 ComObjPtr<Snapshot> snap = mData->mCurrentSnapshot;
3522 while (snap)
3523 {
3524 AutoReadLock snapLock(snap COMMA_LOCKVAL_SRC_POS);
3525
3526 const MediaData::AttachmentList &snapAtts = snap->getSnapshotMachine()->mMediaData->mAttachments;
3527
3528 MediumAttachment *pAttachFound = NULL;
3529 uint32_t foundLevel = 0;
3530
3531 for (MediaData::AttachmentList::const_iterator it = snapAtts.begin();
3532 it != snapAtts.end();
3533 ++it)
3534 {
3535 MediumAttachment *pAttach = *it;
3536 ComObjPtr<Medium> pMedium = pAttach->getMedium();
3537 Assert(!pMedium.isNull() || pAttach->getType() != DeviceType_HardDisk);
3538 if (pMedium.isNull())
3539 continue;
3540
3541 uint32_t level = 0;
3542 if (pMedium->getBase(&level) == medium)
3543 {
3544 /* matched device, channel and bus (i.e. attached to the
3545 * same place) will win and immediately stop the search;
3546 * otherwise the attachment that has the youngest
3547 * descendant of medium will be used
3548 */
3549 if ( pAttach->getDevice() == aDevice
3550 && pAttach->getPort() == aControllerPort
3551 && pAttach->getControllerName() == aControllerName
3552 )
3553 {
3554 pAttachFound = pAttach;
3555 break;
3556 }
3557 else if ( !pAttachFound
3558 || level > foundLevel /* prefer younger */
3559 )
3560 {
3561 pAttachFound = pAttach;
3562 foundLevel = level;
3563 }
3564 }
3565 }
3566
3567 if (pAttachFound)
3568 {
3569 base = pAttachFound->getMedium();
3570 break;
3571 }
3572
3573 snap = snap->getParent();
3574 }
3575
3576 /* re-lock medium tree and the medium, as we need it below */
3577 treeLock.acquire();
3578 mediumLock.acquire();
3579
3580 /* found a suitable diff, use it as a base */
3581 if (!base.isNull())
3582 {
3583 medium = base;
3584 mediumCaller.attach(medium);
3585 if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3586 mediumLock.attach(medium);
3587 }
3588 }
3589
3590 ComObjPtr<Medium> diff;
3591 diff.createObject();
3592 rc = diff->init(mParent,
3593 medium->getPreferredDiffFormat(),
3594 Utf8Str(mUserData->m_strSnapshotFolderFull).append(RTPATH_SLASH_STR),
3595 medium->getRegistryMachineId(), // store this diff in the same registry as the parent
3596 &fNeedsGlobalSaveSettings);
3597 if (FAILED(rc)) return rc;
3598
3599 /* Apply the normal locking logic to the entire chain. */
3600 MediumLockList *pMediumLockList(new MediumLockList());
3601 rc = diff->createMediumLockList(true /* fFailIfInaccessible */,
3602 true /* fMediumLockWrite */,
3603 medium,
3604 *pMediumLockList);
3605 if (SUCCEEDED(rc))
3606 {
3607 rc = pMediumLockList->Lock();
3608 if (FAILED(rc))
3609 setError(rc,
3610 tr("Could not lock medium when creating diff '%s'"),
3611 diff->getLocationFull().c_str());
3612 else
3613 {
3614 /* will leave the lock before the potentially lengthy operation, so
3615 * protect with the special state */
3616 MachineState_T oldState = mData->mMachineState;
3617 setMachineState(MachineState_SettingUp);
3618
3619 mediumLock.leave();
3620 treeLock.leave();
3621 alock.leave();
3622
3623 rc = medium->createDiffStorage(diff,
3624 MediumVariant_Standard,
3625 pMediumLockList,
3626 NULL /* aProgress */,
3627 true /* aWait */,
3628 &fNeedsGlobalSaveSettings);
3629
3630 alock.enter();
3631 treeLock.enter();
3632 mediumLock.enter();
3633
3634 setMachineState(oldState);
3635 }
3636 }
3637
3638 /* Unlock the media and free the associated memory. */
3639 delete pMediumLockList;
3640
3641 if (FAILED(rc)) return rc;
3642
3643 /* use the created diff for the actual attachment */
3644 medium = diff;
3645 mediumCaller.attach(medium);
3646 if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
3647 mediumLock.attach(medium);
3648 }
3649 while (0);
3650
3651 ComObjPtr<MediumAttachment> attachment;
3652 attachment.createObject();
3653 rc = attachment->init(this,
3654 medium,
3655 aControllerName,
3656 aControllerPort,
3657 aDevice,
3658 aType,
3659 fIndirect,
3660 0 /* No bandwidth limit */);
3661 if (FAILED(rc)) return rc;
3662
3663 if (associate && !medium.isNull())
3664 {
3665 // as the last step, associate the medium to the VM
3666 rc = medium->addBackReference(mData->mUuid);
3667 // here we can fail because of Deleting, or being in process of creating a Diff
3668 if (FAILED(rc)) return rc;
3669
3670 // and decide which medium registry to use now that the medium is attached:
3671 if (mData->pMachineConfigFile->canHaveOwnMediaRegistry())
3672 // machine XML is VirtualBox 4.0 or higher:
3673 medium->setRegistryIdIfFirst(getId()); // machine UUID
3674 else
3675 medium->setRegistryIdIfFirst(mParent->getGlobalRegistryId()); // VirtualBox global registry UUID
3676 }
3677
3678 /* success: finally remember the attachment */
3679 setModified(IsModified_Storage);
3680 mMediaData.backup();
3681 mMediaData->mAttachments.push_back(attachment);
3682
3683 if (fNeedsGlobalSaveSettings)
3684 {
3685 // save the global settings; for that we should hold only the VirtualBox lock
3686 mediumLock.release();
3687 treeLock.leave();
3688 alock.release();
3689
3690 AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
3691 mParent->saveSettings();
3692 }
3693
3694 return rc;
3695}
3696
3697STDMETHODIMP Machine::DetachDevice(IN_BSTR aControllerName, LONG aControllerPort,
3698 LONG aDevice)
3699{
3700 CheckComArgStrNotEmptyOrNull(aControllerName);
3701
3702 LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%ld aDevice=%ld\n",
3703 aControllerName, aControllerPort, aDevice));
3704
3705 AutoCaller autoCaller(this);
3706 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3707
3708 bool fNeedsSaveSettings = false;
3709
3710 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3711
3712 HRESULT rc = checkStateDependency(MutableStateDep);
3713 if (FAILED(rc)) return rc;
3714
3715 AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3716
3717 if (Global::IsOnlineOrTransient(mData->mMachineState))
3718 return setError(VBOX_E_INVALID_VM_STATE,
3719 tr("Invalid machine state: %s"),
3720 Global::stringifyMachineState(mData->mMachineState));
3721
3722 MediumAttachment *pAttach = findAttachment(mMediaData->mAttachments,
3723 aControllerName,
3724 aControllerPort,
3725 aDevice);
3726 if (!pAttach)
3727 return setError(VBOX_E_OBJECT_NOT_FOUND,
3728 tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
3729 aDevice, aControllerPort, aControllerName);
3730
3731 rc = detachDevice(pAttach, alock, NULL /* pSnapshot */, &fNeedsSaveSettings);
3732
3733 if (fNeedsSaveSettings)
3734 {
3735 bool fNeedsGlobalSaveSettings = false;
3736 saveSettings(&fNeedsGlobalSaveSettings);
3737
3738 if (fNeedsGlobalSaveSettings)
3739 {
3740 // save the global settings; for that we should hold only the VirtualBox lock
3741 alock.release();
3742 AutoWriteLock vboxlock(this COMMA_LOCKVAL_SRC_POS);
3743 mParent->saveSettings();
3744 }
3745 }
3746
3747 return S_OK;
3748}
3749
3750STDMETHODIMP Machine::PassthroughDevice(IN_BSTR aControllerName, LONG aControllerPort,
3751 LONG aDevice, BOOL aPassthrough)
3752{
3753 CheckComArgStrNotEmptyOrNull(aControllerName);
3754
3755 LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%ld aDevice=%ld aPassthrough=%d\n",
3756 aControllerName, aControllerPort, aDevice, aPassthrough));
3757
3758 AutoCaller autoCaller(this);
3759 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3760
3761 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3762
3763 HRESULT rc = checkStateDependency(MutableStateDep);
3764 if (FAILED(rc)) return rc;
3765
3766 AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
3767
3768 if (Global::IsOnlineOrTransient(mData->mMachineState))
3769 return setError(VBOX_E_INVALID_VM_STATE,
3770 tr("Invalid machine state: %s"),
3771 Global::stringifyMachineState(mData->mMachineState));
3772
3773 MediumAttachment *pAttach = findAttachment(mMediaData->mAttachments,
3774 aControllerName,
3775 aControllerPort,
3776 aDevice);
3777 if (!pAttach)
3778 return setError(VBOX_E_OBJECT_NOT_FOUND,
3779 tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
3780 aDevice, aControllerPort, aControllerName);
3781
3782
3783 setModified(IsModified_Storage);
3784 mMediaData.backup();
3785
3786 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
3787
3788 if (pAttach->getType() != DeviceType_DVD)
3789 return setError(E_INVALIDARG,
3790 tr("Setting passthrough rejected as the device attached to device slot %d on port %d of controller '%ls' is not a DVD"),
3791 aDevice, aControllerPort, aControllerName);
3792 pAttach->updatePassthrough(!!aPassthrough);
3793
3794 return S_OK;
3795}
3796
3797STDMETHODIMP Machine::MountMedium(IN_BSTR aControllerName,
3798 LONG aControllerPort,
3799 LONG aDevice,
3800 IN_BSTR aId,
3801 BOOL aForce)
3802{
3803 int rc = S_OK;
3804 LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%ld aDevice=%ld aForce=%d\n",
3805 aControllerName, aControllerPort, aDevice, aForce));
3806
3807 CheckComArgStrNotEmptyOrNull(aControllerName);
3808
3809 AutoCaller autoCaller(this);
3810 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3811
3812 // we're calling host methods for getting DVD and floppy drives so lock host first
3813 AutoMultiWriteLock2 alock(mParent->host(), this COMMA_LOCKVAL_SRC_POS);
3814
3815 ComObjPtr<MediumAttachment> pAttach = findAttachment(mMediaData->mAttachments,
3816 aControllerName,
3817 aControllerPort,
3818 aDevice);
3819 if (pAttach.isNull())
3820 return setError(VBOX_E_OBJECT_NOT_FOUND,
3821 tr("No drive attached to device slot %d on port %d of controller '%ls'"),
3822 aDevice, aControllerPort, aControllerName);
3823
3824 /* Remember previously mounted medium. The medium before taking the
3825 * backup is not necessarily the same thing. */
3826 ComObjPtr<Medium> oldmedium;
3827 oldmedium = pAttach->getMedium();
3828
3829 Guid uuid(aId);
3830 ComObjPtr<Medium> medium;
3831 DeviceType_T mediumType = pAttach->getType();
3832 switch (mediumType)
3833 {
3834 case DeviceType_DVD:
3835 case DeviceType_Floppy:
3836 rc = mParent->findRemoveableMedium(mediumType, uuid, true /* fRefresh */, medium);
3837 if (FAILED(rc)) return rc;
3838 break;
3839
3840 default:
3841 return setError(VBOX_E_INVALID_OBJECT_STATE,
3842 tr("Cannot change medium attached to device slot %d on port %d of controller '%ls'"),
3843 aDevice, aControllerPort, aControllerName);
3844 }
3845
3846 if (SUCCEEDED(rc))
3847 {
3848 setModified(IsModified_Storage);
3849 mMediaData.backup();
3850
3851 /* The backup operation makes the pAttach reference point to the
3852 * old settings. Re-get the correct reference. */
3853 pAttach = findAttachment(mMediaData->mAttachments,
3854 aControllerName,
3855 aControllerPort,
3856 aDevice);
3857 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
3858 /* For non-hard disk media, detach straight away. */
3859 if (mediumType != DeviceType_HardDisk && !oldmedium.isNull())
3860 oldmedium->removeBackReference(mData->mUuid);
3861 if (!medium.isNull())
3862 medium->addBackReference(mData->mUuid);
3863 pAttach->updateMedium(medium, false /* aImplicit */);
3864 setModified(IsModified_Storage);
3865 }
3866
3867 alock.leave();
3868 rc = onMediumChange(pAttach, aForce);
3869 alock.enter();
3870
3871 /* On error roll back this change only. */
3872 if (FAILED(rc))
3873 {
3874 if (!medium.isNull())
3875 medium->removeBackReference(mData->mUuid);
3876 pAttach = findAttachment(mMediaData->mAttachments,
3877 aControllerName,
3878 aControllerPort,
3879 aDevice);
3880 /* If the attachment is gone in the mean time, bail out. */
3881 if (pAttach.isNull())
3882 return rc;
3883 AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
3884 /* For non-hard disk media, re-attach straight away. */
3885 if (mediumType != DeviceType_HardDisk && !oldmedium.isNull())
3886 oldmedium->addBackReference(mData->mUuid);
3887 pAttach->updateMedium(oldmedium, false /* aImplicit */);
3888 }
3889
3890 return rc;
3891}
3892
3893STDMETHODIMP Machine::GetMedium(IN_BSTR aControllerName,
3894 LONG aControllerPort,
3895 LONG aDevice,
3896 IMedium **aMedium)
3897{
3898 LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%ld aDevice=%ld\n",
3899 aControllerName, aControllerPort, aDevice));
3900
3901 CheckComArgStrNotEmptyOrNull(aControllerName);
3902 CheckComArgOutPointerValid(aMedium);
3903
3904 AutoCaller autoCaller(this);
3905 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3906
3907 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3908
3909 *aMedium = NULL;
3910
3911 ComObjPtr<MediumAttachment> pAttach = findAttachment(mMediaData->mAttachments,
3912 aControllerName,
3913 aControllerPort,
3914 aDevice);
3915 if (pAttach.isNull())
3916 return setError(VBOX_E_OBJECT_NOT_FOUND,
3917 tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
3918 aDevice, aControllerPort, aControllerName);
3919
3920 pAttach->getMedium().queryInterfaceTo(aMedium);
3921
3922 return S_OK;
3923}
3924
3925STDMETHODIMP Machine::GetSerialPort(ULONG slot, ISerialPort **port)
3926{
3927 CheckComArgOutPointerValid(port);
3928 CheckComArgExpr(slot, slot < RT_ELEMENTS(mSerialPorts));
3929
3930 AutoCaller autoCaller(this);
3931 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3932
3933 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3934
3935 mSerialPorts[slot].queryInterfaceTo(port);
3936
3937 return S_OK;
3938}
3939
3940STDMETHODIMP Machine::GetParallelPort(ULONG slot, IParallelPort **port)
3941{
3942 CheckComArgOutPointerValid(port);
3943 CheckComArgExpr(slot, slot < RT_ELEMENTS(mParallelPorts));
3944
3945 AutoCaller autoCaller(this);
3946 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3947
3948 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3949
3950 mParallelPorts[slot].queryInterfaceTo(port);
3951
3952 return S_OK;
3953}
3954
3955STDMETHODIMP Machine::GetNetworkAdapter(ULONG slot, INetworkAdapter **adapter)
3956{
3957 CheckComArgOutPointerValid(adapter);
3958 CheckComArgExpr(slot, slot < RT_ELEMENTS(mNetworkAdapters));
3959
3960 AutoCaller autoCaller(this);
3961 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3962
3963 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3964
3965 mNetworkAdapters[slot].queryInterfaceTo(adapter);
3966
3967 return S_OK;
3968}
3969
3970STDMETHODIMP Machine::GetExtraDataKeys(ComSafeArrayOut(BSTR, aKeys))
3971{
3972 if (ComSafeArrayOutIsNull(aKeys))
3973 return E_POINTER;
3974
3975 AutoCaller autoCaller(this);
3976 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3977
3978 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3979
3980 com::SafeArray<BSTR> saKeys(mData->pMachineConfigFile->mapExtraDataItems.size());
3981 int i = 0;
3982 for (settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.begin();
3983 it != mData->pMachineConfigFile->mapExtraDataItems.end();
3984 ++it, ++i)
3985 {
3986 const Utf8Str &strKey = it->first;
3987 strKey.cloneTo(&saKeys[i]);
3988 }
3989 saKeys.detachTo(ComSafeArrayOutArg(aKeys));
3990
3991 return S_OK;
3992 }
3993
3994 /**
3995 * @note Locks this object for reading.
3996 */
3997STDMETHODIMP Machine::GetExtraData(IN_BSTR aKey,
3998 BSTR *aValue)
3999{
4000 CheckComArgStrNotEmptyOrNull(aKey);
4001 CheckComArgOutPointerValid(aValue);
4002
4003 AutoCaller autoCaller(this);
4004 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4005
4006 /* start with nothing found */
4007 Bstr bstrResult("");
4008
4009 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4010
4011 settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(Utf8Str(aKey));
4012 if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4013 // found:
4014 bstrResult = it->second; // source is a Utf8Str
4015
4016 /* return the result to caller (may be empty) */
4017 bstrResult.cloneTo(aValue);
4018
4019 return S_OK;
4020}
4021
4022 /**
4023 * @note Locks mParent for writing + this object for writing.
4024 */
4025STDMETHODIMP Machine::SetExtraData(IN_BSTR aKey, IN_BSTR aValue)
4026{
4027 CheckComArgStrNotEmptyOrNull(aKey);
4028
4029 AutoCaller autoCaller(this);
4030 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4031
4032 Utf8Str strKey(aKey);
4033 Utf8Str strValue(aValue);
4034 Utf8Str strOldValue; // empty
4035
4036 // locking note: we only hold the read lock briefly to look up the old value,
4037 // then release it and call the onExtraCanChange callbacks. There is a small
4038 // chance of a race insofar as the callback might be called twice if two callers
4039 // change the same key at the same time, but that's a much better solution
4040 // than the deadlock we had here before. The actual changing of the extradata
4041 // is then performed under the write lock and race-free.
4042
4043 // look up the old value first; if nothing's changed then we need not do anything
4044 {
4045 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); // hold read lock only while looking up
4046 settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(strKey);
4047 if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
4048 strOldValue = it->second;
4049 }
4050
4051 bool fChanged;
4052 if ((fChanged = (strOldValue != strValue)))
4053 {
4054 // ask for permission from all listeners outside the locks;
4055 // onExtraDataCanChange() only briefly requests the VirtualBox
4056 // lock to copy the list of callbacks to invoke
4057 Bstr error;
4058 Bstr bstrValue(aValue);
4059
4060 if (!mParent->onExtraDataCanChange(mData->mUuid, aKey, bstrValue.raw(), error))
4061 {
4062 const char *sep = error.isEmpty() ? "" : ": ";
4063 CBSTR err = error.raw();
4064 LogWarningFunc(("Someone vetoed! Change refused%s%ls\n",
4065 sep, err));
4066 return setError(E_ACCESSDENIED,
4067 tr("Could not set extra data because someone refused the requested change of '%ls' to '%ls'%s%ls"),
4068 aKey,
4069 bstrValue.raw(),
4070 sep,
4071 err);
4072 }
4073
4074 // data is changing and change not vetoed: then write it out under the lock
4075 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4076
4077 if (isSnapshotMachine())
4078 {
4079 HRESULT rc = checkStateDependency(MutableStateDep);
4080 if (FAILED(rc)) return rc;
4081 }
4082
4083 if (strValue.isEmpty())
4084 mData->pMachineConfigFile->mapExtraDataItems.erase(strKey);
4085 else
4086 mData->pMachineConfigFile->mapExtraDataItems[strKey] = strValue;
4087 // creates a new key if needed
4088
4089 bool fNeedsGlobalSaveSettings = false;
4090 saveSettings(&fNeedsGlobalSaveSettings);
4091
4092 if (fNeedsGlobalSaveSettings)
4093 {
4094 // save the global settings; for that we should hold only the VirtualBox lock
4095 alock.release();
4096 AutoWriteLock vboxlock(mParent COMMA_LOCKVAL_SRC_POS);
4097 mParent->saveSettings();
4098 }
4099 }
4100
4101 // fire notification outside the lock
4102 if (fChanged)
4103 mParent->onExtraDataChange(mData->mUuid, aKey, aValue);
4104
4105 return S_OK;
4106}
4107
4108STDMETHODIMP Machine::SaveSettings()
4109{
4110 AutoCaller autoCaller(this);
4111 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4112
4113 AutoWriteLock mlock(this COMMA_LOCKVAL_SRC_POS);
4114
4115 /* when there was auto-conversion, we want to save the file even if
4116 * the VM is saved */
4117 HRESULT rc = checkStateDependency(MutableStateDep);
4118 if (FAILED(rc)) return rc;
4119
4120 /* the settings file path may never be null */
4121 ComAssertRet(!mData->m_strConfigFileFull.isEmpty(), E_FAIL);
4122
4123 /* save all VM data excluding snapshots */
4124 bool fNeedsGlobalSaveSettings = false;
4125 rc = saveSettings(&fNeedsGlobalSaveSettings);
4126 mlock.release();
4127
4128 if (SUCCEEDED(rc) && fNeedsGlobalSaveSettings)
4129 {
4130 // save the global settings; for that we should hold only the VirtualBox lock
4131 AutoWriteLock vlock(mParent COMMA_LOCKVAL_SRC_POS);
4132 rc = mParent->saveSettings();
4133 }
4134
4135 return rc;
4136}
4137
4138STDMETHODIMP Machine::DiscardSettings()
4139{
4140 AutoCaller autoCaller(this);
4141 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4142
4143 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4144
4145 HRESULT rc = checkStateDependency(MutableStateDep);
4146 if (FAILED(rc)) return rc;
4147
4148 /*
4149 * during this rollback, the session will be notified if data has
4150 * been actually changed
4151 */
4152 rollback(true /* aNotify */);
4153
4154 return S_OK;
4155}
4156
4157/** @note Locks objects! */
4158STDMETHODIMP Machine::Unregister(CleanupMode_T cleanupMode,
4159 ComSafeArrayOut(IMedium*, aMedia))
4160{
4161 // use AutoLimitedCaller because this call is valid on inaccessible machines as well
4162 AutoLimitedCaller autoCaller(this);
4163 AssertComRCReturnRC(autoCaller.rc());
4164
4165 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4166
4167 Guid id(getId());
4168
4169 if (mData->mSession.mState != SessionState_Unlocked)
4170 return setError(VBOX_E_INVALID_OBJECT_STATE,
4171 tr("Cannot unregister the machine '%s' while it is locked"),
4172 mUserData->s.strName.c_str());
4173
4174 // wait for state dependants to drop to zero
4175 ensureNoStateDependencies();
4176
4177 if (!mData->mAccessible)
4178 {
4179 // inaccessible maschines can only be unregistered; uninitialize ourselves
4180 // here because currently there may be no unregistered that are inaccessible
4181 // (this state combination is not supported). Note releasing the caller and
4182 // leaving the lock before alling uninit()
4183 alock.leave();
4184 autoCaller.release();
4185
4186 uninit();
4187
4188 mParent->unregisterMachine(this, id);
4189 // calls VirtualBox::saveSettings()
4190
4191 return S_OK;
4192 }
4193
4194 HRESULT rc = S_OK;
4195
4196 // discard saved state
4197 if (mData->mMachineState == MachineState_Saved)
4198 {
4199 // add the saved state file to the list of files the caller should delete
4200 Assert(!mSSData->mStateFilePath.isEmpty());
4201 mData->llFilesToDelete.push_back(mSSData->mStateFilePath);
4202
4203 mSSData->mStateFilePath.setNull();
4204
4205 // unconditionally set the machine state to powered off, we now
4206 // know no session has locked the machine
4207 mData->mMachineState = MachineState_PoweredOff;
4208 }
4209
4210 size_t cSnapshots = 0;
4211 if (mData->mFirstSnapshot)
4212 cSnapshots = mData->mFirstSnapshot->getAllChildrenCount() + 1;
4213 if (cSnapshots && cleanupMode == CleanupMode_UnregisterOnly)
4214 // fail now before we start detaching media
4215 return setError(VBOX_E_INVALID_OBJECT_STATE,
4216 tr("Cannot unregister the machine '%s' because it has %d snapshots"),
4217 mUserData->s.strName.c_str(), cSnapshots);
4218
4219 // this list collects the medium objects from all medium attachments
4220 // which got detached from the machine and its snapshots, in the following
4221 // order:
4222 // 1) media from machine attachments (these have the "leaf" attachments with snapshots
4223 // and must be closed first, or closing the parents will fail because they will
4224 // children);
4225 // 2) media from the youngest snapshots followed those from the parent snapshots until
4226 // the root ("first") snapshot of the machine
4227 // This order allows for closing the media on this list from the beginning to the end
4228 // without getting "media in use" errors.
4229 MediaList llMedia;
4230
4231 if ( !mMediaData.isNull() // can be NULL if machine is inaccessible
4232 && mMediaData->mAttachments.size()
4233 )
4234 {
4235 // we have media attachments: detach them all and add the Medium objects to our list
4236 if (cleanupMode != CleanupMode_UnregisterOnly)
4237 detachAllMedia(alock, NULL /* pSnapshot */, cleanupMode, llMedia);
4238 else
4239 return setError(VBOX_E_INVALID_OBJECT_STATE,
4240 tr("Cannot unregister the machine '%s' because it has %d media attachments"),
4241 mUserData->s.strName.c_str(), mMediaData->mAttachments.size());
4242 }
4243
4244 if (cSnapshots)
4245 {
4246 // autoCleanup must be true here, or we would have failed above
4247
4248 // add the media from the medium attachments of the snapshots to llMedia
4249 // as well, after the "main" machine media; Snapshot::uninitRecursively()
4250 // calls Machine::detachAllMedia() for the snapshot machine, recursing
4251 // into the children first
4252
4253 // Snapshot::beginDeletingSnapshot() asserts if the machine state is not this
4254 MachineState_T oldState = mData->mMachineState;
4255 mData->mMachineState = MachineState_DeletingSnapshot;
4256
4257 // make a copy of the first snapshot so the refcount does not drop to 0
4258 // in beginDeletingSnapshot, which sets pFirstSnapshot to 0 (that hangs
4259 // because of the AutoCaller voodoo)
4260 ComObjPtr<Snapshot> pFirstSnapshot = mData->mFirstSnapshot;
4261
4262 // GO!
4263 pFirstSnapshot->uninitRecursively(alock, cleanupMode, llMedia, mData->llFilesToDelete);
4264
4265 mData->mMachineState = oldState;
4266 }
4267
4268 if (FAILED(rc))
4269 {
4270 rollbackMedia();
4271 return rc;
4272 }
4273
4274 // commit all the media changes made above
4275 commitMedia();
4276
4277 mData->mRegistered = false;
4278
4279 // machine lock no longer needed
4280 alock.release();
4281
4282 // return media to caller
4283 SafeIfaceArray<IMedium> sfaMedia(llMedia);
4284 sfaMedia.detachTo(ComSafeArrayOutArg(aMedia));
4285
4286 mParent->unregisterMachine(this, id);
4287 // calls VirtualBox::saveSettings()
4288
4289 return S_OK;
4290}
4291
4292struct Machine::DeleteTask
4293{
4294 ComObjPtr<Machine> pMachine;
4295 std::list<Utf8Str> llFilesToDelete;
4296 ComObjPtr<Progress> pProgress;
4297 bool fNeedsGlobalSaveSettings;
4298};
4299
4300STDMETHODIMP Machine::Delete(ComSafeArrayIn(IMedium*, aMedia), IProgress **aProgress)
4301{
4302 LogFlowFuncEnter();
4303
4304 AutoCaller autoCaller(this);
4305 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4306
4307 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4308
4309 HRESULT rc = checkStateDependency(MutableStateDep);
4310 if (FAILED(rc)) return rc;
4311
4312 if (mData->mRegistered)
4313 return setError(VBOX_E_INVALID_VM_STATE,
4314 tr("Cannot delete settings of a registered machine"));
4315
4316 DeleteTask *pTask = new DeleteTask;
4317 pTask->pMachine = this;
4318 com::SafeIfaceArray<IMedium> sfaMedia(ComSafeArrayInArg(aMedia));
4319
4320 // collect files to delete
4321 pTask->llFilesToDelete = mData->llFilesToDelete; // saved states pushed here by Unregister()
4322
4323 pTask->fNeedsGlobalSaveSettings = false;
4324 for (size_t i = 0; i < sfaMedia.size(); ++i)
4325 {
4326 IMedium *pIMedium(sfaMedia[i]);
4327 Medium *pMedium = static_cast<Medium*>(pIMedium);
4328 AutoCaller mediumAutoCaller(pMedium);
4329 if (FAILED(mediumAutoCaller.rc())) return mediumAutoCaller.rc();
4330
4331 Utf8Str bstrLocation = pMedium->getLocationFull();
4332 // close the medium now; if that succeeds, then that means the medium is no longer
4333 // in use and we can add it to the list of files to delete
4334 rc = pMedium->close(&pTask->fNeedsGlobalSaveSettings,
4335 mediumAutoCaller);
4336 if (SUCCEEDED(rc))
4337 pTask->llFilesToDelete.push_back(bstrLocation);
4338 }
4339 if (mData->pMachineConfigFile->fileExists())
4340 pTask->llFilesToDelete.push_back(mData->m_strConfigFileFull);
4341
4342 pTask->pProgress.createObject();
4343 pTask->pProgress->init(getVirtualBox(),
4344 static_cast<IMachine*>(this) /* aInitiator */,
4345 Bstr(tr("Deleting files")).raw(),
4346 true /* fCancellable */,
4347 pTask->llFilesToDelete.size() + 1, // cOperations
4348 BstrFmt(tr("Deleting '%s'"), pTask->llFilesToDelete.front().c_str()).raw());
4349
4350 int vrc = RTThreadCreate(NULL,
4351 Machine::deleteThread,
4352 (void*)pTask,
4353 0,
4354 RTTHREADTYPE_MAIN_WORKER,
4355 0,
4356 "MachineDelete");
4357
4358 pTask->pProgress.queryInterfaceTo(aProgress);
4359
4360 if (RT_FAILURE(vrc))
4361 {
4362 delete pTask;
4363 return setError(E_FAIL, "Could not create MachineDelete thread (%Rrc)", vrc);
4364 }
4365
4366 LogFlowFuncLeave();
4367
4368 return S_OK;
4369}
4370
4371/**
4372 * Static task wrapper passed to RTThreadCreate() in Machine::Delete() which then
4373 * calls Machine::deleteTaskWorker() on the actual machine object.
4374 * @param Thread
4375 * @param pvUser
4376 * @return
4377 */
4378/*static*/
4379DECLCALLBACK(int) Machine::deleteThread(RTTHREAD Thread, void *pvUser)
4380{
4381 LogFlowFuncEnter();
4382
4383 DeleteTask *pTask = (DeleteTask*)pvUser;
4384 Assert(pTask);
4385 Assert(pTask->pMachine);
4386 Assert(pTask->pProgress);
4387
4388 HRESULT rc = pTask->pMachine->deleteTaskWorker(*pTask);
4389 pTask->pProgress->notifyComplete(rc);
4390
4391 delete pTask;
4392
4393 LogFlowFuncLeave();
4394
4395 NOREF(Thread);
4396
4397 return VINF_SUCCESS;
4398}
4399
4400/**
4401 * Task thread implementation for Machine::Delete(), called from Machine::deleteThread().
4402 * @param task
4403 * @return
4404 */
4405HRESULT Machine::deleteTaskWorker(DeleteTask &task)
4406{
4407 AutoCaller autoCaller(this);
4408 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4409
4410 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4411
4412 ULONG uLogHistoryCount = 3;
4413 ComPtr<ISystemProperties> systemProperties;
4414 mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
4415 if (!systemProperties.isNull())
4416 systemProperties->COMGETTER(LogHistoryCount)(&uLogHistoryCount);
4417
4418 // delete the files pushed on the task list by Machine::Delete()
4419 // (this includes saved states of the machine and snapshots and
4420 // medium storage files from the IMedium list passed in, and the
4421 // machine XML file)
4422 std::list<Utf8Str>::const_iterator it = task.llFilesToDelete.begin();
4423 while (it != task.llFilesToDelete.end())
4424 {
4425 const Utf8Str &strFile = *it;
4426 LogFunc(("Deleting file %s\n", strFile.c_str()));
4427 RTFileDelete(strFile.c_str());
4428
4429 ++it;
4430 if (it == task.llFilesToDelete.end())
4431 {
4432 task.pProgress->SetNextOperation(Bstr(tr("Cleaning up machine directory")).raw(), 1);
4433 break;
4434 }
4435
4436 task.pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), it->c_str()).raw(), 1);
4437 }
4438
4439 /* delete the settings only when the file actually exists */
4440 if (mData->pMachineConfigFile->fileExists())
4441 {
4442 /* Delete any backup or uncommitted XML files. Ignore failures.
4443 See the fSafe parameter of xml::XmlFileWriter::write for details. */
4444 /** @todo Find a way to avoid referring directly to iprt/xml.h here. */
4445 Utf8Str otherXml = Utf8StrFmt("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszTmpSuff);
4446 RTFileDelete(otherXml.c_str());
4447 otherXml = Utf8StrFmt("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszPrevSuff);
4448 RTFileDelete(otherXml.c_str());
4449
4450 /* delete the Logs folder, nothing important should be left
4451 * there (we don't check for errors because the user might have
4452 * some private files there that we don't want to delete) */
4453 Utf8Str logFolder;
4454 getLogFolder(logFolder);
4455 Assert(logFolder.length());
4456 if (RTDirExists(logFolder.c_str()))
4457 {
4458 /* Delete all VBox.log[.N] files from the Logs folder
4459 * (this must be in sync with the rotation logic in
4460 * Console::powerUpThread()). Also, delete the VBox.png[.N]
4461 * files that may have been created by the GUI. */
4462 Utf8Str log = Utf8StrFmt("%s%cVBox.log",
4463 logFolder.c_str(), RTPATH_DELIMITER);
4464 RTFileDelete(log.c_str());
4465 log = Utf8StrFmt("%s%cVBox.png",
4466 logFolder.c_str(), RTPATH_DELIMITER);
4467 RTFileDelete(log.c_str());
4468 for (int i = uLogHistoryCount; i > 0; i--)
4469 {
4470 log = Utf8StrFmt("%s%cVBox.log.%d",
4471 logFolder.c_str(), RTPATH_DELIMITER, i);
4472 RTFileDelete(log.c_str());
4473 log = Utf8StrFmt("%s%cVBox.png.%d",
4474 logFolder.c_str(), RTPATH_DELIMITER, i);
4475 RTFileDelete(log.c_str());
4476 }
4477
4478 RTDirRemove(logFolder.c_str());
4479 }
4480
4481 /* delete the Snapshots folder, nothing important should be left
4482 * there (we don't check for errors because the user might have
4483 * some private files there that we don't want to delete) */
4484 Assert(mUserData->m_strSnapshotFolderFull.length());
4485 if (RTDirExists(mUserData->m_strSnapshotFolderFull.c_str()))
4486 RTDirRemove(mUserData->m_strSnapshotFolderFull.c_str());
4487
4488 /* delete the directory that contains the settings file, but only
4489 * if it matches the VM name (i.e. a structure created by default in
4490 * prepareSaveSettings()) */
4491 {
4492 Utf8Str settingsDir;
4493 if (isInOwnDir(&settingsDir))
4494 RTDirRemove(settingsDir.c_str());
4495 }
4496 }
4497
4498 alock.release();
4499
4500 if (task.fNeedsGlobalSaveSettings)
4501 {
4502 AutoWriteLock vboxlock(mParent COMMA_LOCKVAL_SRC_POS);
4503 mParent->saveSettings();
4504 }
4505
4506 return S_OK;
4507}
4508
4509STDMETHODIMP Machine::GetSnapshot(IN_BSTR aId, ISnapshot **aSnapshot)
4510{
4511 CheckComArgOutPointerValid(aSnapshot);
4512
4513 AutoCaller autoCaller(this);
4514 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4515
4516 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4517
4518 Guid uuid(aId);
4519 /* Todo: fix this properly by perhaps introducing an isValid method for the Guid class */
4520 if ( (aId)
4521 && (*aId != '\0') // an empty Bstr means "get root snapshot", so don't fail on that
4522 && (uuid.isEmpty()))
4523 {
4524 RTUUID uuidTemp;
4525 /* Either it's a null UUID or the conversion failed. (null uuid has a special meaning in findSnapshot) */
4526 if (RT_FAILURE(RTUuidFromUtf16(&uuidTemp, aId)))
4527 return setError(E_FAIL,
4528 tr("Could not find a snapshot with UUID {%ls}"),
4529 aId);
4530 }
4531
4532 ComObjPtr<Snapshot> snapshot;
4533
4534 HRESULT rc = findSnapshot(uuid, snapshot, true /* aSetError */);
4535 snapshot.queryInterfaceTo(aSnapshot);
4536
4537 return rc;
4538}
4539
4540STDMETHODIMP Machine::FindSnapshot(IN_BSTR aName, ISnapshot **aSnapshot)
4541{
4542 CheckComArgStrNotEmptyOrNull(aName);
4543 CheckComArgOutPointerValid(aSnapshot);
4544
4545 AutoCaller autoCaller(this);
4546 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4547
4548 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4549
4550 ComObjPtr<Snapshot> snapshot;
4551
4552 HRESULT rc = findSnapshot(aName, snapshot, true /* aSetError */);
4553 snapshot.queryInterfaceTo(aSnapshot);
4554
4555 return rc;
4556}
4557
4558STDMETHODIMP Machine::SetCurrentSnapshot(IN_BSTR /* aId */)
4559{
4560 /// @todo (dmik) don't forget to set
4561 // mData->mCurrentStateModified to FALSE
4562
4563 return setError(E_NOTIMPL, "Not implemented");
4564}
4565
4566STDMETHODIMP Machine::CreateSharedFolder(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable, BOOL aAutoMount)
4567{
4568 CheckComArgStrNotEmptyOrNull(aName);
4569 CheckComArgStrNotEmptyOrNull(aHostPath);
4570
4571 AutoCaller autoCaller(this);
4572 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4573
4574 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4575
4576 HRESULT rc = checkStateDependency(MutableStateDep);
4577 if (FAILED(rc)) return rc;
4578
4579 ComObjPtr<SharedFolder> sharedFolder;
4580 rc = findSharedFolder(aName, sharedFolder, false /* aSetError */);
4581 if (SUCCEEDED(rc))
4582 return setError(VBOX_E_OBJECT_IN_USE,
4583 tr("Shared folder named '%ls' already exists"),
4584 aName);
4585
4586 sharedFolder.createObject();
4587 rc = sharedFolder->init(getMachine(), aName, aHostPath, aWritable, aAutoMount);
4588 if (FAILED(rc)) return rc;
4589
4590 setModified(IsModified_SharedFolders);
4591 mHWData.backup();
4592 mHWData->mSharedFolders.push_back(sharedFolder);
4593
4594 /* inform the direct session if any */
4595 alock.leave();
4596 onSharedFolderChange();
4597
4598 return S_OK;
4599}
4600
4601STDMETHODIMP Machine::RemoveSharedFolder(IN_BSTR aName)
4602{
4603 CheckComArgStrNotEmptyOrNull(aName);
4604
4605 AutoCaller autoCaller(this);
4606 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4607
4608 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4609
4610 HRESULT rc = checkStateDependency(MutableStateDep);
4611 if (FAILED(rc)) return rc;
4612
4613 ComObjPtr<SharedFolder> sharedFolder;
4614 rc = findSharedFolder(aName, sharedFolder, true /* aSetError */);
4615 if (FAILED(rc)) return rc;
4616
4617 setModified(IsModified_SharedFolders);
4618 mHWData.backup();
4619 mHWData->mSharedFolders.remove(sharedFolder);
4620
4621 /* inform the direct session if any */
4622 alock.leave();
4623 onSharedFolderChange();
4624
4625 return S_OK;
4626}
4627
4628STDMETHODIMP Machine::CanShowConsoleWindow(BOOL *aCanShow)
4629{
4630 CheckComArgOutPointerValid(aCanShow);
4631
4632 /* start with No */
4633 *aCanShow = FALSE;
4634
4635 AutoCaller autoCaller(this);
4636 AssertComRCReturnRC(autoCaller.rc());
4637
4638 ComPtr<IInternalSessionControl> directControl;
4639 {
4640 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4641
4642 if (mData->mSession.mState != SessionState_Locked)
4643 return setError(VBOX_E_INVALID_VM_STATE,
4644 tr("Machine is not locked for session (session state: %s)"),
4645 Global::stringifySessionState(mData->mSession.mState));
4646
4647 directControl = mData->mSession.mDirectControl;
4648 }
4649
4650 /* ignore calls made after #OnSessionEnd() is called */
4651 if (!directControl)
4652 return S_OK;
4653
4654 LONG64 dummy;
4655 return directControl->OnShowWindow(TRUE /* aCheck */, aCanShow, &dummy);
4656}
4657
4658STDMETHODIMP Machine::ShowConsoleWindow(LONG64 *aWinId)
4659{
4660 CheckComArgOutPointerValid(aWinId);
4661
4662 AutoCaller autoCaller(this);
4663 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
4664
4665 ComPtr<IInternalSessionControl> directControl;
4666 {
4667 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4668
4669 if (mData->mSession.mState != SessionState_Locked)
4670 return setError(E_FAIL,
4671 tr("Machine is not locked for session (session state: %s)"),
4672 Global::stringifySessionState(mData->mSession.mState));
4673
4674 directControl = mData->mSession.mDirectControl;
4675 }
4676
4677 /* ignore calls made after #OnSessionEnd() is called */
4678 if (!directControl)
4679 return S_OK;
4680
4681 BOOL dummy;
4682 return directControl->OnShowWindow(FALSE /* aCheck */, &dummy, aWinId);
4683}
4684
4685#ifdef VBOX_WITH_GUEST_PROPS
4686/**
4687 * Look up a guest property in VBoxSVC's internal structures.
4688 */
4689HRESULT Machine::getGuestPropertyFromService(IN_BSTR aName,
4690 BSTR *aValue,
4691 LONG64 *aTimestamp,
4692 BSTR *aFlags) const
4693{
4694 using namespace guestProp;
4695
4696 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4697 Utf8Str strName(aName);
4698 HWData::GuestPropertyList::const_iterator it;
4699
4700 for (it = mHWData->mGuestProperties.begin();
4701 it != mHWData->mGuestProperties.end(); ++it)
4702 {
4703 if (it->strName == strName)
4704 {
4705 char szFlags[MAX_FLAGS_LEN + 1];
4706 it->strValue.cloneTo(aValue);
4707 *aTimestamp = it->mTimestamp;
4708 writeFlags(it->mFlags, szFlags);
4709 Bstr(szFlags).cloneTo(aFlags);
4710 break;
4711 }
4712 }
4713 return S_OK;
4714}
4715
4716/**
4717 * Query the VM that a guest property belongs to for the property.
4718 * @returns E_ACCESSDENIED if the VM process is not available or not
4719 * currently handling queries and the lookup should then be done in
4720 * VBoxSVC.
4721 */
4722HRESULT Machine::getGuestPropertyFromVM(IN_BSTR aName,
4723 BSTR *aValue,
4724 LONG64 *aTimestamp,
4725 BSTR *aFlags) const
4726{
4727 HRESULT rc;
4728 ComPtr<IInternalSessionControl> directControl;
4729 directControl = mData->mSession.mDirectControl;
4730
4731 /* fail if we were called after #OnSessionEnd() is called. This is a
4732 * silly race condition. */
4733
4734 if (!directControl)
4735 rc = E_ACCESSDENIED;
4736 else
4737 rc = directControl->AccessGuestProperty(aName, NULL, NULL,
4738 false /* isSetter */,
4739 aValue, aTimestamp, aFlags);
4740 return rc;
4741}
4742#endif // VBOX_WITH_GUEST_PROPS
4743
4744STDMETHODIMP Machine::GetGuestProperty(IN_BSTR aName,
4745 BSTR *aValue,
4746 LONG64 *aTimestamp,
4747 BSTR *aFlags)
4748{
4749#ifndef VBOX_WITH_GUEST_PROPS
4750 ReturnComNotImplemented();
4751#else // VBOX_WITH_GUEST_PROPS
4752 CheckComArgStrNotEmptyOrNull(aName);
4753 CheckComArgOutPointerValid(aValue);
4754 CheckComArgOutPointerValid(aTimestamp);
4755 CheckComArgOutPointerValid(aFlags);
4756
4757 AutoCaller autoCaller(this);
4758 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4759
4760 HRESULT rc = getGuestPropertyFromVM(aName, aValue, aTimestamp, aFlags);
4761 if (rc == E_ACCESSDENIED)
4762 /* The VM is not running or the service is not (yet) accessible */
4763 rc = getGuestPropertyFromService(aName, aValue, aTimestamp, aFlags);
4764 return rc;
4765#endif // VBOX_WITH_GUEST_PROPS
4766}
4767
4768STDMETHODIMP Machine::GetGuestPropertyValue(IN_BSTR aName, BSTR *aValue)
4769{
4770 LONG64 dummyTimestamp;
4771 Bstr dummyFlags;
4772 return GetGuestProperty(aName, aValue, &dummyTimestamp, dummyFlags.asOutParam());
4773}
4774
4775STDMETHODIMP Machine::GetGuestPropertyTimestamp(IN_BSTR aName, LONG64 *aTimestamp)
4776{
4777 Bstr dummyValue;
4778 Bstr dummyFlags;
4779 return GetGuestProperty(aName, dummyValue.asOutParam(), aTimestamp, dummyFlags.asOutParam());
4780}
4781
4782#ifdef VBOX_WITH_GUEST_PROPS
4783/**
4784 * Set a guest property in VBoxSVC's internal structures.
4785 */
4786HRESULT Machine::setGuestPropertyToService(IN_BSTR aName, IN_BSTR aValue,
4787 IN_BSTR aFlags)
4788{
4789 using namespace guestProp;
4790
4791 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4792 HRESULT rc = S_OK;
4793 HWData::GuestProperty property;
4794 property.mFlags = NILFLAG;
4795 bool found = false;
4796
4797 rc = checkStateDependency(MutableStateDep);
4798 if (FAILED(rc)) return rc;
4799
4800 try
4801 {
4802 Utf8Str utf8Name(aName);
4803 Utf8Str utf8Flags(aFlags);
4804 uint32_t fFlags = NILFLAG;
4805 if ( (aFlags != NULL)
4806 && RT_FAILURE(validateFlags(utf8Flags.c_str(), &fFlags))
4807 )
4808 return setError(E_INVALIDARG,
4809 tr("Invalid flag values: '%ls'"),
4810 aFlags);
4811
4812 /** @todo r=bird: see efficiency rant in PushGuestProperty. (Yeah, I
4813 * know, this is simple and do an OK job atm.) */
4814 HWData::GuestPropertyList::iterator it;
4815 for (it = mHWData->mGuestProperties.begin();
4816 it != mHWData->mGuestProperties.end(); ++it)
4817 if (it->strName == utf8Name)
4818 {
4819 property = *it;
4820 if (it->mFlags & (RDONLYHOST))
4821 rc = setError(E_ACCESSDENIED,
4822 tr("The property '%ls' cannot be changed by the host"),
4823 aName);
4824 else
4825 {
4826 setModified(IsModified_MachineData);
4827 mHWData.backup(); // @todo r=dj backup in a loop?!?
4828
4829 /* The backup() operation invalidates our iterator, so
4830 * get a new one. */
4831 for (it = mHWData->mGuestProperties.begin();
4832 it->strName != utf8Name;
4833 ++it)
4834 ;
4835 mHWData->mGuestProperties.erase(it);
4836 }
4837 found = true;
4838 break;
4839 }
4840 if (found && SUCCEEDED(rc))
4841 {
4842 if (*aValue)
4843 {
4844 RTTIMESPEC time;
4845 property.strValue = aValue;
4846 property.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
4847 if (aFlags != NULL)
4848 property.mFlags = fFlags;
4849 mHWData->mGuestProperties.push_back(property);
4850 }
4851 }
4852 else if (SUCCEEDED(rc) && *aValue)
4853 {
4854 RTTIMESPEC time;
4855 setModified(IsModified_MachineData);
4856 mHWData.backup();
4857 property.strName = aName;
4858 property.strValue = aValue;
4859 property.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
4860 property.mFlags = fFlags;
4861 mHWData->mGuestProperties.push_back(property);
4862 }
4863 if ( SUCCEEDED(rc)
4864 && ( mHWData->mGuestPropertyNotificationPatterns.isEmpty()
4865 || RTStrSimplePatternMultiMatch(mHWData->mGuestPropertyNotificationPatterns.c_str(),
4866 RTSTR_MAX,
4867 utf8Name.c_str(),
4868 RTSTR_MAX,
4869 NULL)
4870 )
4871 )
4872 {
4873 /** @todo r=bird: Why aren't we leaving the lock here? The
4874 * same code in PushGuestProperty does... */
4875 mParent->onGuestPropertyChange(mData->mUuid, aName, aValue, aFlags);
4876 }
4877 }
4878 catch (std::bad_alloc &)
4879 {
4880 rc = E_OUTOFMEMORY;
4881 }
4882
4883 return rc;
4884}
4885
4886/**
4887 * Set a property on the VM that that property belongs to.
4888 * @returns E_ACCESSDENIED if the VM process is not available or not
4889 * currently handling queries and the setting should then be done in
4890 * VBoxSVC.
4891 */
4892HRESULT Machine::setGuestPropertyToVM(IN_BSTR aName, IN_BSTR aValue,
4893 IN_BSTR aFlags)
4894{
4895 HRESULT rc;
4896
4897 try {
4898 ComPtr<IInternalSessionControl> directControl =
4899 mData->mSession.mDirectControl;
4900
4901 BSTR dummy = NULL; /* will not be changed (setter) */
4902 LONG64 dummy64;
4903 if (!directControl)
4904 rc = E_ACCESSDENIED;
4905 else
4906 rc = directControl->AccessGuestProperty
4907 (aName,
4908 /** @todo Fix when adding DeleteGuestProperty(),
4909 see defect. */
4910 *aValue ? aValue : NULL, aFlags, true /* isSetter */,
4911 &dummy, &dummy64, &dummy);
4912 }
4913 catch (std::bad_alloc &)
4914 {
4915 rc = E_OUTOFMEMORY;
4916 }
4917
4918 return rc;
4919}
4920#endif // VBOX_WITH_GUEST_PROPS
4921
4922STDMETHODIMP Machine::SetGuestProperty(IN_BSTR aName, IN_BSTR aValue,
4923 IN_BSTR aFlags)
4924{
4925#ifndef VBOX_WITH_GUEST_PROPS
4926 ReturnComNotImplemented();
4927#else // VBOX_WITH_GUEST_PROPS
4928 CheckComArgStrNotEmptyOrNull(aName);
4929 if ((aFlags != NULL) && !VALID_PTR(aFlags))
4930 return E_INVALIDARG;
4931 AutoCaller autoCaller(this);
4932 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4933
4934 HRESULT rc = setGuestPropertyToVM(aName, aValue, aFlags);
4935 if (rc == E_ACCESSDENIED)
4936 /* The VM is not running or the service is not (yet) accessible */
4937 rc = setGuestPropertyToService(aName, aValue, aFlags);
4938 return rc;
4939#endif // VBOX_WITH_GUEST_PROPS
4940}
4941
4942STDMETHODIMP Machine::SetGuestPropertyValue(IN_BSTR aName, IN_BSTR aValue)
4943{
4944 return SetGuestProperty(aName, aValue, NULL);
4945}
4946
4947#ifdef VBOX_WITH_GUEST_PROPS
4948/**
4949 * Enumerate the guest properties in VBoxSVC's internal structures.
4950 */
4951HRESULT Machine::enumerateGuestPropertiesInService
4952 (IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
4953 ComSafeArrayOut(BSTR, aValues),
4954 ComSafeArrayOut(LONG64, aTimestamps),
4955 ComSafeArrayOut(BSTR, aFlags))
4956{
4957 using namespace guestProp;
4958
4959 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4960 Utf8Str strPatterns(aPatterns);
4961
4962 /*
4963 * Look for matching patterns and build up a list.
4964 */
4965 HWData::GuestPropertyList propList;
4966 for (HWData::GuestPropertyList::iterator it = mHWData->mGuestProperties.begin();
4967 it != mHWData->mGuestProperties.end();
4968 ++it)
4969 if ( strPatterns.isEmpty()
4970 || RTStrSimplePatternMultiMatch(strPatterns.c_str(),
4971 RTSTR_MAX,
4972 it->strName.c_str(),
4973 RTSTR_MAX,
4974 NULL)
4975 )
4976 propList.push_back(*it);
4977
4978 /*
4979 * And build up the arrays for returning the property information.
4980 */
4981 size_t cEntries = propList.size();
4982 SafeArray<BSTR> names(cEntries);
4983 SafeArray<BSTR> values(cEntries);
4984 SafeArray<LONG64> timestamps(cEntries);
4985 SafeArray<BSTR> flags(cEntries);
4986 size_t iProp = 0;
4987 for (HWData::GuestPropertyList::iterator it = propList.begin();
4988 it != propList.end();
4989 ++it)
4990 {
4991 char szFlags[MAX_FLAGS_LEN + 1];
4992 it->strName.cloneTo(&names[iProp]);
4993 it->strValue.cloneTo(&values[iProp]);
4994 timestamps[iProp] = it->mTimestamp;
4995 writeFlags(it->mFlags, szFlags);
4996 Bstr(szFlags).cloneTo(&flags[iProp]);
4997 ++iProp;
4998 }
4999 names.detachTo(ComSafeArrayOutArg(aNames));
5000 values.detachTo(ComSafeArrayOutArg(aValues));
5001 timestamps.detachTo(ComSafeArrayOutArg(aTimestamps));
5002 flags.detachTo(ComSafeArrayOutArg(aFlags));
5003 return S_OK;
5004}
5005
5006/**
5007 * Enumerate the properties managed by a VM.
5008 * @returns E_ACCESSDENIED if the VM process is not available or not
5009 * currently handling queries and the setting should then be done in
5010 * VBoxSVC.
5011 */
5012HRESULT Machine::enumerateGuestPropertiesOnVM
5013 (IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
5014 ComSafeArrayOut(BSTR, aValues),
5015 ComSafeArrayOut(LONG64, aTimestamps),
5016 ComSafeArrayOut(BSTR, aFlags))
5017{
5018 HRESULT rc;
5019 ComPtr<IInternalSessionControl> directControl;
5020 directControl = mData->mSession.mDirectControl;
5021
5022 if (!directControl)
5023 rc = E_ACCESSDENIED;
5024 else
5025 rc = directControl->EnumerateGuestProperties
5026 (aPatterns, ComSafeArrayOutArg(aNames),
5027 ComSafeArrayOutArg(aValues),
5028 ComSafeArrayOutArg(aTimestamps),
5029 ComSafeArrayOutArg(aFlags));
5030 return rc;
5031}
5032#endif // VBOX_WITH_GUEST_PROPS
5033
5034STDMETHODIMP Machine::EnumerateGuestProperties(IN_BSTR aPatterns,
5035 ComSafeArrayOut(BSTR, aNames),
5036 ComSafeArrayOut(BSTR, aValues),
5037 ComSafeArrayOut(LONG64, aTimestamps),
5038 ComSafeArrayOut(BSTR, aFlags))
5039{
5040#ifndef VBOX_WITH_GUEST_PROPS
5041 ReturnComNotImplemented();
5042#else // VBOX_WITH_GUEST_PROPS
5043 if (!VALID_PTR(aPatterns) && (aPatterns != NULL))
5044 return E_POINTER;
5045
5046 CheckComArgOutSafeArrayPointerValid(aNames);
5047 CheckComArgOutSafeArrayPointerValid(aValues);
5048 CheckComArgOutSafeArrayPointerValid(aTimestamps);
5049 CheckComArgOutSafeArrayPointerValid(aFlags);
5050
5051 AutoCaller autoCaller(this);
5052 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5053
5054 HRESULT rc = enumerateGuestPropertiesOnVM
5055 (aPatterns, ComSafeArrayOutArg(aNames),
5056 ComSafeArrayOutArg(aValues),
5057 ComSafeArrayOutArg(aTimestamps),
5058 ComSafeArrayOutArg(aFlags));
5059 if (rc == E_ACCESSDENIED)
5060 /* The VM is not running or the service is not (yet) accessible */
5061 rc = enumerateGuestPropertiesInService
5062 (aPatterns, ComSafeArrayOutArg(aNames),
5063 ComSafeArrayOutArg(aValues),
5064 ComSafeArrayOutArg(aTimestamps),
5065 ComSafeArrayOutArg(aFlags));
5066 return rc;
5067#endif // VBOX_WITH_GUEST_PROPS
5068}
5069
5070STDMETHODIMP Machine::GetMediumAttachmentsOfController(IN_BSTR aName,
5071 ComSafeArrayOut(IMediumAttachment*, aAttachments))
5072{
5073 MediaData::AttachmentList atts;
5074
5075 HRESULT rc = getMediumAttachmentsOfController(aName, atts);
5076 if (FAILED(rc)) return rc;
5077
5078 SafeIfaceArray<IMediumAttachment> attachments(atts);
5079 attachments.detachTo(ComSafeArrayOutArg(aAttachments));
5080
5081 return S_OK;
5082}
5083
5084STDMETHODIMP Machine::GetMediumAttachment(IN_BSTR aControllerName,
5085 LONG aControllerPort,
5086 LONG aDevice,
5087 IMediumAttachment **aAttachment)
5088{
5089 LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d\n",
5090 aControllerName, aControllerPort, aDevice));
5091
5092 CheckComArgStrNotEmptyOrNull(aControllerName);
5093 CheckComArgOutPointerValid(aAttachment);
5094
5095 AutoCaller autoCaller(this);
5096 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5097
5098 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5099
5100 *aAttachment = NULL;
5101
5102 ComObjPtr<MediumAttachment> pAttach = findAttachment(mMediaData->mAttachments,
5103 aControllerName,
5104 aControllerPort,
5105 aDevice);
5106 if (pAttach.isNull())
5107 return setError(VBOX_E_OBJECT_NOT_FOUND,
5108 tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
5109 aDevice, aControllerPort, aControllerName);
5110
5111 pAttach.queryInterfaceTo(aAttachment);
5112
5113 return S_OK;
5114}
5115
5116STDMETHODIMP Machine::AddStorageController(IN_BSTR aName,
5117 StorageBus_T aConnectionType,
5118 IStorageController **controller)
5119{
5120 CheckComArgStrNotEmptyOrNull(aName);
5121
5122 if ( (aConnectionType <= StorageBus_Null)
5123 || (aConnectionType > StorageBus_SAS))
5124 return setError(E_INVALIDARG,
5125 tr("Invalid connection type: %d"),
5126 aConnectionType);
5127
5128 AutoCaller autoCaller(this);
5129 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5130
5131 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5132
5133 HRESULT rc = checkStateDependency(MutableStateDep);
5134 if (FAILED(rc)) return rc;
5135
5136 /* try to find one with the name first. */
5137 ComObjPtr<StorageController> ctrl;
5138
5139 rc = getStorageControllerByName(aName, ctrl, false /* aSetError */);
5140 if (SUCCEEDED(rc))
5141 return setError(VBOX_E_OBJECT_IN_USE,
5142 tr("Storage controller named '%ls' already exists"),
5143 aName);
5144
5145 ctrl.createObject();
5146
5147 /* get a new instance number for the storage controller */
5148 ULONG ulInstance = 0;
5149 for (StorageControllerList::const_iterator it = mStorageControllers->begin();
5150 it != mStorageControllers->end();
5151 ++it)
5152 {
5153 if ((*it)->getStorageBus() == aConnectionType)
5154 {
5155 ULONG ulCurInst = (*it)->getInstance();
5156
5157 if (ulCurInst >= ulInstance)
5158 ulInstance = ulCurInst + 1;
5159 }
5160 }
5161
5162 rc = ctrl->init(this, aName, aConnectionType, ulInstance);
5163 if (FAILED(rc)) return rc;
5164
5165 setModified(IsModified_Storage);
5166 mStorageControllers.backup();
5167 mStorageControllers->push_back(ctrl);
5168
5169 ctrl.queryInterfaceTo(controller);
5170
5171 /* inform the direct session if any */
5172 alock.leave();
5173 onStorageControllerChange();
5174
5175 return S_OK;
5176}
5177
5178STDMETHODIMP Machine::GetStorageControllerByName(IN_BSTR aName,
5179 IStorageController **aStorageController)
5180{
5181 CheckComArgStrNotEmptyOrNull(aName);
5182
5183 AutoCaller autoCaller(this);
5184 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5185
5186 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5187
5188 ComObjPtr<StorageController> ctrl;
5189
5190 HRESULT rc = getStorageControllerByName(aName, ctrl, true /* aSetError */);
5191 if (SUCCEEDED(rc))
5192 ctrl.queryInterfaceTo(aStorageController);
5193
5194 return rc;
5195}
5196
5197STDMETHODIMP Machine::GetStorageControllerByInstance(ULONG aInstance,
5198 IStorageController **aStorageController)
5199{
5200 AutoCaller autoCaller(this);
5201 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5202
5203 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5204
5205 for (StorageControllerList::const_iterator it = mStorageControllers->begin();
5206 it != mStorageControllers->end();
5207 ++it)
5208 {
5209 if ((*it)->getInstance() == aInstance)
5210 {
5211 (*it).queryInterfaceTo(aStorageController);
5212 return S_OK;
5213 }
5214 }
5215
5216 return setError(VBOX_E_OBJECT_NOT_FOUND,
5217 tr("Could not find a storage controller with instance number '%lu'"),
5218 aInstance);
5219}
5220
5221STDMETHODIMP Machine::RemoveStorageController(IN_BSTR aName)
5222{
5223 CheckComArgStrNotEmptyOrNull(aName);
5224
5225 AutoCaller autoCaller(this);
5226 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5227
5228 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5229
5230 HRESULT rc = checkStateDependency(MutableStateDep);
5231 if (FAILED(rc)) return rc;
5232
5233 ComObjPtr<StorageController> ctrl;
5234 rc = getStorageControllerByName(aName, ctrl, true /* aSetError */);
5235 if (FAILED(rc)) return rc;
5236
5237 /* We can remove the controller only if there is no device attached. */
5238 /* check if the device slot is already busy */
5239 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
5240 it != mMediaData->mAttachments.end();
5241 ++it)
5242 {
5243 if ((*it)->getControllerName() == aName)
5244 return setError(VBOX_E_OBJECT_IN_USE,
5245 tr("Storage controller named '%ls' has still devices attached"),
5246 aName);
5247 }
5248
5249 /* We can remove it now. */
5250 setModified(IsModified_Storage);
5251 mStorageControllers.backup();
5252
5253 ctrl->unshare();
5254
5255 mStorageControllers->remove(ctrl);
5256
5257 /* inform the direct session if any */
5258 alock.leave();
5259 onStorageControllerChange();
5260
5261 return S_OK;
5262}
5263
5264STDMETHODIMP Machine::QuerySavedGuestSize(ULONG uScreenId, ULONG *puWidth, ULONG *puHeight)
5265{
5266 LogFlowThisFunc(("\n"));
5267
5268 CheckComArgNotNull(puWidth);
5269 CheckComArgNotNull(puHeight);
5270
5271 uint32_t u32Width = 0;
5272 uint32_t u32Height = 0;
5273
5274 int vrc = readSavedGuestSize(mSSData->mStateFilePath, uScreenId, &u32Width, &u32Height);
5275 if (RT_FAILURE(vrc))
5276 return setError(VBOX_E_IPRT_ERROR,
5277 tr("Saved guest size is not available (%Rrc)"),
5278 vrc);
5279
5280 *puWidth = u32Width;
5281 *puHeight = u32Height;
5282
5283 return S_OK;
5284}
5285
5286STDMETHODIMP Machine::QuerySavedThumbnailSize(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight)
5287{
5288 LogFlowThisFunc(("\n"));
5289
5290 CheckComArgNotNull(aSize);
5291 CheckComArgNotNull(aWidth);
5292 CheckComArgNotNull(aHeight);
5293
5294 if (aScreenId != 0)
5295 return E_NOTIMPL;
5296
5297 AutoCaller autoCaller(this);
5298 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5299
5300 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5301
5302 uint8_t *pu8Data = NULL;
5303 uint32_t cbData = 0;
5304 uint32_t u32Width = 0;
5305 uint32_t u32Height = 0;
5306
5307 int vrc = readSavedDisplayScreenshot(mSSData->mStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
5308
5309 if (RT_FAILURE(vrc))
5310 return setError(VBOX_E_IPRT_ERROR,
5311 tr("Saved screenshot data is not available (%Rrc)"),
5312 vrc);
5313
5314 *aSize = cbData;
5315 *aWidth = u32Width;
5316 *aHeight = u32Height;
5317
5318 freeSavedDisplayScreenshot(pu8Data);
5319
5320 return S_OK;
5321}
5322
5323STDMETHODIMP Machine::ReadSavedThumbnailToArray(ULONG aScreenId, BOOL aBGR, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData))
5324{
5325 LogFlowThisFunc(("\n"));
5326
5327 CheckComArgNotNull(aWidth);
5328 CheckComArgNotNull(aHeight);
5329 CheckComArgOutSafeArrayPointerValid(aData);
5330
5331 if (aScreenId != 0)
5332 return E_NOTIMPL;
5333
5334 AutoCaller autoCaller(this);
5335 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5336
5337 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5338
5339 uint8_t *pu8Data = NULL;
5340 uint32_t cbData = 0;
5341 uint32_t u32Width = 0;
5342 uint32_t u32Height = 0;
5343
5344 int vrc = readSavedDisplayScreenshot(mSSData->mStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
5345
5346 if (RT_FAILURE(vrc))
5347 return setError(VBOX_E_IPRT_ERROR,
5348 tr("Saved screenshot data is not available (%Rrc)"),
5349 vrc);
5350
5351 *aWidth = u32Width;
5352 *aHeight = u32Height;
5353
5354 com::SafeArray<BYTE> bitmap(cbData);
5355 /* Convert pixels to format expected by the API caller. */
5356 if (aBGR)
5357 {
5358 /* [0] B, [1] G, [2] R, [3] A. */
5359 for (unsigned i = 0; i < cbData; i += 4)
5360 {
5361 bitmap[i] = pu8Data[i];
5362 bitmap[i + 1] = pu8Data[i + 1];
5363 bitmap[i + 2] = pu8Data[i + 2];
5364 bitmap[i + 3] = 0xff;
5365 }
5366 }
5367 else
5368 {
5369 /* [0] R, [1] G, [2] B, [3] A. */
5370 for (unsigned i = 0; i < cbData; i += 4)
5371 {
5372 bitmap[i] = pu8Data[i + 2];
5373 bitmap[i + 1] = pu8Data[i + 1];
5374 bitmap[i + 2] = pu8Data[i];
5375 bitmap[i + 3] = 0xff;
5376 }
5377 }
5378 bitmap.detachTo(ComSafeArrayOutArg(aData));
5379
5380 freeSavedDisplayScreenshot(pu8Data);
5381
5382 return S_OK;
5383}
5384
5385
5386STDMETHODIMP Machine::ReadSavedThumbnailPNGToArray(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData))
5387{
5388 LogFlowThisFunc(("\n"));
5389
5390 CheckComArgNotNull(aWidth);
5391 CheckComArgNotNull(aHeight);
5392 CheckComArgOutSafeArrayPointerValid(aData);
5393
5394 if (aScreenId != 0)
5395 return E_NOTIMPL;
5396
5397 AutoCaller autoCaller(this);
5398 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5399
5400 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5401
5402 uint8_t *pu8Data = NULL;
5403 uint32_t cbData = 0;
5404 uint32_t u32Width = 0;
5405 uint32_t u32Height = 0;
5406
5407 int vrc = readSavedDisplayScreenshot(mSSData->mStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
5408
5409 if (RT_FAILURE(vrc))
5410 return setError(VBOX_E_IPRT_ERROR,
5411 tr("Saved screenshot data is not available (%Rrc)"),
5412 vrc);
5413
5414 *aWidth = u32Width;
5415 *aHeight = u32Height;
5416
5417 uint8_t *pu8PNG = NULL;
5418 uint32_t cbPNG = 0;
5419 uint32_t cxPNG = 0;
5420 uint32_t cyPNG = 0;
5421
5422 DisplayMakePNG(pu8Data, u32Width, u32Height, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
5423
5424 com::SafeArray<BYTE> screenData(cbPNG);
5425 screenData.initFrom(pu8PNG, cbPNG);
5426 RTMemFree(pu8PNG);
5427
5428 screenData.detachTo(ComSafeArrayOutArg(aData));
5429
5430 freeSavedDisplayScreenshot(pu8Data);
5431
5432 return S_OK;
5433}
5434
5435STDMETHODIMP Machine::QuerySavedScreenshotPNGSize(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight)
5436{
5437 LogFlowThisFunc(("\n"));
5438
5439 CheckComArgNotNull(aSize);
5440 CheckComArgNotNull(aWidth);
5441 CheckComArgNotNull(aHeight);
5442
5443 if (aScreenId != 0)
5444 return E_NOTIMPL;
5445
5446 AutoCaller autoCaller(this);
5447 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5448
5449 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5450
5451 uint8_t *pu8Data = NULL;
5452 uint32_t cbData = 0;
5453 uint32_t u32Width = 0;
5454 uint32_t u32Height = 0;
5455
5456 int vrc = readSavedDisplayScreenshot(mSSData->mStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
5457
5458 if (RT_FAILURE(vrc))
5459 return setError(VBOX_E_IPRT_ERROR,
5460 tr("Saved screenshot data is not available (%Rrc)"),
5461 vrc);
5462
5463 *aSize = cbData;
5464 *aWidth = u32Width;
5465 *aHeight = u32Height;
5466
5467 freeSavedDisplayScreenshot(pu8Data);
5468
5469 return S_OK;
5470}
5471
5472STDMETHODIMP Machine::ReadSavedScreenshotPNGToArray(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData))
5473{
5474 LogFlowThisFunc(("\n"));
5475
5476 CheckComArgNotNull(aWidth);
5477 CheckComArgNotNull(aHeight);
5478 CheckComArgOutSafeArrayPointerValid(aData);
5479
5480 if (aScreenId != 0)
5481 return E_NOTIMPL;
5482
5483 AutoCaller autoCaller(this);
5484 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5485
5486 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5487
5488 uint8_t *pu8Data = NULL;
5489 uint32_t cbData = 0;
5490 uint32_t u32Width = 0;
5491 uint32_t u32Height = 0;
5492
5493 int vrc = readSavedDisplayScreenshot(mSSData->mStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
5494
5495 if (RT_FAILURE(vrc))
5496 return setError(VBOX_E_IPRT_ERROR,
5497 tr("Saved screenshot thumbnail data is not available (%Rrc)"),
5498 vrc);
5499
5500 *aWidth = u32Width;
5501 *aHeight = u32Height;
5502
5503 com::SafeArray<BYTE> png(cbData);
5504 png.initFrom(pu8Data, cbData);
5505 png.detachTo(ComSafeArrayOutArg(aData));
5506
5507 freeSavedDisplayScreenshot(pu8Data);
5508
5509 return S_OK;
5510}
5511
5512STDMETHODIMP Machine::HotPlugCPU(ULONG aCpu)
5513{
5514 HRESULT rc = S_OK;
5515 LogFlowThisFunc(("\n"));
5516
5517 AutoCaller autoCaller(this);
5518 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5519
5520 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5521
5522 if (!mHWData->mCPUHotPlugEnabled)
5523 return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
5524
5525 if (aCpu >= mHWData->mCPUCount)
5526 return setError(E_INVALIDARG, tr("CPU id exceeds number of possible CPUs [0:%lu]"), mHWData->mCPUCount-1);
5527
5528 if (mHWData->mCPUAttached[aCpu])
5529 return setError(VBOX_E_OBJECT_IN_USE, tr("CPU %lu is already attached"), aCpu);
5530
5531 alock.release();
5532 rc = onCPUChange(aCpu, false);
5533 alock.acquire();
5534 if (FAILED(rc)) return rc;
5535
5536 setModified(IsModified_MachineData);
5537 mHWData.backup();
5538 mHWData->mCPUAttached[aCpu] = true;
5539
5540 /* Save settings if online */
5541 if (Global::IsOnline(mData->mMachineState))
5542 saveSettings(NULL);
5543
5544 return S_OK;
5545}
5546
5547STDMETHODIMP Machine::HotUnplugCPU(ULONG aCpu)
5548{
5549 HRESULT rc = S_OK;
5550 LogFlowThisFunc(("\n"));
5551
5552 AutoCaller autoCaller(this);
5553 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5554
5555 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5556
5557 if (!mHWData->mCPUHotPlugEnabled)
5558 return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
5559
5560 if (aCpu >= SchemaDefs::MaxCPUCount)
5561 return setError(E_INVALIDARG,
5562 tr("CPU index exceeds maximum CPU count (must be in range [0:%lu])"),
5563 SchemaDefs::MaxCPUCount);
5564
5565 if (!mHWData->mCPUAttached[aCpu])
5566 return setError(VBOX_E_OBJECT_NOT_FOUND, tr("CPU %lu is not attached"), aCpu);
5567
5568 /* CPU 0 can't be detached */
5569 if (aCpu == 0)
5570 return setError(E_INVALIDARG, tr("It is not possible to detach CPU 0"));
5571
5572 alock.release();
5573 rc = onCPUChange(aCpu, true);
5574 alock.acquire();
5575 if (FAILED(rc)) return rc;
5576
5577 setModified(IsModified_MachineData);
5578 mHWData.backup();
5579 mHWData->mCPUAttached[aCpu] = false;
5580
5581 /* Save settings if online */
5582 if (Global::IsOnline(mData->mMachineState))
5583 saveSettings(NULL);
5584
5585 return S_OK;
5586}
5587
5588STDMETHODIMP Machine::GetCPUStatus(ULONG aCpu, BOOL *aCpuAttached)
5589{
5590 LogFlowThisFunc(("\n"));
5591
5592 CheckComArgNotNull(aCpuAttached);
5593
5594 *aCpuAttached = false;
5595
5596 AutoCaller autoCaller(this);
5597 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5598
5599 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5600
5601 /* If hotplug is enabled the CPU is always enabled. */
5602 if (!mHWData->mCPUHotPlugEnabled)
5603 {
5604 if (aCpu < mHWData->mCPUCount)
5605 *aCpuAttached = true;
5606 }
5607 else
5608 {
5609 if (aCpu < SchemaDefs::MaxCPUCount)
5610 *aCpuAttached = mHWData->mCPUAttached[aCpu];
5611 }
5612
5613 return S_OK;
5614}
5615
5616STDMETHODIMP Machine::QueryLogFilename(ULONG aIdx, BSTR *aName)
5617{
5618 CheckComArgOutPointerValid(aName);
5619
5620 AutoCaller autoCaller(this);
5621 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5622
5623 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5624
5625 Utf8Str log = queryLogFilename(aIdx);
5626 if (!RTFileExists(log.c_str()))
5627 log.setNull();
5628 log.cloneTo(aName);
5629
5630 return S_OK;
5631}
5632
5633STDMETHODIMP Machine::ReadLog(ULONG aIdx, LONG64 aOffset, LONG64 aSize, ComSafeArrayOut(BYTE, aData))
5634{
5635 LogFlowThisFunc(("\n"));
5636 CheckComArgOutSafeArrayPointerValid(aData);
5637 if (aSize < 0)
5638 return setError(E_INVALIDARG, tr("The size argument (%lld) is negative"), aSize);
5639
5640 AutoCaller autoCaller(this);
5641 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5642
5643 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5644
5645 HRESULT rc = S_OK;
5646 Utf8Str log = queryLogFilename(aIdx);
5647
5648 /* do not unnecessarily hold the lock while doing something which does
5649 * not need the lock and potentially takes a long time. */
5650 alock.release();
5651
5652 /* Limit the chunk size to 32K for now, as that gives better performance
5653 * over (XP)COM, and keeps the SOAP reply size under 1M for the webservice.
5654 * One byte expands to approx. 25 bytes of breathtaking XML. */
5655 size_t cbData = (size_t)RT_MIN(aSize, 32768);
5656 com::SafeArray<BYTE> logData(cbData);
5657
5658 RTFILE LogFile;
5659 int vrc = RTFileOpen(&LogFile, log.c_str(),
5660 RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE);
5661 if (RT_SUCCESS(vrc))
5662 {
5663 vrc = RTFileReadAt(LogFile, aOffset, logData.raw(), cbData, &cbData);
5664 if (RT_SUCCESS(vrc))
5665 logData.resize(cbData);
5666 else
5667 rc = setError(VBOX_E_IPRT_ERROR,
5668 tr("Could not read log file '%s' (%Rrc)"),
5669 log.c_str(), vrc);
5670 RTFileClose(LogFile);
5671 }
5672 else
5673 rc = setError(VBOX_E_IPRT_ERROR,
5674 tr("Could not open log file '%s' (%Rrc)"),
5675 log.c_str(), vrc);
5676
5677 if (FAILED(rc))
5678 logData.resize(0);
5679 logData.detachTo(ComSafeArrayOutArg(aData));
5680
5681 return rc;
5682}
5683
5684
5685// public methods for internal purposes
5686/////////////////////////////////////////////////////////////////////////////
5687
5688/**
5689 * Adds the given IsModified_* flag to the dirty flags of the machine.
5690 * This must be called either during loadSettings or under the machine write lock.
5691 * @param fl
5692 */
5693void Machine::setModified(uint32_t fl)
5694{
5695 mData->flModifications |= fl;
5696}
5697
5698/**
5699 * Saves the registry entry of this machine to the given configuration node.
5700 *
5701 * @param aEntryNode Node to save the registry entry to.
5702 *
5703 * @note locks this object for reading.
5704 */
5705HRESULT Machine::saveRegistryEntry(settings::MachineRegistryEntry &data)
5706{
5707 AutoLimitedCaller autoCaller(this);
5708 AssertComRCReturnRC(autoCaller.rc());
5709
5710 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5711
5712 data.uuid = mData->mUuid;
5713 data.strSettingsFile = mData->m_strConfigFile;
5714
5715 return S_OK;
5716}
5717
5718/**
5719 * Calculates the absolute path of the given path taking the directory of the
5720 * machine settings file as the current directory.
5721 *
5722 * @param aPath Path to calculate the absolute path for.
5723 * @param aResult Where to put the result (used only on success, can be the
5724 * same Utf8Str instance as passed in @a aPath).
5725 * @return IPRT result.
5726 *
5727 * @note Locks this object for reading.
5728 */
5729int Machine::calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult)
5730{
5731 AutoCaller autoCaller(this);
5732 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
5733
5734 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5735
5736 AssertReturn(!mData->m_strConfigFileFull.isEmpty(), VERR_GENERAL_FAILURE);
5737
5738 Utf8Str strSettingsDir = mData->m_strConfigFileFull;
5739
5740 strSettingsDir.stripFilename();
5741 char folder[RTPATH_MAX];
5742 int vrc = RTPathAbsEx(strSettingsDir.c_str(), strPath.c_str(), folder, sizeof(folder));
5743 if (RT_SUCCESS(vrc))
5744 aResult = folder;
5745
5746 return vrc;
5747}
5748
5749/**
5750 * Copies strSource to strTarget, making it relative to the machine folder
5751 * if it is a subdirectory thereof, or simply copying it otherwise.
5752 *
5753 * @param strSource Path to evalue and copy.
5754 * @param strTarget Buffer to receive target path.
5755 *
5756 * @note Locks this object for reading.
5757 */
5758void Machine::copyPathRelativeToMachine(const Utf8Str &strSource,
5759 Utf8Str &strTarget)
5760{
5761 AutoCaller autoCaller(this);
5762 AssertComRCReturn(autoCaller.rc(), (void)0);
5763
5764 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5765
5766 AssertReturnVoid(!mData->m_strConfigFileFull.isEmpty());
5767 // use strTarget as a temporary buffer to hold the machine settings dir
5768 strTarget = mData->m_strConfigFileFull;
5769 strTarget.stripFilename();
5770 if (RTPathStartsWith(strSource.c_str(), strTarget.c_str()))
5771 // is relative: then append what's left
5772 strTarget.append(strSource.c_str() + strTarget.length()); // include '/'
5773 else
5774 // is not relative: then overwrite
5775 strTarget = strSource;
5776}
5777
5778/**
5779 * Returns the full path to the machine's log folder in the
5780 * \a aLogFolder argument.
5781 */
5782void Machine::getLogFolder(Utf8Str &aLogFolder)
5783{
5784 AutoCaller autoCaller(this);
5785 AssertComRCReturnVoid(autoCaller.rc());
5786
5787 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5788
5789 Utf8Str settingsDir;
5790 if (isInOwnDir(&settingsDir))
5791 /* Log folder is <Machines>/<VM_Name>/Logs */
5792 aLogFolder = settingsDir;
5793 else
5794 {
5795 /* Log folder is <Machines>/<VM_SnapshotFolder>/Logs */
5796 Assert(!mUserData->m_strSnapshotFolderFull.isEmpty());
5797 aLogFolder = mUserData->m_strSnapshotFolderFull;
5798 }
5799
5800 aLogFolder.append(RTPATH_DELIMITER);
5801 aLogFolder.append("Logs");
5802}
5803
5804/**
5805 * Returns the full path to the machine's log file for an given index.
5806 */
5807Utf8Str Machine::queryLogFilename(ULONG idx)
5808{
5809 Utf8Str logFolder;
5810 getLogFolder(logFolder);
5811 Assert(logFolder.length());
5812 Utf8Str log;
5813 if (idx == 0)
5814 log = Utf8StrFmt("%s%cVBox.log",
5815 logFolder.c_str(), RTPATH_DELIMITER);
5816 else
5817 log = Utf8StrFmt("%s%cVBox.log.%d",
5818 logFolder.c_str(), RTPATH_DELIMITER, idx);
5819 return log;
5820}
5821
5822/**
5823 * @note Locks this object for writing, calls the client process
5824 * (inside the lock).
5825 */
5826HRESULT Machine::openRemoteSession(IInternalSessionControl *aControl,
5827 IN_BSTR aType,
5828 IN_BSTR aEnvironment,
5829 ProgressProxy *aProgress)
5830{
5831 LogFlowThisFuncEnter();
5832
5833 AssertReturn(aControl, E_FAIL);
5834 AssertReturn(aProgress, E_FAIL);
5835
5836 AutoCaller autoCaller(this);
5837 if (FAILED(autoCaller.rc())) return autoCaller.rc();
5838
5839 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
5840
5841 if (!mData->mRegistered)
5842 return setError(E_UNEXPECTED,
5843 tr("The machine '%s' is not registered"),
5844 mUserData->s.strName.c_str());
5845
5846 LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
5847
5848 if ( mData->mSession.mState == SessionState_Locked
5849 || mData->mSession.mState == SessionState_Spawning
5850 || mData->mSession.mState == SessionState_Unlocking)
5851 return setError(VBOX_E_INVALID_OBJECT_STATE,
5852 tr("The machine '%s' is already locked by a session (or being locked or unlocked)"),
5853 mUserData->s.strName.c_str());
5854
5855 /* may not be busy */
5856 AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
5857
5858 /* get the path to the executable */
5859 char szPath[RTPATH_MAX];
5860 RTPathAppPrivateArch(szPath, RTPATH_MAX);
5861 size_t sz = strlen(szPath);
5862 szPath[sz++] = RTPATH_DELIMITER;
5863 szPath[sz] = 0;
5864 char *cmd = szPath + sz;
5865 sz = RTPATH_MAX - sz;
5866
5867 int vrc = VINF_SUCCESS;
5868 RTPROCESS pid = NIL_RTPROCESS;
5869
5870 RTENV env = RTENV_DEFAULT;
5871
5872 if (aEnvironment != NULL && *aEnvironment)
5873 {
5874 char *newEnvStr = NULL;
5875
5876 do
5877 {
5878 /* clone the current environment */
5879 int vrc2 = RTEnvClone(&env, RTENV_DEFAULT);
5880 AssertRCBreakStmt(vrc2, vrc = vrc2);
5881
5882 newEnvStr = RTStrDup(Utf8Str(aEnvironment).c_str());
5883 AssertPtrBreakStmt(newEnvStr, vrc = vrc2);
5884
5885 /* put new variables to the environment
5886 * (ignore empty variable names here since RTEnv API
5887 * intentionally doesn't do that) */
5888 char *var = newEnvStr;
5889 for (char *p = newEnvStr; *p; ++p)
5890 {
5891 if (*p == '\n' && (p == newEnvStr || *(p - 1) != '\\'))
5892 {
5893 *p = '\0';
5894 if (*var)
5895 {
5896 char *val = strchr(var, '=');
5897 if (val)
5898 {
5899 *val++ = '\0';
5900 vrc2 = RTEnvSetEx(env, var, val);
5901 }
5902 else
5903 vrc2 = RTEnvUnsetEx(env, var);
5904 if (RT_FAILURE(vrc2))
5905 break;
5906 }
5907 var = p + 1;
5908 }
5909 }
5910 if (RT_SUCCESS(vrc2) && *var)
5911 vrc2 = RTEnvPutEx(env, var);
5912
5913 AssertRCBreakStmt(vrc2, vrc = vrc2);
5914 }
5915 while (0);
5916
5917 if (newEnvStr != NULL)
5918 RTStrFree(newEnvStr);
5919 }
5920
5921 Utf8Str strType(aType);
5922
5923 /* Qt is default */
5924#ifdef VBOX_WITH_QTGUI
5925 if (strType == "gui" || strType == "GUI/Qt")
5926 {
5927# ifdef RT_OS_DARWIN /* Avoid Launch Services confusing this with the selector by using a helper app. */
5928 const char VirtualBox_exe[] = "../Resources/VirtualBoxVM.app/Contents/MacOS/VirtualBoxVM";
5929# else
5930 const char VirtualBox_exe[] = "VirtualBox" HOSTSUFF_EXE;
5931# endif
5932 Assert(sz >= sizeof(VirtualBox_exe));
5933 strcpy(cmd, VirtualBox_exe);
5934
5935 Utf8Str idStr = mData->mUuid.toString();
5936 const char * args[] = {szPath, "--comment", mUserData->s.strName.c_str(), "--startvm", idStr.c_str(), "--no-startvm-errormsgbox", 0 };
5937 vrc = RTProcCreate(szPath, args, env, 0, &pid);
5938 }
5939#else /* !VBOX_WITH_QTGUI */
5940 if (0)
5941 ;
5942#endif /* VBOX_WITH_QTGUI */
5943
5944 else
5945
5946#ifdef VBOX_WITH_VBOXSDL
5947 if (strType == "sdl" || strType == "GUI/SDL")
5948 {
5949 const char VBoxSDL_exe[] = "VBoxSDL" HOSTSUFF_EXE;
5950 Assert(sz >= sizeof(VBoxSDL_exe));
5951 strcpy(cmd, VBoxSDL_exe);
5952
5953 Utf8Str idStr = mData->mUuid.toString();
5954 const char * args[] = {szPath, "--comment", mUserData->s.strName.c_str(), "--startvm", idStr.c_str(), 0 };
5955 vrc = RTProcCreate(szPath, args, env, 0, &pid);
5956 }
5957#else /* !VBOX_WITH_VBOXSDL */
5958 if (0)
5959 ;
5960#endif /* !VBOX_WITH_VBOXSDL */
5961
5962 else
5963
5964#ifdef VBOX_WITH_HEADLESS
5965 if ( strType == "headless"
5966 || strType == "capture"
5967#ifdef VBOX_WITH_VRDP
5968 || strType == "vrdp"
5969#endif
5970 )
5971 {
5972 const char VBoxHeadless_exe[] = "VBoxHeadless" HOSTSUFF_EXE;
5973 Assert(sz >= sizeof(VBoxHeadless_exe));
5974 strcpy(cmd, VBoxHeadless_exe);
5975
5976 Utf8Str idStr = mData->mUuid.toString();
5977 /* Leave space for 2 args, as "headless" needs --vrdp off on non-OSE. */
5978 const char * args[] = {szPath, "--comment", mUserData->s.strName.c_str(), "--startvm", idStr.c_str(), 0, 0, 0 };
5979#ifdef VBOX_WITH_VRDP
5980 if (strType == "headless")
5981 {
5982 unsigned pos = RT_ELEMENTS(args) - 3;
5983 args[pos++] = "--vrdp";
5984 args[pos] = "off";
5985 }
5986#endif
5987 if (strType == "capture")
5988 {
5989 unsigned pos = RT_ELEMENTS(args) - 3;
5990 args[pos] = "--capture";
5991 }
5992 vrc = RTProcCreate(szPath, args, env, 0, &pid);
5993 }
5994#else /* !VBOX_WITH_HEADLESS */
5995 if (0)
5996 ;
5997#endif /* !VBOX_WITH_HEADLESS */
5998 else
5999 {
6000 RTEnvDestroy(env);
6001 return setError(E_INVALIDARG,
6002 tr("Invalid session type: '%s'"),
6003 strType.c_str());
6004 }
6005
6006 RTEnvDestroy(env);
6007
6008 if (RT_FAILURE(vrc))
6009 return setError(VBOX_E_IPRT_ERROR,
6010 tr("Could not launch a process for the machine '%s' (%Rrc)"),
6011 mUserData->s.strName.c_str(), vrc);
6012
6013 LogFlowThisFunc(("launched.pid=%d(0x%x)\n", pid, pid));
6014
6015 /*
6016 * Note that we don't leave the lock here before calling the client,
6017 * because it doesn't need to call us back if called with a NULL argument.
6018 * Leaving the lock herer is dangerous because we didn't prepare the
6019 * launch data yet, but the client we've just started may happen to be
6020 * too fast and call openSession() that will fail (because of PID, etc.),
6021 * so that the Machine will never get out of the Spawning session state.
6022 */
6023
6024 /* inform the session that it will be a remote one */
6025 LogFlowThisFunc(("Calling AssignMachine (NULL)...\n"));
6026 HRESULT rc = aControl->AssignMachine(NULL);
6027 LogFlowThisFunc(("AssignMachine (NULL) returned %08X\n", rc));
6028
6029 if (FAILED(rc))
6030 {
6031 /* restore the session state */
6032 mData->mSession.mState = SessionState_Unlocked;
6033 /* The failure may occur w/o any error info (from RPC), so provide one */
6034 return setError(VBOX_E_VM_ERROR,
6035 tr("Failed to assign the machine to the session (%Rrc)"), rc);
6036 }
6037
6038 /* attach launch data to the machine */
6039 Assert(mData->mSession.mPid == NIL_RTPROCESS);
6040 mData->mSession.mRemoteControls.push_back (aControl);
6041 mData->mSession.mProgress = aProgress;
6042 mData->mSession.mPid = pid;
6043 mData->mSession.mState = SessionState_Spawning;
6044 mData->mSession.mType = strType;
6045
6046 LogFlowThisFuncLeave();
6047 return S_OK;
6048}
6049
6050/**
6051 * Returns @c true if the given machine has an open direct session and returns
6052 * the session machine instance and additional session data (on some platforms)
6053 * if so.
6054 *
6055 * Note that when the method returns @c false, the arguments remain unchanged.
6056 *
6057 * @param aMachine Session machine object.
6058 * @param aControl Direct session control object (optional).
6059 * @param aIPCSem Mutex IPC semaphore handle for this machine (optional).
6060 *
6061 * @note locks this object for reading.
6062 */
6063#if defined(RT_OS_WINDOWS)
6064bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
6065 ComPtr<IInternalSessionControl> *aControl /*= NULL*/,
6066 HANDLE *aIPCSem /*= NULL*/,
6067 bool aAllowClosing /*= false*/)
6068#elif defined(RT_OS_OS2)
6069bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
6070 ComPtr<IInternalSessionControl> *aControl /*= NULL*/,
6071 HMTX *aIPCSem /*= NULL*/,
6072 bool aAllowClosing /*= false*/)
6073#else
6074bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
6075 ComPtr<IInternalSessionControl> *aControl /*= NULL*/,
6076 bool aAllowClosing /*= false*/)
6077#endif
6078{
6079 AutoLimitedCaller autoCaller(this);
6080 AssertComRCReturn(autoCaller.rc(), false);
6081
6082 /* just return false for inaccessible machines */
6083 if (autoCaller.state() != Ready)
6084 return false;
6085
6086 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6087
6088 if ( mData->mSession.mState == SessionState_Locked
6089 || (aAllowClosing && mData->mSession.mState == SessionState_Unlocking)
6090 )
6091 {
6092 AssertReturn(!mData->mSession.mMachine.isNull(), false);
6093
6094 aMachine = mData->mSession.mMachine;
6095
6096 if (aControl != NULL)
6097 *aControl = mData->mSession.mDirectControl;
6098
6099#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
6100 /* Additional session data */
6101 if (aIPCSem != NULL)
6102 *aIPCSem = aMachine->mIPCSem;
6103#endif
6104 return true;
6105 }
6106
6107 return false;
6108}
6109
6110/**
6111 * Returns @c true if the given machine has an spawning direct session and
6112 * returns and additional session data (on some platforms) if so.
6113 *
6114 * Note that when the method returns @c false, the arguments remain unchanged.
6115 *
6116 * @param aPID PID of the spawned direct session process.
6117 *
6118 * @note locks this object for reading.
6119 */
6120#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
6121bool Machine::isSessionSpawning(RTPROCESS *aPID /*= NULL*/)
6122#else
6123bool Machine::isSessionSpawning()
6124#endif
6125{
6126 AutoLimitedCaller autoCaller(this);
6127 AssertComRCReturn(autoCaller.rc(), false);
6128
6129 /* just return false for inaccessible machines */
6130 if (autoCaller.state() != Ready)
6131 return false;
6132
6133 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
6134
6135 if (mData->mSession.mState == SessionState_Spawning)
6136 {
6137#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
6138 /* Additional session data */
6139 if (aPID != NULL)
6140 {
6141 AssertReturn(mData->mSession.mPid != NIL_RTPROCESS, false);
6142 *aPID = mData->mSession.mPid;
6143 }
6144#endif
6145 return true;
6146 }
6147
6148 return false;
6149}
6150
6151/**
6152 * Called from the client watcher thread to check for unexpected client process
6153 * death during Session_Spawning state (e.g. before it successfully opened a
6154 * direct session).
6155 *
6156 * On Win32 and on OS/2, this method is called only when we've got the
6157 * direct client's process termination notification, so it always returns @c
6158 * true.
6159 *
6160 * On other platforms, this method returns @c true if the client process is
6161 * terminated and @c false if it's still alive.
6162 *
6163 * @note Locks this object for writing.
6164 */
6165bool Machine::checkForSpawnFailure()
6166{
6167 AutoCaller autoCaller(this);
6168 if (!autoCaller.isOk())
6169 {
6170 /* nothing to do */
6171 LogFlowThisFunc(("Already uninitialized!\n"));
6172 return true;
6173 }
6174
6175 /* VirtualBox::addProcessToReap() needs a write lock */
6176 AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
6177
6178 if (mData->mSession.mState != SessionState_Spawning)
6179 {
6180 /* nothing to do */
6181 LogFlowThisFunc(("Not spawning any more!\n"));
6182 return true;
6183 }
6184
6185 HRESULT rc = S_OK;
6186
6187#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
6188
6189 /* the process was already unexpectedly terminated, we just need to set an
6190 * error and finalize session spawning */
6191 rc = setError(E_FAIL,
6192 tr("The virtual machine '%ls' has terminated unexpectedly during startup"),
6193 getName().c_str());
6194#else
6195
6196 /* PID not yet initialized, skip check. */
6197 if (mData->mSession.mPid == NIL_RTPROCESS)
6198 return false;
6199
6200 RTPROCSTATUS status;
6201 int vrc = ::RTProcWait(mData->mSession.mPid, RTPROCWAIT_FLAGS_NOBLOCK,
6202 &status);
6203
6204 if (vrc != VERR_PROCESS_RUNNING)
6205 {
6206 if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_NORMAL)
6207 rc = setError(E_FAIL,
6208 tr("The virtual machine '%s' has terminated unexpectedly during startup with exit code %d"),
6209 getName().c_str(), status.iStatus);
6210 else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_SIGNAL)
6211 rc = setError(E_FAIL,
6212 tr("The virtual machine '%s' has terminated unexpectedly during startup because of signal %d"),
6213 getName().c_str(), status.iStatus);
6214 else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_ABEND)
6215 rc = setError(E_FAIL,
6216 tr("The virtual machine '%s' has terminated abnormally"),
6217 getName().c_str(), status.iStatus);
6218 else
6219 rc = setError(E_FAIL,
6220 tr("The virtual machine '%s' has terminated unexpectedly during startup (%Rrc)"),
6221 getName().c_str(), rc);
6222 }
6223
6224#endif
6225
6226 if (FAILED(rc))
6227 {
6228 /* Close the remote session, remove the remote control from the list
6229 * and reset session state to Closed (@note keep the code in sync with
6230 * the relevant part in checkForSpawnFailure()). */
6231
6232 Assert(mData->mSession.mRemoteControls.size() == 1);
6233 if (mData->mSession.mRemoteControls.size() == 1)
6234 {
6235 ErrorInfoKeeper eik;
6236 mData->mSession.mRemoteControls.front()->Uninitialize();
6237 }
6238
6239 mData->mSession.mRemoteControls.clear();
6240 mData->mSession.mState = SessionState_Unlocked;
6241
6242 /* finalize the progress after setting the state */
6243 if (!mData->mSession.mProgress.isNull())
6244 {
6245 mData->mSession.mProgress->notifyComplete(rc);
6246 mData->mSession.mProgress.setNull();
6247 }
6248
6249 mParent->addProcessToReap(mData->mSession.mPid);
6250 mData->mSession.mPid = NIL_RTPROCESS;
6251
6252 mParent->onSessionStateChange(mData->mUuid, SessionState_Unlocked);
6253 return true;
6254 }
6255
6256 return false;
6257}
6258
6259/**
6260 * Checks whether the machine can be registered. If so, commits and saves
6261 * all settings.
6262 *
6263 * @note Must be called from mParent's write lock. Locks this object and
6264 * children for writing.
6265 */
6266HRESULT Machine::prepareRegister()
6267{
6268 AssertReturn(mParent->isWriteLockOnCurrentThread(), E_FAIL);
6269
6270 AutoLimitedCaller autoCaller(this);
6271 AssertComRCReturnRC(autoCaller.rc());
6272
6273 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6274
6275 /* wait for state dependants to drop to zero */
6276 ensureNoStateDependencies();
6277
6278 if (!mData->mAccessible)
6279 return setError(VBOX_E_INVALID_OBJECT_STATE,
6280 tr("The machine '%s' with UUID {%s} is inaccessible and cannot be registered"),
6281 mUserData->s.strName.c_str(),
6282 mData->mUuid.toString().c_str());
6283
6284 AssertReturn(autoCaller.state() == Ready, E_FAIL);
6285
6286 if (mData->mRegistered)
6287 return setError(VBOX_E_INVALID_OBJECT_STATE,
6288 tr("The machine '%s' with UUID {%s} is already registered"),
6289 mUserData->s.strName.c_str(),
6290 mData->mUuid.toString().c_str());
6291
6292 HRESULT rc = S_OK;
6293
6294 // Ensure the settings are saved. If we are going to be registered and
6295 // no config file exists yet, create it by calling saveSettings() too.
6296 if ( (mData->flModifications)
6297 || (!mData->pMachineConfigFile->fileExists())
6298 )
6299 {
6300 rc = saveSettings(NULL);
6301 // no need to check whether VirtualBox.xml needs saving too since
6302 // we can't have a machine XML file rename pending
6303 if (FAILED(rc)) return rc;
6304 }
6305
6306 /* more config checking goes here */
6307
6308 if (SUCCEEDED(rc))
6309 {
6310 /* we may have had implicit modifications we want to fix on success */
6311 commit();
6312
6313 mData->mRegistered = true;
6314 }
6315 else
6316 {
6317 /* we may have had implicit modifications we want to cancel on failure*/
6318 rollback(false /* aNotify */);
6319 }
6320
6321 return rc;
6322}
6323
6324/**
6325 * Increases the number of objects dependent on the machine state or on the
6326 * registered state. Guarantees that these two states will not change at least
6327 * until #releaseStateDependency() is called.
6328 *
6329 * Depending on the @a aDepType value, additional state checks may be made.
6330 * These checks will set extended error info on failure. See
6331 * #checkStateDependency() for more info.
6332 *
6333 * If this method returns a failure, the dependency is not added and the caller
6334 * is not allowed to rely on any particular machine state or registration state
6335 * value and may return the failed result code to the upper level.
6336 *
6337 * @param aDepType Dependency type to add.
6338 * @param aState Current machine state (NULL if not interested).
6339 * @param aRegistered Current registered state (NULL if not interested).
6340 *
6341 * @note Locks this object for writing.
6342 */
6343HRESULT Machine::addStateDependency(StateDependency aDepType /* = AnyStateDep */,
6344 MachineState_T *aState /* = NULL */,
6345 BOOL *aRegistered /* = NULL */)
6346{
6347 AutoCaller autoCaller(this);
6348 AssertComRCReturnRC(autoCaller.rc());
6349
6350 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6351
6352 HRESULT rc = checkStateDependency(aDepType);
6353 if (FAILED(rc)) return rc;
6354
6355 {
6356 if (mData->mMachineStateChangePending != 0)
6357 {
6358 /* ensureNoStateDependencies() is waiting for state dependencies to
6359 * drop to zero so don't add more. It may make sense to wait a bit
6360 * and retry before reporting an error (since the pending state
6361 * transition should be really quick) but let's just assert for
6362 * now to see if it ever happens on practice. */
6363
6364 AssertFailed();
6365
6366 return setError(E_ACCESSDENIED,
6367 tr("Machine state change is in progress. Please retry the operation later."));
6368 }
6369
6370 ++mData->mMachineStateDeps;
6371 Assert(mData->mMachineStateDeps != 0 /* overflow */);
6372 }
6373
6374 if (aState)
6375 *aState = mData->mMachineState;
6376 if (aRegistered)
6377 *aRegistered = mData->mRegistered;
6378
6379 return S_OK;
6380}
6381
6382/**
6383 * Decreases the number of objects dependent on the machine state.
6384 * Must always complete the #addStateDependency() call after the state
6385 * dependency is no more necessary.
6386 */
6387void Machine::releaseStateDependency()
6388{
6389 AutoCaller autoCaller(this);
6390 AssertComRCReturnVoid(autoCaller.rc());
6391
6392 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6393
6394 /* releaseStateDependency() w/o addStateDependency()? */
6395 AssertReturnVoid(mData->mMachineStateDeps != 0);
6396 -- mData->mMachineStateDeps;
6397
6398 if (mData->mMachineStateDeps == 0)
6399 {
6400 /* inform ensureNoStateDependencies() that there are no more deps */
6401 if (mData->mMachineStateChangePending != 0)
6402 {
6403 Assert(mData->mMachineStateDepsSem != NIL_RTSEMEVENTMULTI);
6404 RTSemEventMultiSignal (mData->mMachineStateDepsSem);
6405 }
6406 }
6407}
6408
6409// protected methods
6410/////////////////////////////////////////////////////////////////////////////
6411
6412/**
6413 * Performs machine state checks based on the @a aDepType value. If a check
6414 * fails, this method will set extended error info, otherwise it will return
6415 * S_OK. It is supposed, that on failure, the caller will immedieately return
6416 * the return value of this method to the upper level.
6417 *
6418 * When @a aDepType is AnyStateDep, this method always returns S_OK.
6419 *
6420 * When @a aDepType is MutableStateDep, this method returns S_OK only if the
6421 * current state of this machine object allows to change settings of the
6422 * machine (i.e. the machine is not registered, or registered but not running
6423 * and not saved). It is useful to call this method from Machine setters
6424 * before performing any change.
6425 *
6426 * When @a aDepType is MutableOrSavedStateDep, this method behaves the same
6427 * as for MutableStateDep except that if the machine is saved, S_OK is also
6428 * returned. This is useful in setters which allow changing machine
6429 * properties when it is in the saved state.
6430 *
6431 * @param aDepType Dependency type to check.
6432 *
6433 * @note Non Machine based classes should use #addStateDependency() and
6434 * #releaseStateDependency() methods or the smart AutoStateDependency
6435 * template.
6436 *
6437 * @note This method must be called from under this object's read or write
6438 * lock.
6439 */
6440HRESULT Machine::checkStateDependency(StateDependency aDepType)
6441{
6442 switch (aDepType)
6443 {
6444 case AnyStateDep:
6445 {
6446 break;
6447 }
6448 case MutableStateDep:
6449 {
6450 if ( mData->mRegistered
6451 && ( !isSessionMachine() /** @todo This was just convered raw; Check if Running and Paused should actually be included here... (Live Migration) */
6452 || ( mData->mMachineState != MachineState_Paused
6453 && mData->mMachineState != MachineState_Running
6454 && mData->mMachineState != MachineState_Aborted
6455 && mData->mMachineState != MachineState_Teleported
6456 && mData->mMachineState != MachineState_PoweredOff
6457 )
6458 )
6459 )
6460 return setError(VBOX_E_INVALID_VM_STATE,
6461 tr("The machine is not mutable (state is %s)"),
6462 Global::stringifyMachineState(mData->mMachineState));
6463 break;
6464 }
6465 case MutableOrSavedStateDep:
6466 {
6467 if ( mData->mRegistered
6468 && ( !isSessionMachine() /** @todo This was just convered raw; Check if Running and Paused should actually be included here... (Live Migration) */
6469 || ( mData->mMachineState != MachineState_Paused
6470 && mData->mMachineState != MachineState_Running
6471 && mData->mMachineState != MachineState_Aborted
6472 && mData->mMachineState != MachineState_Teleported
6473 && mData->mMachineState != MachineState_Saved
6474 && mData->mMachineState != MachineState_PoweredOff
6475 )
6476 )
6477 )
6478 return setError(VBOX_E_INVALID_VM_STATE,
6479 tr("The machine is not mutable (state is %s)"),
6480 Global::stringifyMachineState(mData->mMachineState));
6481 break;
6482 }
6483 }
6484
6485 return S_OK;
6486}
6487
6488/**
6489 * Helper to initialize all associated child objects and allocate data
6490 * structures.
6491 *
6492 * This method must be called as a part of the object's initialization procedure
6493 * (usually done in the #init() method).
6494 *
6495 * @note Must be called only from #init() or from #registeredInit().
6496 */
6497HRESULT Machine::initDataAndChildObjects()
6498{
6499 AutoCaller autoCaller(this);
6500 AssertComRCReturnRC(autoCaller.rc());
6501 AssertComRCReturn(autoCaller.state() == InInit ||
6502 autoCaller.state() == Limited, E_FAIL);
6503
6504 AssertReturn(!mData->mAccessible, E_FAIL);
6505
6506 /* allocate data structures */
6507 mSSData.allocate();
6508 mUserData.allocate();
6509 mHWData.allocate();
6510 mMediaData.allocate();
6511 mStorageControllers.allocate();
6512
6513 /* initialize mOSTypeId */
6514 mUserData->s.strOsType = mParent->getUnknownOSType()->id();
6515
6516 /* create associated BIOS settings object */
6517 unconst(mBIOSSettings).createObject();
6518 mBIOSSettings->init(this);
6519
6520#ifdef VBOX_WITH_VRDP
6521 /* create an associated VRDPServer object (default is disabled) */
6522 unconst(mVRDPServer).createObject();
6523 mVRDPServer->init(this);
6524#endif
6525
6526 /* create associated serial port objects */
6527 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
6528 {
6529 unconst(mSerialPorts[slot]).createObject();
6530 mSerialPorts[slot]->init(this, slot);
6531 }
6532
6533 /* create associated parallel port objects */
6534 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
6535 {
6536 unconst(mParallelPorts[slot]).createObject();
6537 mParallelPorts[slot]->init(this, slot);
6538 }
6539
6540 /* create the audio adapter object (always present, default is disabled) */
6541 unconst(mAudioAdapter).createObject();
6542 mAudioAdapter->init(this);
6543
6544 /* create the USB controller object (always present, default is disabled) */
6545 unconst(mUSBController).createObject();
6546 mUSBController->init(this);
6547
6548 /* create associated network adapter objects */
6549 for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot ++)
6550 {
6551 unconst(mNetworkAdapters[slot]).createObject();
6552 mNetworkAdapters[slot]->init(this, slot);
6553 }
6554
6555 return S_OK;
6556}
6557
6558/**
6559 * Helper to uninitialize all associated child objects and to free all data
6560 * structures.
6561 *
6562 * This method must be called as a part of the object's uninitialization
6563 * procedure (usually done in the #uninit() method).
6564 *
6565 * @note Must be called only from #uninit() or from #registeredInit().
6566 */
6567void Machine::uninitDataAndChildObjects()
6568{
6569 AutoCaller autoCaller(this);
6570 AssertComRCReturnVoid(autoCaller.rc());
6571 AssertComRCReturnVoid( autoCaller.state() == InUninit
6572 || autoCaller.state() == Limited);
6573
6574 /* uninit all children using addDependentChild()/removeDependentChild()
6575 * in their init()/uninit() methods */
6576 uninitDependentChildren();
6577
6578 /* tell all our other child objects we've been uninitialized */
6579
6580 for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
6581 {
6582 if (mNetworkAdapters[slot])
6583 {
6584 mNetworkAdapters[slot]->uninit();
6585 unconst(mNetworkAdapters[slot]).setNull();
6586 }
6587 }
6588
6589 if (mUSBController)
6590 {
6591 mUSBController->uninit();
6592 unconst(mUSBController).setNull();
6593 }
6594
6595 if (mAudioAdapter)
6596 {
6597 mAudioAdapter->uninit();
6598 unconst(mAudioAdapter).setNull();
6599 }
6600
6601 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
6602 {
6603 if (mParallelPorts[slot])
6604 {
6605 mParallelPorts[slot]->uninit();
6606 unconst(mParallelPorts[slot]).setNull();
6607 }
6608 }
6609
6610 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
6611 {
6612 if (mSerialPorts[slot])
6613 {
6614 mSerialPorts[slot]->uninit();
6615 unconst(mSerialPorts[slot]).setNull();
6616 }
6617 }
6618
6619#ifdef VBOX_WITH_VRDP
6620 if (mVRDPServer)
6621 {
6622 mVRDPServer->uninit();
6623 unconst(mVRDPServer).setNull();
6624 }
6625#endif
6626
6627 if (mBIOSSettings)
6628 {
6629 mBIOSSettings->uninit();
6630 unconst(mBIOSSettings).setNull();
6631 }
6632
6633 /* Deassociate hard disks (only when a real Machine or a SnapshotMachine
6634 * instance is uninitialized; SessionMachine instances refer to real
6635 * Machine hard disks). This is necessary for a clean re-initialization of
6636 * the VM after successfully re-checking the accessibility state. Note
6637 * that in case of normal Machine or SnapshotMachine uninitialization (as
6638 * a result of unregistering or deleting the snapshot), outdated hard
6639 * disk attachments will already be uninitialized and deleted, so this
6640 * code will not affect them. */
6641 if ( !!mMediaData
6642 && (!isSessionMachine())
6643 )
6644 {
6645 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
6646 it != mMediaData->mAttachments.end();
6647 ++it)
6648 {
6649 ComObjPtr<Medium> hd = (*it)->getMedium();
6650 if (hd.isNull())
6651 continue;
6652 HRESULT rc = hd->removeBackReference(mData->mUuid, getSnapshotId());
6653 AssertComRC(rc);
6654 }
6655 }
6656
6657 if (!isSessionMachine() && !isSnapshotMachine())
6658 {
6659 // clean up the snapshots list (Snapshot::uninit() will handle the snapshot's children recursively)
6660 if (mData->mFirstSnapshot)
6661 {
6662 // snapshots tree is protected by media write lock; strictly
6663 // this isn't necessary here since we're deleting the entire
6664 // machine, but otherwise we assert in Snapshot::uninit()
6665 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6666 mData->mFirstSnapshot->uninit();
6667 mData->mFirstSnapshot.setNull();
6668 }
6669
6670 mData->mCurrentSnapshot.setNull();
6671 }
6672
6673 /* free data structures (the essential mData structure is not freed here
6674 * since it may be still in use) */
6675 mMediaData.free();
6676 mStorageControllers.free();
6677 mHWData.free();
6678 mUserData.free();
6679 mSSData.free();
6680}
6681
6682/**
6683 * Returns a pointer to the Machine object for this machine that acts like a
6684 * parent for complex machine data objects such as shared folders, etc.
6685 *
6686 * For primary Machine objects and for SnapshotMachine objects, returns this
6687 * object's pointer itself. For SessoinMachine objects, returns the peer
6688 * (primary) machine pointer.
6689 */
6690Machine* Machine::getMachine()
6691{
6692 if (isSessionMachine())
6693 return (Machine*)mPeer;
6694 return this;
6695}
6696
6697/**
6698 * Makes sure that there are no machine state dependants. If necessary, waits
6699 * for the number of dependants to drop to zero.
6700 *
6701 * Make sure this method is called from under this object's write lock to
6702 * guarantee that no new dependants may be added when this method returns
6703 * control to the caller.
6704 *
6705 * @note Locks this object for writing. The lock will be released while waiting
6706 * (if necessary).
6707 *
6708 * @warning To be used only in methods that change the machine state!
6709 */
6710void Machine::ensureNoStateDependencies()
6711{
6712 AssertReturnVoid(isWriteLockOnCurrentThread());
6713
6714 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6715
6716 /* Wait for all state dependants if necessary */
6717 if (mData->mMachineStateDeps != 0)
6718 {
6719 /* lazy semaphore creation */
6720 if (mData->mMachineStateDepsSem == NIL_RTSEMEVENTMULTI)
6721 RTSemEventMultiCreate(&mData->mMachineStateDepsSem);
6722
6723 LogFlowThisFunc(("Waiting for state deps (%d) to drop to zero...\n",
6724 mData->mMachineStateDeps));
6725
6726 ++mData->mMachineStateChangePending;
6727
6728 /* reset the semaphore before waiting, the last dependant will signal
6729 * it */
6730 RTSemEventMultiReset(mData->mMachineStateDepsSem);
6731
6732 alock.leave();
6733
6734 RTSemEventMultiWait(mData->mMachineStateDepsSem, RT_INDEFINITE_WAIT);
6735
6736 alock.enter();
6737
6738 -- mData->mMachineStateChangePending;
6739 }
6740}
6741
6742/**
6743 * Changes the machine state and informs callbacks.
6744 *
6745 * This method is not intended to fail so it either returns S_OK or asserts (and
6746 * returns a failure).
6747 *
6748 * @note Locks this object for writing.
6749 */
6750HRESULT Machine::setMachineState(MachineState_T aMachineState)
6751{
6752 LogFlowThisFuncEnter();
6753 LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
6754
6755 AutoCaller autoCaller(this);
6756 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
6757
6758 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
6759
6760 /* wait for state dependants to drop to zero */
6761 ensureNoStateDependencies();
6762
6763 if (mData->mMachineState != aMachineState)
6764 {
6765 mData->mMachineState = aMachineState;
6766
6767 RTTimeNow(&mData->mLastStateChange);
6768
6769 mParent->onMachineStateChange(mData->mUuid, aMachineState);
6770 }
6771
6772 LogFlowThisFuncLeave();
6773 return S_OK;
6774}
6775
6776/**
6777 * Searches for a shared folder with the given logical name
6778 * in the collection of shared folders.
6779 *
6780 * @param aName logical name of the shared folder
6781 * @param aSharedFolder where to return the found object
6782 * @param aSetError whether to set the error info if the folder is
6783 * not found
6784 * @return
6785 * S_OK when found or VBOX_E_OBJECT_NOT_FOUND when not found
6786 *
6787 * @note
6788 * must be called from under the object's lock!
6789 */
6790HRESULT Machine::findSharedFolder(CBSTR aName,
6791 ComObjPtr<SharedFolder> &aSharedFolder,
6792 bool aSetError /* = false */)
6793{
6794 bool found = false;
6795 for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
6796 !found && it != mHWData->mSharedFolders.end();
6797 ++it)
6798 {
6799 AutoWriteLock alock(*it COMMA_LOCKVAL_SRC_POS);
6800 found = (*it)->getName() == aName;
6801 if (found)
6802 aSharedFolder = *it;
6803 }
6804
6805 HRESULT rc = found ? S_OK : VBOX_E_OBJECT_NOT_FOUND;
6806
6807 if (aSetError && !found)
6808 setError(rc, tr("Could not find a shared folder named '%ls'"), aName);
6809
6810 return rc;
6811}
6812
6813/**
6814 * Initializes all machine instance data from the given settings structures
6815 * from XML. The exception is the machine UUID which needs special handling
6816 * depending on the caller's use case, so the caller needs to set that herself.
6817 *
6818 * This gets called in several contexts during machine initialization:
6819 *
6820 * -- When machine XML exists on disk already and needs to be loaded into memory,
6821 * for example, from registeredInit() to load all registered machines on
6822 * VirtualBox startup. In this case, puuidRegistry is NULL because the media
6823 * attached to the machine should be part of some media registry already.
6824 *
6825 * -- During OVF import, when a machine config has been constructed from an
6826 * OVF file. In this case, puuidRegistry is set to the machine UUID to
6827 * ensure that the media listed as attachments in the config (which have
6828 * been imported from the OVF) receive the correct registry ID.
6829 *
6830 * @param config Machine settings from XML.
6831 * @param puuidRegistry If != NULL, Medium::setRegistryIdIfFirst() gets called with this registry ID for each attached medium in the config.
6832 * @return
6833 */
6834HRESULT Machine::loadMachineDataFromSettings(const settings::MachineConfigFile &config,
6835 const Guid *puuidRegistry)
6836{
6837 // copy name, description, OS type, teleporter, UTC etc.
6838 mUserData->s = config.machineUserData;
6839
6840 // look up the object by Id to check it is valid
6841 ComPtr<IGuestOSType> guestOSType;
6842 HRESULT rc = mParent->GetGuestOSType(Bstr(mUserData->s.strOsType).raw(),
6843 guestOSType.asOutParam());
6844 if (FAILED(rc)) return rc;
6845
6846 // stateFile (optional)
6847 if (config.strStateFile.isEmpty())
6848 mSSData->mStateFilePath.setNull();
6849 else
6850 {
6851 Utf8Str stateFilePathFull(config.strStateFile);
6852 int vrc = calculateFullPath(stateFilePathFull, stateFilePathFull);
6853 if (RT_FAILURE(vrc))
6854 return setError(E_FAIL,
6855 tr("Invalid saved state file path '%s' (%Rrc)"),
6856 config.strStateFile.c_str(),
6857 vrc);
6858 mSSData->mStateFilePath = stateFilePathFull;
6859 }
6860
6861 // snapshot folder needs special processing so set it again
6862 rc = COMSETTER(SnapshotFolder)(Bstr(config.machineUserData.strSnapshotFolder).raw());
6863 if (FAILED(rc)) return rc;
6864
6865 /* currentStateModified (optional, default is true) */
6866 mData->mCurrentStateModified = config.fCurrentStateModified;
6867
6868 mData->mLastStateChange = config.timeLastStateChange;
6869
6870 /*
6871 * note: all mUserData members must be assigned prior this point because
6872 * we need to commit changes in order to let mUserData be shared by all
6873 * snapshot machine instances.
6874 */
6875 mUserData.commitCopy();
6876
6877 // machine registry, if present (must be loaded before snapshots)
6878 if (config.canHaveOwnMediaRegistry())
6879 {
6880 rc = mParent->initMedia(getId(), // media registry ID == machine UUID
6881 config.mediaRegistry);
6882 if (FAILED(rc)) return rc;
6883 }
6884
6885 /* Snapshot node (optional) */
6886 size_t cRootSnapshots;
6887 if ((cRootSnapshots = config.llFirstSnapshot.size()))
6888 {
6889 // there must be only one root snapshot
6890 Assert(cRootSnapshots == 1);
6891
6892 const settings::Snapshot &snap = config.llFirstSnapshot.front();
6893
6894 rc = loadSnapshot(snap,
6895 config.uuidCurrentSnapshot,
6896 NULL); // no parent == first snapshot
6897 if (FAILED(rc)) return rc;
6898 }
6899
6900 // hardware data
6901 rc = loadHardware(config.hardwareMachine);
6902 if (FAILED(rc)) return rc;
6903
6904 // load storage controllers
6905 rc = loadStorageControllers(config.storageMachine,
6906 puuidRegistry,
6907 NULL /* puuidSnapshot */);
6908 if (FAILED(rc)) return rc;
6909
6910 /*
6911 * NOTE: the assignment below must be the last thing to do,
6912 * otherwise it will be not possible to change the settings
6913 * somewehere in the code above because all setters will be
6914 * blocked by checkStateDependency(MutableStateDep).
6915 */
6916
6917 /* set the machine state to Aborted or Saved when appropriate */
6918 if (config.fAborted)
6919 {
6920 Assert(!mSSData->mStateFilePath.isEmpty());
6921 mSSData->mStateFilePath.setNull();
6922
6923 /* no need to use setMachineState() during init() */
6924 mData->mMachineState = MachineState_Aborted;
6925 }
6926 else if (!mSSData->mStateFilePath.isEmpty())
6927 {
6928 /* no need to use setMachineState() during init() */
6929 mData->mMachineState = MachineState_Saved;
6930 }
6931
6932 // after loading settings, we are no longer different from the XML on disk
6933 mData->flModifications = 0;
6934
6935 return S_OK;
6936}
6937
6938/**
6939 * Recursively loads all snapshots starting from the given.
6940 *
6941 * @param aNode <Snapshot> node.
6942 * @param aCurSnapshotId Current snapshot ID from the settings file.
6943 * @param aParentSnapshot Parent snapshot.
6944 */
6945HRESULT Machine::loadSnapshot(const settings::Snapshot &data,
6946 const Guid &aCurSnapshotId,
6947 Snapshot *aParentSnapshot)
6948{
6949 AssertReturn(!isSnapshotMachine(), E_FAIL);
6950 AssertReturn(!isSessionMachine(), E_FAIL);
6951
6952 HRESULT rc = S_OK;
6953
6954 Utf8Str strStateFile;
6955 if (!data.strStateFile.isEmpty())
6956 {
6957 /* optional */
6958 strStateFile = data.strStateFile;
6959 int vrc = calculateFullPath(strStateFile, strStateFile);
6960 if (RT_FAILURE(vrc))
6961 return setError(E_FAIL,
6962 tr("Invalid saved state file path '%s' (%Rrc)"),
6963 strStateFile.c_str(),
6964 vrc);
6965 }
6966
6967 /* create a snapshot machine object */
6968 ComObjPtr<SnapshotMachine> pSnapshotMachine;
6969 pSnapshotMachine.createObject();
6970 rc = pSnapshotMachine->init(this,
6971 data.hardware,
6972 data.storage,
6973 data.uuid.ref(),
6974 strStateFile);
6975 if (FAILED(rc)) return rc;
6976
6977 /* create a snapshot object */
6978 ComObjPtr<Snapshot> pSnapshot;
6979 pSnapshot.createObject();
6980 /* initialize the snapshot */
6981 rc = pSnapshot->init(mParent, // VirtualBox object
6982 data.uuid,
6983 data.strName,
6984 data.strDescription,
6985 data.timestamp,
6986 pSnapshotMachine,
6987 aParentSnapshot);
6988 if (FAILED(rc)) return rc;
6989
6990 /* memorize the first snapshot if necessary */
6991 if (!mData->mFirstSnapshot)
6992 mData->mFirstSnapshot = pSnapshot;
6993
6994 /* memorize the current snapshot when appropriate */
6995 if ( !mData->mCurrentSnapshot
6996 && pSnapshot->getId() == aCurSnapshotId
6997 )
6998 mData->mCurrentSnapshot = pSnapshot;
6999
7000 // now create the children
7001 for (settings::SnapshotsList::const_iterator it = data.llChildSnapshots.begin();
7002 it != data.llChildSnapshots.end();
7003 ++it)
7004 {
7005 const settings::Snapshot &childData = *it;
7006 // recurse
7007 rc = loadSnapshot(childData,
7008 aCurSnapshotId,
7009 pSnapshot); // parent = the one we created above
7010 if (FAILED(rc)) return rc;
7011 }
7012
7013 return rc;
7014}
7015
7016/**
7017 * @param aNode <Hardware> node.
7018 */
7019HRESULT Machine::loadHardware(const settings::Hardware &data)
7020{
7021 AssertReturn(!isSessionMachine(), E_FAIL);
7022
7023 HRESULT rc = S_OK;
7024
7025 try
7026 {
7027 /* The hardware version attribute (optional). */
7028 mHWData->mHWVersion = data.strVersion;
7029 mHWData->mHardwareUUID = data.uuid;
7030
7031 mHWData->mHWVirtExEnabled = data.fHardwareVirt;
7032 mHWData->mHWVirtExExclusive = data.fHardwareVirtExclusive;
7033 mHWData->mHWVirtExNestedPagingEnabled = data.fNestedPaging;
7034 mHWData->mHWVirtExLargePagesEnabled = data.fLargePages;
7035 mHWData->mHWVirtExVPIDEnabled = data.fVPID;
7036 mHWData->mHWVirtExForceEnabled = data.fHardwareVirtForce;
7037 mHWData->mPAEEnabled = data.fPAE;
7038 mHWData->mSyntheticCpu = data.fSyntheticCpu;
7039
7040 mHWData->mCPUCount = data.cCPUs;
7041 mHWData->mCPUHotPlugEnabled = data.fCpuHotPlug;
7042 mHWData->mCpuExecutionCap = data.ulCpuExecutionCap;
7043
7044 // cpu
7045 if (mHWData->mCPUHotPlugEnabled)
7046 {
7047 for (settings::CpuList::const_iterator it = data.llCpus.begin();
7048 it != data.llCpus.end();
7049 ++it)
7050 {
7051 const settings::Cpu &cpu = *it;
7052
7053 mHWData->mCPUAttached[cpu.ulId] = true;
7054 }
7055 }
7056
7057 // cpuid leafs
7058 for (settings::CpuIdLeafsList::const_iterator it = data.llCpuIdLeafs.begin();
7059 it != data.llCpuIdLeafs.end();
7060 ++it)
7061 {
7062 const settings::CpuIdLeaf &leaf = *it;
7063
7064 switch (leaf.ulId)
7065 {
7066 case 0x0:
7067 case 0x1:
7068 case 0x2:
7069 case 0x3:
7070 case 0x4:
7071 case 0x5:
7072 case 0x6:
7073 case 0x7:
7074 case 0x8:
7075 case 0x9:
7076 case 0xA:
7077 mHWData->mCpuIdStdLeafs[leaf.ulId] = leaf;
7078 break;
7079
7080 case 0x80000000:
7081 case 0x80000001:
7082 case 0x80000002:
7083 case 0x80000003:
7084 case 0x80000004:
7085 case 0x80000005:
7086 case 0x80000006:
7087 case 0x80000007:
7088 case 0x80000008:
7089 case 0x80000009:
7090 case 0x8000000A:
7091 mHWData->mCpuIdExtLeafs[leaf.ulId - 0x80000000] = leaf;
7092 break;
7093
7094 default:
7095 /* just ignore */
7096 break;
7097 }
7098 }
7099
7100 mHWData->mMemorySize = data.ulMemorySizeMB;
7101 mHWData->mPageFusionEnabled = data.fPageFusionEnabled;
7102
7103 // boot order
7104 for (size_t i = 0;
7105 i < RT_ELEMENTS(mHWData->mBootOrder);
7106 i++)
7107 {
7108 settings::BootOrderMap::const_iterator it = data.mapBootOrder.find(i);
7109 if (it == data.mapBootOrder.end())
7110 mHWData->mBootOrder[i] = DeviceType_Null;
7111 else
7112 mHWData->mBootOrder[i] = it->second;
7113 }
7114
7115 mHWData->mVRAMSize = data.ulVRAMSizeMB;
7116 mHWData->mMonitorCount = data.cMonitors;
7117 mHWData->mAccelerate3DEnabled = data.fAccelerate3D;
7118 mHWData->mAccelerate2DVideoEnabled = data.fAccelerate2DVideo;
7119 mHWData->mFirmwareType = data.firmwareType;
7120 mHWData->mPointingHidType = data.pointingHidType;
7121 mHWData->mKeyboardHidType = data.keyboardHidType;
7122 mHWData->mChipsetType = data.chipsetType;
7123 mHWData->mHpetEnabled = data.fHpetEnabled;
7124
7125#ifdef VBOX_WITH_VRDP
7126 /* RemoteDisplay */
7127 rc = mVRDPServer->loadSettings(data.vrdpSettings);
7128 if (FAILED(rc)) return rc;
7129#endif
7130
7131 /* BIOS */
7132 rc = mBIOSSettings->loadSettings(data.biosSettings);
7133 if (FAILED(rc)) return rc;
7134
7135 /* USB Controller */
7136 rc = mUSBController->loadSettings(data.usbController);
7137 if (FAILED(rc)) return rc;
7138
7139 // network adapters
7140 for (settings::NetworkAdaptersList::const_iterator it = data.llNetworkAdapters.begin();
7141 it != data.llNetworkAdapters.end();
7142 ++it)
7143 {
7144 const settings::NetworkAdapter &nic = *it;
7145
7146 /* slot unicity is guaranteed by XML Schema */
7147 AssertBreak(nic.ulSlot < RT_ELEMENTS(mNetworkAdapters));
7148 rc = mNetworkAdapters[nic.ulSlot]->loadSettings(nic);
7149 if (FAILED(rc)) return rc;
7150 }
7151
7152 // serial ports
7153 for (settings::SerialPortsList::const_iterator it = data.llSerialPorts.begin();
7154 it != data.llSerialPorts.end();
7155 ++it)
7156 {
7157 const settings::SerialPort &s = *it;
7158
7159 AssertBreak(s.ulSlot < RT_ELEMENTS(mSerialPorts));
7160 rc = mSerialPorts[s.ulSlot]->loadSettings(s);
7161 if (FAILED(rc)) return rc;
7162 }
7163
7164 // parallel ports (optional)
7165 for (settings::ParallelPortsList::const_iterator it = data.llParallelPorts.begin();
7166 it != data.llParallelPorts.end();
7167 ++it)
7168 {
7169 const settings::ParallelPort &p = *it;
7170
7171 AssertBreak(p.ulSlot < RT_ELEMENTS(mParallelPorts));
7172 rc = mParallelPorts[p.ulSlot]->loadSettings(p);
7173 if (FAILED(rc)) return rc;
7174 }
7175
7176 /* AudioAdapter */
7177 rc = mAudioAdapter->loadSettings(data.audioAdapter);
7178 if (FAILED(rc)) return rc;
7179
7180 for (settings::SharedFoldersList::const_iterator it = data.llSharedFolders.begin();
7181 it != data.llSharedFolders.end();
7182 ++it)
7183 {
7184 const settings::SharedFolder &sf = *it;
7185 rc = CreateSharedFolder(Bstr(sf.strName).raw(),
7186 Bstr(sf.strHostPath).raw(),
7187 sf.fWritable, sf.fAutoMount);
7188 if (FAILED(rc)) return rc;
7189 }
7190
7191 // Clipboard
7192 mHWData->mClipboardMode = data.clipboardMode;
7193
7194 // guest settings
7195 mHWData->mMemoryBalloonSize = data.ulMemoryBalloonSize;
7196
7197 // IO settings
7198 mHWData->mIoCacheEnabled = data.ioSettings.fIoCacheEnabled;
7199 mHWData->mIoCacheSize = data.ioSettings.ulIoCacheSize;
7200
7201#ifdef VBOX_WITH_GUEST_PROPS
7202 /* Guest properties (optional) */
7203 for (settings::GuestPropertiesList::const_iterator it = data.llGuestProperties.begin();
7204 it != data.llGuestProperties.end();
7205 ++it)
7206 {
7207 const settings::GuestProperty &prop = *it;
7208 uint32_t fFlags = guestProp::NILFLAG;
7209 guestProp::validateFlags(prop.strFlags.c_str(), &fFlags);
7210 HWData::GuestProperty property = { prop.strName, prop.strValue, prop.timestamp, fFlags };
7211 mHWData->mGuestProperties.push_back(property);
7212 }
7213
7214 mHWData->mGuestPropertyNotificationPatterns = data.strNotificationPatterns;
7215#endif /* VBOX_WITH_GUEST_PROPS defined */
7216 }
7217 catch(std::bad_alloc &)
7218 {
7219 return E_OUTOFMEMORY;
7220 }
7221
7222 AssertComRC(rc);
7223 return rc;
7224}
7225
7226/**
7227 * Called from loadMachineDataFromSettings() for the storage controller data, including media.
7228 *
7229 * @param data
7230 * @param puuidRegistry media registry ID to set media to or NULL; see Machine::loadMachineDataFromSettings()
7231 * @param puuidSnapshot
7232 * @return
7233 */
7234HRESULT Machine::loadStorageControllers(const settings::Storage &data,
7235 const Guid *puuidRegistry,
7236 const Guid *puuidSnapshot)
7237{
7238 AssertReturn(!isSessionMachine(), E_FAIL);
7239
7240 HRESULT rc = S_OK;
7241
7242 for (settings::StorageControllersList::const_iterator it = data.llStorageControllers.begin();
7243 it != data.llStorageControllers.end();
7244 ++it)
7245 {
7246 const settings::StorageController &ctlData = *it;
7247
7248 ComObjPtr<StorageController> pCtl;
7249 /* Try to find one with the name first. */
7250 rc = getStorageControllerByName(ctlData.strName, pCtl, false /* aSetError */);
7251 if (SUCCEEDED(rc))
7252 return setError(VBOX_E_OBJECT_IN_USE,
7253 tr("Storage controller named '%s' already exists"),
7254 ctlData.strName.c_str());
7255
7256 pCtl.createObject();
7257 rc = pCtl->init(this,
7258 ctlData.strName,
7259 ctlData.storageBus,
7260 ctlData.ulInstance);
7261 if (FAILED(rc)) return rc;
7262
7263 mStorageControllers->push_back(pCtl);
7264
7265 rc = pCtl->COMSETTER(ControllerType)(ctlData.controllerType);
7266 if (FAILED(rc)) return rc;
7267
7268 rc = pCtl->COMSETTER(PortCount)(ctlData.ulPortCount);
7269 if (FAILED(rc)) return rc;
7270
7271 rc = pCtl->COMSETTER(UseHostIOCache)(ctlData.fUseHostIOCache);
7272 if (FAILED(rc)) return rc;
7273
7274 /* Set IDE emulation settings (only for AHCI controller). */
7275 if (ctlData.controllerType == StorageControllerType_IntelAhci)
7276 {
7277 if ( (FAILED(rc = pCtl->SetIDEEmulationPort(0, ctlData.lIDE0MasterEmulationPort)))
7278 || (FAILED(rc = pCtl->SetIDEEmulationPort(1, ctlData.lIDE0SlaveEmulationPort)))
7279 || (FAILED(rc = pCtl->SetIDEEmulationPort(2, ctlData.lIDE1MasterEmulationPort)))
7280 || (FAILED(rc = pCtl->SetIDEEmulationPort(3, ctlData.lIDE1SlaveEmulationPort)))
7281 )
7282 return rc;
7283 }
7284
7285 /* Load the attached devices now. */
7286 rc = loadStorageDevices(pCtl,
7287 ctlData,
7288 puuidRegistry,
7289 puuidSnapshot);
7290 if (FAILED(rc)) return rc;
7291 }
7292
7293 return S_OK;
7294}
7295
7296/**
7297 * Called from loadStorageControllers for a controller's devices.
7298 *
7299 * @param aStorageController
7300 * @param data
7301 * @param puuidRegistry media registry ID to set media to or NULL; see Machine::loadMachineDataFromSettings()
7302 * @param aSnapshotId pointer to the snapshot ID if this is a snapshot machine
7303 * @return
7304 */
7305HRESULT Machine::loadStorageDevices(StorageController *aStorageController,
7306 const settings::StorageController &data,
7307 const Guid *puuidRegistry,
7308 const Guid *puuidSnapshot)
7309{
7310 HRESULT rc = S_OK;
7311
7312 /* paranoia: detect duplicate attachments */
7313 for (settings::AttachedDevicesList::const_iterator it = data.llAttachedDevices.begin();
7314 it != data.llAttachedDevices.end();
7315 ++it)
7316 {
7317 const settings::AttachedDevice &ad = *it;
7318
7319 for (settings::AttachedDevicesList::const_iterator it2 = it;
7320 it2 != data.llAttachedDevices.end();
7321 ++it2)
7322 {
7323 if (it == it2)
7324 continue;
7325
7326 const settings::AttachedDevice &ad2 = *it2;
7327
7328 if ( ad.lPort == ad2.lPort
7329 && ad.lDevice == ad2.lDevice)
7330 {
7331 return setError(E_FAIL,
7332 tr("Duplicate attachments for storage controller '%s', port %d, device %d of the virtual machine '%s'"),
7333 aStorageController->getName().c_str(),
7334 ad.lPort,
7335 ad.lDevice,
7336 mUserData->s.strName.c_str());
7337 }
7338 }
7339 }
7340
7341 for (settings::AttachedDevicesList::const_iterator it = data.llAttachedDevices.begin();
7342 it != data.llAttachedDevices.end();
7343 ++it)
7344 {
7345 const settings::AttachedDevice &dev = *it;
7346 ComObjPtr<Medium> medium;
7347
7348 switch (dev.deviceType)
7349 {
7350 case DeviceType_Floppy:
7351 case DeviceType_DVD:
7352 rc = mParent->findRemoveableMedium(dev.deviceType, dev.uuid, false /* fRefresh */, medium);
7353 if (FAILED(rc))
7354 return rc;
7355 break;
7356
7357 case DeviceType_HardDisk:
7358 {
7359 /* find a hard disk by UUID */
7360 rc = mParent->findHardDisk(&dev.uuid, Utf8Str::Empty, true /* aDoSetError */, &medium);
7361 if (FAILED(rc))
7362 {
7363 if (isSnapshotMachine())
7364 {
7365 // wrap another error message around the "cannot find hard disk" set by findHardDisk
7366 // so the user knows that the bad disk is in a snapshot somewhere
7367 com::ErrorInfo info;
7368 return setError(E_FAIL,
7369 tr("A differencing image of snapshot {%RTuuid} could not be found. %ls"),
7370 puuidSnapshot->raw(),
7371 info.getText().raw());
7372 }
7373 else
7374 return rc;
7375 }
7376
7377 AutoWriteLock hdLock(medium COMMA_LOCKVAL_SRC_POS);
7378
7379 if (medium->getType() == MediumType_Immutable)
7380 {
7381 if (isSnapshotMachine())
7382 return setError(E_FAIL,
7383 tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
7384 "of the virtual machine '%s' ('%s')"),
7385 medium->getLocationFull().c_str(),
7386 dev.uuid.raw(),
7387 puuidSnapshot->raw(),
7388 mUserData->s.strName.c_str(),
7389 mData->m_strConfigFileFull.c_str());
7390
7391 return setError(E_FAIL,
7392 tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
7393 medium->getLocationFull().c_str(),
7394 dev.uuid.raw(),
7395 mUserData->s.strName.c_str(),
7396 mData->m_strConfigFileFull.c_str());
7397 }
7398
7399 if ( !isSnapshotMachine()
7400 && medium->getChildren().size() != 0
7401 )
7402 return setError(E_FAIL,
7403 tr("Hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s') "
7404 "because it has %d differencing child hard disks"),
7405 medium->getLocationFull().c_str(),
7406 dev.uuid.raw(),
7407 mUserData->s.strName.c_str(),
7408 mData->m_strConfigFileFull.c_str(),
7409 medium->getChildren().size());
7410
7411 if (findAttachment(mMediaData->mAttachments,
7412 medium))
7413 return setError(E_FAIL,
7414 tr("Hard disk '%s' with UUID {%RTuuid} is already attached to the virtual machine '%s' ('%s')"),
7415 medium->getLocationFull().c_str(),
7416 dev.uuid.raw(),
7417 mUserData->s.strName.c_str(),
7418 mData->m_strConfigFileFull.c_str());
7419
7420 break;
7421 }
7422
7423 default:
7424 return setError(E_FAIL,
7425 tr("Device '%s' with unknown type is attached to the virtual machine '%s' ('%s')"),
7426 medium->getLocationFull().c_str(),
7427 mUserData->s.strName.c_str(),
7428 mData->m_strConfigFileFull.c_str());
7429 }
7430
7431 if (FAILED(rc))
7432 break;
7433
7434 const Bstr controllerName = aStorageController->getName();
7435 ComObjPtr<MediumAttachment> pAttachment;
7436 pAttachment.createObject();
7437 rc = pAttachment->init(this,
7438 medium,
7439 controllerName,
7440 dev.lPort,
7441 dev.lDevice,
7442 dev.deviceType,
7443 dev.fPassThrough,
7444 dev.ulBandwidthLimit);
7445 if (FAILED(rc)) break;
7446
7447 /* associate the medium with this machine and snapshot */
7448 if (!medium.isNull())
7449 {
7450 if (isSnapshotMachine())
7451 rc = medium->addBackReference(mData->mUuid, *puuidSnapshot);
7452 else
7453 rc = medium->addBackReference(mData->mUuid);
7454
7455 if (puuidRegistry)
7456 // caller wants registry ID to be set on all attached media (OVF import case)
7457 medium->setRegistryIdIfFirst(*puuidRegistry);
7458 }
7459
7460 if (FAILED(rc))
7461 break;
7462
7463 /* back up mMediaData to let registeredInit() properly rollback on failure
7464 * (= limited accessibility) */
7465 setModified(IsModified_Storage);
7466 mMediaData.backup();
7467 mMediaData->mAttachments.push_back(pAttachment);
7468 }
7469
7470 return rc;
7471}
7472
7473/**
7474 * Returns the snapshot with the given UUID or fails of no such snapshot exists.
7475 *
7476 * @param aId snapshot UUID to find (empty UUID refers the first snapshot)
7477 * @param aSnapshot where to return the found snapshot
7478 * @param aSetError true to set extended error info on failure
7479 */
7480HRESULT Machine::findSnapshot(const Guid &aId,
7481 ComObjPtr<Snapshot> &aSnapshot,
7482 bool aSetError /* = false */)
7483{
7484 AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
7485
7486 if (!mData->mFirstSnapshot)
7487 {
7488 if (aSetError)
7489 return setError(E_FAIL,
7490 tr("This machine does not have any snapshots"));
7491 return E_FAIL;
7492 }
7493
7494 if (aId.isEmpty())
7495 aSnapshot = mData->mFirstSnapshot;
7496 else
7497 aSnapshot = mData->mFirstSnapshot->findChildOrSelf(aId.ref());
7498
7499 if (!aSnapshot)
7500 {
7501 if (aSetError)
7502 return setError(E_FAIL,
7503 tr("Could not find a snapshot with UUID {%s}"),
7504 aId.toString().c_str());
7505 return E_FAIL;
7506 }
7507
7508 return S_OK;
7509}
7510
7511/**
7512 * Returns the snapshot with the given name or fails of no such snapshot.
7513 *
7514 * @param aName snapshot name to find
7515 * @param aSnapshot where to return the found snapshot
7516 * @param aSetError true to set extended error info on failure
7517 */
7518HRESULT Machine::findSnapshot(IN_BSTR aName,
7519 ComObjPtr<Snapshot> &aSnapshot,
7520 bool aSetError /* = false */)
7521{
7522 AssertReturn(aName, E_INVALIDARG);
7523
7524 AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
7525
7526 if (!mData->mFirstSnapshot)
7527 {
7528 if (aSetError)
7529 return setError(VBOX_E_OBJECT_NOT_FOUND,
7530 tr("This machine does not have any snapshots"));
7531 return VBOX_E_OBJECT_NOT_FOUND;
7532 }
7533
7534 aSnapshot = mData->mFirstSnapshot->findChildOrSelf(aName);
7535
7536 if (!aSnapshot)
7537 {
7538 if (aSetError)
7539 return setError(VBOX_E_OBJECT_NOT_FOUND,
7540 tr("Could not find a snapshot named '%ls'"), aName);
7541 return VBOX_E_OBJECT_NOT_FOUND;
7542 }
7543
7544 return S_OK;
7545}
7546
7547/**
7548 * Returns a storage controller object with the given name.
7549 *
7550 * @param aName storage controller name to find
7551 * @param aStorageController where to return the found storage controller
7552 * @param aSetError true to set extended error info on failure
7553 */
7554HRESULT Machine::getStorageControllerByName(const Utf8Str &aName,
7555 ComObjPtr<StorageController> &aStorageController,
7556 bool aSetError /* = false */)
7557{
7558 AssertReturn(!aName.isEmpty(), E_INVALIDARG);
7559
7560 for (StorageControllerList::const_iterator it = mStorageControllers->begin();
7561 it != mStorageControllers->end();
7562 ++it)
7563 {
7564 if ((*it)->getName() == aName)
7565 {
7566 aStorageController = (*it);
7567 return S_OK;
7568 }
7569 }
7570
7571 if (aSetError)
7572 return setError(VBOX_E_OBJECT_NOT_FOUND,
7573 tr("Could not find a storage controller named '%s'"),
7574 aName.c_str());
7575 return VBOX_E_OBJECT_NOT_FOUND;
7576}
7577
7578HRESULT Machine::getMediumAttachmentsOfController(CBSTR aName,
7579 MediaData::AttachmentList &atts)
7580{
7581 AutoCaller autoCaller(this);
7582 if (FAILED(autoCaller.rc())) return autoCaller.rc();
7583
7584 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
7585
7586 for (MediaData::AttachmentList::iterator it = mMediaData->mAttachments.begin();
7587 it != mMediaData->mAttachments.end();
7588 ++it)
7589 {
7590 const ComObjPtr<MediumAttachment> &pAtt = *it;
7591
7592 // should never happen, but deal with NULL pointers in the list.
7593 AssertStmt(!pAtt.isNull(), continue);
7594
7595 // getControllerName() needs caller+read lock
7596 AutoCaller autoAttCaller(pAtt);
7597 if (FAILED(autoAttCaller.rc()))
7598 {
7599 atts.clear();
7600 return autoAttCaller.rc();
7601 }
7602 AutoReadLock attLock(pAtt COMMA_LOCKVAL_SRC_POS);
7603
7604 if (pAtt->getControllerName() == aName)
7605 atts.push_back(pAtt);
7606 }
7607
7608 return S_OK;
7609}
7610
7611/**
7612 * Helper for #saveSettings. Cares about renaming the settings directory and
7613 * file if the machine name was changed and about creating a new settings file
7614 * if this is a new machine.
7615 *
7616 * @note Must be never called directly but only from #saveSettings().
7617 */
7618HRESULT Machine::prepareSaveSettings(bool *pfNeedsGlobalSaveSettings)
7619{
7620 AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
7621
7622 HRESULT rc = S_OK;
7623
7624 bool fSettingsFileIsNew = !mData->pMachineConfigFile->fileExists();
7625
7626 /* attempt to rename the settings file if machine name is changed */
7627 if ( mUserData->s.fNameSync
7628 && mUserData.isBackedUp()
7629 && mUserData.backedUpData()->s.strName != mUserData->s.strName
7630 )
7631 {
7632 bool dirRenamed = false;
7633 bool fileRenamed = false;
7634
7635 Utf8Str configFile, newConfigFile;
7636 Utf8Str configDir, newConfigDir;
7637
7638 do
7639 {
7640 int vrc = VINF_SUCCESS;
7641
7642 Utf8Str name = mUserData.backedUpData()->s.strName;
7643 Utf8Str newName = mUserData->s.strName;
7644
7645 configFile = mData->m_strConfigFileFull;
7646
7647 /* first, rename the directory if it matches the machine name */
7648 configDir = configFile;
7649 configDir.stripFilename();
7650 newConfigDir = configDir;
7651 if (!strcmp(RTPathFilename(configDir.c_str()), name.c_str()))
7652 {
7653 newConfigDir.stripFilename();
7654 newConfigDir.append(RTPATH_DELIMITER);
7655 newConfigDir.append(newName);
7656 /* new dir and old dir cannot be equal here because of 'if'
7657 * above and because name != newName */
7658 Assert(configDir != newConfigDir);
7659 if (!fSettingsFileIsNew)
7660 {
7661 /* perform real rename only if the machine is not new */
7662 vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
7663 if (RT_FAILURE(vrc))
7664 {
7665 rc = setError(E_FAIL,
7666 tr("Could not rename the directory '%s' to '%s' to save the settings file (%Rrc)"),
7667 configDir.c_str(),
7668 newConfigDir.c_str(),
7669 vrc);
7670 break;
7671 }
7672 dirRenamed = true;
7673 }
7674 }
7675
7676 newConfigFile = Utf8StrFmt("%s%c%s.vbox",
7677 newConfigDir.c_str(), RTPATH_DELIMITER, newName.c_str());
7678
7679 /* then try to rename the settings file itself */
7680 if (newConfigFile != configFile)
7681 {
7682 /* get the path to old settings file in renamed directory */
7683 configFile = Utf8StrFmt("%s%c%s",
7684 newConfigDir.c_str(),
7685 RTPATH_DELIMITER,
7686 RTPathFilename(configFile.c_str()));
7687 if (!fSettingsFileIsNew)
7688 {
7689 /* perform real rename only if the machine is not new */
7690 vrc = RTFileRename(configFile.c_str(), newConfigFile.c_str(), 0);
7691 if (RT_FAILURE(vrc))
7692 {
7693 rc = setError(E_FAIL,
7694 tr("Could not rename the settings file '%s' to '%s' (%Rrc)"),
7695 configFile.c_str(),
7696 newConfigFile.c_str(),
7697 vrc);
7698 break;
7699 }
7700 fileRenamed = true;
7701 }
7702 }
7703
7704 /* update m_strConfigFileFull amd mConfigFile */
7705 mData->m_strConfigFileFull = newConfigFile;
7706 // compute the relative path too
7707 mParent->copyPathRelativeToConfig(newConfigFile, mData->m_strConfigFile);
7708
7709 // store the old and new so that VirtualBox::saveSettings() can update
7710 // the media registry
7711 if ( mData->mRegistered
7712 && configDir != newConfigDir)
7713 {
7714 mParent->rememberMachineNameChangeForMedia(configDir, newConfigDir);
7715
7716 if (pfNeedsGlobalSaveSettings)
7717 *pfNeedsGlobalSaveSettings = true;
7718 }
7719
7720 /* update the snapshot folder */
7721 if (RTPathStartsWith(mUserData->m_strSnapshotFolderFull.c_str(),
7722 configDir.c_str()))
7723 {
7724 mUserData->m_strSnapshotFolderFull = Utf8StrFmt("%s%s",
7725 newConfigDir.c_str(),
7726 mUserData->m_strSnapshotFolderFull.c_str() + configDir.length());
7727 copyPathRelativeToMachine(mUserData->m_strSnapshotFolderFull,
7728 mUserData->s.strSnapshotFolder);
7729 }
7730
7731 /* update the saved state file path */
7732 Utf8Str path = mSSData->mStateFilePath;
7733 if (RTPathStartsWith(path.c_str(), configDir.c_str()))
7734 mSSData->mStateFilePath = Utf8StrFmt("%s%s",
7735 newConfigDir.c_str(),
7736 path.c_str() + configDir.length());
7737
7738 /* Update saved state file paths of all online snapshots.
7739 * Note that saveSettings() will recognize name change
7740 * and will save all snapshots in this case. */
7741 if (mData->mFirstSnapshot)
7742 mData->mFirstSnapshot->updateSavedStatePaths(configDir.c_str(),
7743 newConfigDir.c_str());
7744 }
7745 while (0);
7746
7747 if (FAILED(rc))
7748 {
7749 /* silently try to rename everything back */
7750 if (fileRenamed)
7751 RTFileRename(newConfigFile.c_str(), configFile.c_str(), 0);
7752 if (dirRenamed)
7753 RTPathRename(newConfigDir.c_str(), configDir.c_str(), 0);
7754 }
7755
7756 if (FAILED(rc)) return rc;
7757 }
7758
7759 if (fSettingsFileIsNew)
7760 {
7761 /* create a virgin config file */
7762 int vrc = VINF_SUCCESS;
7763
7764 /* ensure the settings directory exists */
7765 Utf8Str path(mData->m_strConfigFileFull);
7766 path.stripFilename();
7767 if (!RTDirExists(path.c_str()))
7768 {
7769 vrc = RTDirCreateFullPath(path.c_str(), 0777);
7770 if (RT_FAILURE(vrc))
7771 {
7772 return setError(E_FAIL,
7773 tr("Could not create a directory '%s' to save the settings file (%Rrc)"),
7774 path.c_str(),
7775 vrc);
7776 }
7777 }
7778
7779 /* Note: open flags must correlate with RTFileOpen() in lockConfig() */
7780 path = Utf8Str(mData->m_strConfigFileFull);
7781 RTFILE f = NIL_RTFILE;
7782 vrc = RTFileOpen(&f, path.c_str(),
7783 RTFILE_O_READWRITE | RTFILE_O_CREATE | RTFILE_O_DENY_WRITE);
7784 if (RT_FAILURE(vrc))
7785 return setError(E_FAIL,
7786 tr("Could not create the settings file '%s' (%Rrc)"),
7787 path.c_str(),
7788 vrc);
7789 RTFileClose(f);
7790 }
7791
7792 return rc;
7793}
7794
7795/**
7796 * Saves and commits machine data, user data and hardware data.
7797 *
7798 * Note that on failure, the data remains uncommitted.
7799 *
7800 * @a aFlags may combine the following flags:
7801 *
7802 * - SaveS_ResetCurStateModified: Resets mData->mCurrentStateModified to FALSE.
7803 * Used when saving settings after an operation that makes them 100%
7804 * correspond to the settings from the current snapshot.
7805 * - SaveS_InformCallbacksAnyway: Callbacks will be informed even if
7806 * #isReallyModified() returns false. This is necessary for cases when we
7807 * change machine data directly, not through the backup()/commit() mechanism.
7808 * - SaveS_Force: settings will be saved without doing a deep compare of the
7809 * settings structures. This is used when this is called because snapshots
7810 * have changed to avoid the overhead of the deep compare.
7811 *
7812 * @note Must be called from under this object's write lock. Locks children for
7813 * writing.
7814 *
7815 * @param pfNeedsGlobalSaveSettings Optional pointer to a bool that must have been
7816 * initialized to false and that will be set to true by this function if
7817 * the caller must invoke VirtualBox::saveSettings() because the global
7818 * settings have changed. This will happen if a machine rename has been
7819 * saved and the global machine and media registries will therefore need
7820 * updating.
7821 */
7822HRESULT Machine::saveSettings(bool *pfNeedsGlobalSaveSettings,
7823 int aFlags /*= 0*/)
7824{
7825 LogFlowThisFuncEnter();
7826
7827 AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
7828
7829 /* make sure child objects are unable to modify the settings while we are
7830 * saving them */
7831 ensureNoStateDependencies();
7832
7833 AssertReturn(!isSnapshotMachine(),
7834 E_FAIL);
7835
7836 HRESULT rc = S_OK;
7837 bool fNeedsWrite = false;
7838
7839 /* First, prepare to save settings. It will care about renaming the
7840 * settings directory and file if the machine name was changed and about
7841 * creating a new settings file if this is a new machine. */
7842 rc = prepareSaveSettings(pfNeedsGlobalSaveSettings);
7843 if (FAILED(rc)) return rc;
7844
7845 // keep a pointer to the current settings structures
7846 settings::MachineConfigFile *pOldConfig = mData->pMachineConfigFile;
7847 settings::MachineConfigFile *pNewConfig = NULL;
7848
7849 try
7850 {
7851 // make a fresh one to have everyone write stuff into
7852 pNewConfig = new settings::MachineConfigFile(NULL);
7853 pNewConfig->copyBaseFrom(*mData->pMachineConfigFile);
7854
7855 // now go and copy all the settings data from COM to the settings structures
7856 // (this calles saveSettings() on all the COM objects in the machine)
7857 copyMachineDataToSettings(*pNewConfig);
7858
7859 if (aFlags & SaveS_ResetCurStateModified)
7860 {
7861 // this gets set by takeSnapshot() (if offline snapshot) and restoreSnapshot()
7862 mData->mCurrentStateModified = FALSE;
7863 fNeedsWrite = true; // always, no need to compare
7864 }
7865 else if (aFlags & SaveS_Force)
7866 {
7867 fNeedsWrite = true; // always, no need to compare
7868 }
7869 else
7870 {
7871 if (!mData->mCurrentStateModified)
7872 {
7873 // do a deep compare of the settings that we just saved with the settings
7874 // previously stored in the config file; this invokes MachineConfigFile::operator==
7875 // which does a deep compare of all the settings, which is expensive but less expensive
7876 // than writing out XML in vain
7877 bool fAnySettingsChanged = (*pNewConfig == *pOldConfig);
7878
7879 // could still be modified if any settings changed
7880 mData->mCurrentStateModified = fAnySettingsChanged;
7881
7882 fNeedsWrite = fAnySettingsChanged;
7883 }
7884 else
7885 fNeedsWrite = true;
7886 }
7887
7888 pNewConfig->fCurrentStateModified = !!mData->mCurrentStateModified;
7889
7890 if (fNeedsWrite)
7891 // now spit it all out!
7892 pNewConfig->write(mData->m_strConfigFileFull);
7893
7894 mData->pMachineConfigFile = pNewConfig;
7895 delete pOldConfig;
7896 commit();
7897
7898 // after saving settings, we are no longer different from the XML on disk
7899 mData->flModifications = 0;
7900 }
7901 catch (HRESULT err)
7902 {
7903 // we assume that error info is set by the thrower
7904 rc = err;
7905
7906 // restore old config
7907 delete pNewConfig;
7908 mData->pMachineConfigFile = pOldConfig;
7909 }
7910 catch (...)
7911 {
7912 rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
7913 }
7914
7915 if (fNeedsWrite || (aFlags & SaveS_InformCallbacksAnyway))
7916 {
7917 /* Fire the data change event, even on failure (since we've already
7918 * committed all data). This is done only for SessionMachines because
7919 * mutable Machine instances are always not registered (i.e. private
7920 * to the client process that creates them) and thus don't need to
7921 * inform callbacks. */
7922 if (isSessionMachine())
7923 mParent->onMachineDataChange(mData->mUuid);
7924 }
7925
7926 LogFlowThisFunc(("rc=%08X\n", rc));
7927 LogFlowThisFuncLeave();
7928 return rc;
7929}
7930
7931/**
7932 * Implementation for saving the machine settings into the given
7933 * settings::MachineConfigFile instance. This copies machine extradata
7934 * from the previous machine config file in the instance data, if any.
7935 *
7936 * This gets called from two locations:
7937 *
7938 * -- Machine::saveSettings(), during the regular XML writing;
7939 *
7940 * -- Appliance::buildXMLForOneVirtualSystem(), when a machine gets
7941 * exported to OVF and we write the VirtualBox proprietary XML
7942 * into a <vbox:Machine> tag.
7943 *
7944 * This routine fills all the fields in there, including snapshots, *except*
7945 * for the following:
7946 *
7947 * -- fCurrentStateModified. There is some special logic associated with that.
7948 *
7949 * The caller can then call MachineConfigFile::write() or do something else
7950 * with it.
7951 *
7952 * Caller must hold the machine lock!
7953 *
7954 * This throws XML errors and HRESULT, so the caller must have a catch block!
7955 */
7956void Machine::copyMachineDataToSettings(settings::MachineConfigFile &config)
7957{
7958 // deep copy extradata
7959 config.mapExtraDataItems = mData->pMachineConfigFile->mapExtraDataItems;
7960
7961 config.uuid = mData->mUuid;
7962
7963 // copy name, description, OS type, teleport, UTC etc.
7964 config.machineUserData = mUserData->s;
7965
7966 if ( mData->mMachineState == MachineState_Saved
7967 || mData->mMachineState == MachineState_Restoring
7968 // when deleting a snapshot we may or may not have a saved state in the current state,
7969 // so let's not assert here please
7970 || ( ( mData->mMachineState == MachineState_DeletingSnapshot
7971 || mData->mMachineState == MachineState_DeletingSnapshotOnline
7972 || mData->mMachineState == MachineState_DeletingSnapshotPaused)
7973 && (!mSSData->mStateFilePath.isEmpty())
7974 )
7975 )
7976 {
7977 Assert(!mSSData->mStateFilePath.isEmpty());
7978 /* try to make the file name relative to the settings file dir */
7979 copyPathRelativeToMachine(mSSData->mStateFilePath, config.strStateFile);
7980 }
7981 else
7982 {
7983 Assert(mSSData->mStateFilePath.isEmpty());
7984 config.strStateFile.setNull();
7985 }
7986
7987 if (mData->mCurrentSnapshot)
7988 config.uuidCurrentSnapshot = mData->mCurrentSnapshot->getId();
7989 else
7990 config.uuidCurrentSnapshot.clear();
7991
7992 config.timeLastStateChange = mData->mLastStateChange;
7993 config.fAborted = (mData->mMachineState == MachineState_Aborted);
7994 /// @todo Live Migration: config.fTeleported = (mData->mMachineState == MachineState_Teleported);
7995
7996 HRESULT rc = saveHardware(config.hardwareMachine);
7997 if (FAILED(rc)) throw rc;
7998
7999 rc = saveStorageControllers(config.storageMachine);
8000 if (FAILED(rc)) throw rc;
8001
8002 // save machine's media registry if this is VirtualBox 4.0 or later
8003 if (config.canHaveOwnMediaRegistry())
8004 mParent->saveMediaRegistry(config.mediaRegistry,
8005 getId()); // only media with registry ID == machine UUID
8006 // this throws HRESULT
8007
8008 // save snapshots
8009 rc = saveAllSnapshots(config);
8010 if (FAILED(rc)) throw rc;
8011}
8012
8013/**
8014 * Saves all snapshots of the machine into the given machine config file. Called
8015 * from Machine::buildMachineXML() and SessionMachine::deleteSnapshotHandler().
8016 * @param config
8017 * @return
8018 */
8019HRESULT Machine::saveAllSnapshots(settings::MachineConfigFile &config)
8020{
8021 AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
8022
8023 HRESULT rc = S_OK;
8024
8025 try
8026 {
8027 config.llFirstSnapshot.clear();
8028
8029 if (mData->mFirstSnapshot)
8030 {
8031 settings::Snapshot snapNew;
8032 config.llFirstSnapshot.push_back(snapNew);
8033
8034 // get reference to the fresh copy of the snapshot on the list and
8035 // work on that copy directly to avoid excessive copying later
8036 settings::Snapshot &snap = config.llFirstSnapshot.front();
8037
8038 rc = mData->mFirstSnapshot->saveSnapshot(snap, false /*aAttrsOnly*/);
8039 if (FAILED(rc)) throw rc;
8040 }
8041
8042// if (mType == IsSessionMachine)
8043// mParent->onMachineDataChange(mData->mUuid); @todo is this necessary?
8044
8045 }
8046 catch (HRESULT err)
8047 {
8048 /* we assume that error info is set by the thrower */
8049 rc = err;
8050 }
8051 catch (...)
8052 {
8053 rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
8054 }
8055
8056 return rc;
8057}
8058
8059/**
8060 * Saves the VM hardware configuration. It is assumed that the
8061 * given node is empty.
8062 *
8063 * @param aNode <Hardware> node to save the VM hardware confguration to.
8064 */
8065HRESULT Machine::saveHardware(settings::Hardware &data)
8066{
8067 HRESULT rc = S_OK;
8068
8069 try
8070 {
8071 /* The hardware version attribute (optional).
8072 Automatically upgrade from 1 to 2 when there is no saved state. (ugly!) */
8073 if ( mHWData->mHWVersion == "1"
8074 && mSSData->mStateFilePath.isEmpty()
8075 )
8076 mHWData->mHWVersion = "2"; /** @todo Is this safe, to update mHWVersion here? If not some other point needs to be found where this can be done. */
8077
8078 data.strVersion = mHWData->mHWVersion;
8079 data.uuid = mHWData->mHardwareUUID;
8080
8081 // CPU
8082 data.fHardwareVirt = !!mHWData->mHWVirtExEnabled;
8083 data.fHardwareVirtExclusive = !!mHWData->mHWVirtExExclusive;
8084 data.fNestedPaging = !!mHWData->mHWVirtExNestedPagingEnabled;
8085 data.fLargePages = !!mHWData->mHWVirtExLargePagesEnabled;
8086 data.fVPID = !!mHWData->mHWVirtExVPIDEnabled;
8087 data.fHardwareVirtForce = !!mHWData->mHWVirtExForceEnabled;
8088 data.fPAE = !!mHWData->mPAEEnabled;
8089 data.fSyntheticCpu = !!mHWData->mSyntheticCpu;
8090
8091 /* Standard and Extended CPUID leafs. */
8092 data.llCpuIdLeafs.clear();
8093 for (unsigned idx = 0; idx < RT_ELEMENTS(mHWData->mCpuIdStdLeafs); idx++)
8094 {
8095 if (mHWData->mCpuIdStdLeafs[idx].ulId != UINT32_MAX)
8096 data.llCpuIdLeafs.push_back(mHWData->mCpuIdStdLeafs[idx]);
8097 }
8098 for (unsigned idx = 0; idx < RT_ELEMENTS(mHWData->mCpuIdExtLeafs); idx++)
8099 {
8100 if (mHWData->mCpuIdExtLeafs[idx].ulId != UINT32_MAX)
8101 data.llCpuIdLeafs.push_back(mHWData->mCpuIdExtLeafs[idx]);
8102 }
8103
8104 data.cCPUs = mHWData->mCPUCount;
8105 data.fCpuHotPlug = !!mHWData->mCPUHotPlugEnabled;
8106 data.ulCpuExecutionCap = mHWData->mCpuExecutionCap;
8107
8108 data.llCpus.clear();
8109 if (data.fCpuHotPlug)
8110 {
8111 for (unsigned idx = 0; idx < data.cCPUs; idx++)
8112 {
8113 if (mHWData->mCPUAttached[idx])
8114 {
8115 settings::Cpu cpu;
8116 cpu.ulId = idx;
8117 data.llCpus.push_back(cpu);
8118 }
8119 }
8120 }
8121
8122 // memory
8123 data.ulMemorySizeMB = mHWData->mMemorySize;
8124 data.fPageFusionEnabled = !!mHWData->mPageFusionEnabled;
8125
8126 // firmware
8127 data.firmwareType = mHWData->mFirmwareType;
8128
8129 // HID
8130 data.pointingHidType = mHWData->mPointingHidType;
8131 data.keyboardHidType = mHWData->mKeyboardHidType;
8132
8133 // chipset
8134 data.chipsetType = mHWData->mChipsetType;
8135
8136 // HPET
8137 data.fHpetEnabled = !!mHWData->mHpetEnabled;
8138
8139 // boot order
8140 data.mapBootOrder.clear();
8141 for (size_t i = 0;
8142 i < RT_ELEMENTS(mHWData->mBootOrder);
8143 ++i)
8144 data.mapBootOrder[i] = mHWData->mBootOrder[i];
8145
8146 // display
8147 data.ulVRAMSizeMB = mHWData->mVRAMSize;
8148 data.cMonitors = mHWData->mMonitorCount;
8149 data.fAccelerate3D = !!mHWData->mAccelerate3DEnabled;
8150 data.fAccelerate2DVideo = !!mHWData->mAccelerate2DVideoEnabled;
8151
8152#ifdef VBOX_WITH_VRDP
8153 /* VRDP settings (optional) */
8154 rc = mVRDPServer->saveSettings(data.vrdpSettings);
8155 if (FAILED(rc)) throw rc;
8156#endif
8157
8158 /* BIOS (required) */
8159 rc = mBIOSSettings->saveSettings(data.biosSettings);
8160 if (FAILED(rc)) throw rc;
8161
8162 /* USB Controller (required) */
8163 rc = mUSBController->saveSettings(data.usbController);
8164 if (FAILED(rc)) throw rc;
8165
8166 /* Network adapters (required) */
8167 data.llNetworkAdapters.clear();
8168 for (ULONG slot = 0;
8169 slot < RT_ELEMENTS(mNetworkAdapters);
8170 ++slot)
8171 {
8172 settings::NetworkAdapter nic;
8173 nic.ulSlot = slot;
8174 rc = mNetworkAdapters[slot]->saveSettings(nic);
8175 if (FAILED(rc)) throw rc;
8176
8177 data.llNetworkAdapters.push_back(nic);
8178 }
8179
8180 /* Serial ports */
8181 data.llSerialPorts.clear();
8182 for (ULONG slot = 0;
8183 slot < RT_ELEMENTS(mSerialPorts);
8184 ++slot)
8185 {
8186 settings::SerialPort s;
8187 s.ulSlot = slot;
8188 rc = mSerialPorts[slot]->saveSettings(s);
8189 if (FAILED(rc)) return rc;
8190
8191 data.llSerialPorts.push_back(s);
8192 }
8193
8194 /* Parallel ports */
8195 data.llParallelPorts.clear();
8196 for (ULONG slot = 0;
8197 slot < RT_ELEMENTS(mParallelPorts);
8198 ++slot)
8199 {
8200 settings::ParallelPort p;
8201 p.ulSlot = slot;
8202 rc = mParallelPorts[slot]->saveSettings(p);
8203 if (FAILED(rc)) return rc;
8204
8205 data.llParallelPorts.push_back(p);
8206 }
8207
8208 /* Audio adapter */
8209 rc = mAudioAdapter->saveSettings(data.audioAdapter);
8210 if (FAILED(rc)) return rc;
8211
8212 /* Shared folders */
8213 data.llSharedFolders.clear();
8214 for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
8215 it != mHWData->mSharedFolders.end();
8216 ++it)
8217 {
8218 ComObjPtr<SharedFolder> pFolder = *it;
8219 settings::SharedFolder sf;
8220 sf.strName = pFolder->getName();
8221 sf.strHostPath = pFolder->getHostPath();
8222 sf.fWritable = !!pFolder->isWritable();
8223 sf.fAutoMount = !!pFolder->isAutoMounted();
8224
8225 data.llSharedFolders.push_back(sf);
8226 }
8227
8228 // clipboard
8229 data.clipboardMode = mHWData->mClipboardMode;
8230
8231 /* Guest */
8232 data.ulMemoryBalloonSize = mHWData->mMemoryBalloonSize;
8233
8234 // IO settings
8235 data.ioSettings.fIoCacheEnabled = !!mHWData->mIoCacheEnabled;
8236 data.ioSettings.ulIoCacheSize = mHWData->mIoCacheSize;
8237
8238 // guest properties
8239 data.llGuestProperties.clear();
8240#ifdef VBOX_WITH_GUEST_PROPS
8241 for (HWData::GuestPropertyList::const_iterator it = mHWData->mGuestProperties.begin();
8242 it != mHWData->mGuestProperties.end();
8243 ++it)
8244 {
8245 HWData::GuestProperty property = *it;
8246
8247 /* Remove transient guest properties at shutdown unless we
8248 * are saving state */
8249 if ( ( mData->mMachineState == MachineState_PoweredOff
8250 || mData->mMachineState == MachineState_Aborted
8251 || mData->mMachineState == MachineState_Teleported)
8252 && property.mFlags & guestProp::TRANSIENT)
8253 continue;
8254 settings::GuestProperty prop;
8255 prop.strName = property.strName;
8256 prop.strValue = property.strValue;
8257 prop.timestamp = property.mTimestamp;
8258 char szFlags[guestProp::MAX_FLAGS_LEN + 1];
8259 guestProp::writeFlags(property.mFlags, szFlags);
8260 prop.strFlags = szFlags;
8261
8262 data.llGuestProperties.push_back(prop);
8263 }
8264
8265 data.strNotificationPatterns = mHWData->mGuestPropertyNotificationPatterns;
8266 /* I presume this doesn't require a backup(). */
8267 mData->mGuestPropertiesModified = FALSE;
8268#endif /* VBOX_WITH_GUEST_PROPS defined */
8269 }
8270 catch(std::bad_alloc &)
8271 {
8272 return E_OUTOFMEMORY;
8273 }
8274
8275 AssertComRC(rc);
8276 return rc;
8277}
8278
8279/**
8280 * Saves the storage controller configuration.
8281 *
8282 * @param aNode <StorageControllers> node to save the VM hardware confguration to.
8283 */
8284HRESULT Machine::saveStorageControllers(settings::Storage &data)
8285{
8286 data.llStorageControllers.clear();
8287
8288 for (StorageControllerList::const_iterator it = mStorageControllers->begin();
8289 it != mStorageControllers->end();
8290 ++it)
8291 {
8292 HRESULT rc;
8293 ComObjPtr<StorageController> pCtl = *it;
8294
8295 settings::StorageController ctl;
8296 ctl.strName = pCtl->getName();
8297 ctl.controllerType = pCtl->getControllerType();
8298 ctl.storageBus = pCtl->getStorageBus();
8299 ctl.ulInstance = pCtl->getInstance();
8300
8301 /* Save the port count. */
8302 ULONG portCount;
8303 rc = pCtl->COMGETTER(PortCount)(&portCount);
8304 ComAssertComRCRet(rc, rc);
8305 ctl.ulPortCount = portCount;
8306
8307 /* Save fUseHostIOCache */
8308 BOOL fUseHostIOCache;
8309 rc = pCtl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
8310 ComAssertComRCRet(rc, rc);
8311 ctl.fUseHostIOCache = !!fUseHostIOCache;
8312
8313 /* Save IDE emulation settings. */
8314 if (ctl.controllerType == StorageControllerType_IntelAhci)
8315 {
8316 if ( (FAILED(rc = pCtl->GetIDEEmulationPort(0, (LONG*)&ctl.lIDE0MasterEmulationPort)))
8317 || (FAILED(rc = pCtl->GetIDEEmulationPort(1, (LONG*)&ctl.lIDE0SlaveEmulationPort)))
8318 || (FAILED(rc = pCtl->GetIDEEmulationPort(2, (LONG*)&ctl.lIDE1MasterEmulationPort)))
8319 || (FAILED(rc = pCtl->GetIDEEmulationPort(3, (LONG*)&ctl.lIDE1SlaveEmulationPort)))
8320 )
8321 ComAssertComRCRet(rc, rc);
8322 }
8323
8324 /* save the devices now. */
8325 rc = saveStorageDevices(pCtl, ctl);
8326 ComAssertComRCRet(rc, rc);
8327
8328 data.llStorageControllers.push_back(ctl);
8329 }
8330
8331 return S_OK;
8332}
8333
8334/**
8335 * Saves the hard disk confguration.
8336 */
8337HRESULT Machine::saveStorageDevices(ComObjPtr<StorageController> aStorageController,
8338 settings::StorageController &data)
8339{
8340 MediaData::AttachmentList atts;
8341
8342 HRESULT rc = getMediumAttachmentsOfController(Bstr(aStorageController->getName()).raw(), atts);
8343 if (FAILED(rc)) return rc;
8344
8345 data.llAttachedDevices.clear();
8346 for (MediaData::AttachmentList::const_iterator it = atts.begin();
8347 it != atts.end();
8348 ++it)
8349 {
8350 settings::AttachedDevice dev;
8351
8352 MediumAttachment *pAttach = *it;
8353 Medium *pMedium = pAttach->getMedium();
8354
8355 dev.deviceType = pAttach->getType();
8356 dev.lPort = pAttach->getPort();
8357 dev.lDevice = pAttach->getDevice();
8358 if (pMedium)
8359 {
8360 if (pMedium->isHostDrive())
8361 dev.strHostDriveSrc = pMedium->getLocation();
8362 else
8363 dev.uuid = pMedium->getId();
8364 dev.fPassThrough = pAttach->getPassthrough();
8365 }
8366
8367 data.llAttachedDevices.push_back(dev);
8368 }
8369
8370 return S_OK;
8371}
8372
8373/**
8374 * Saves machine state settings as defined by aFlags
8375 * (SaveSTS_* values).
8376 *
8377 * @param aFlags Combination of SaveSTS_* flags.
8378 *
8379 * @note Locks objects for writing.
8380 */
8381HRESULT Machine::saveStateSettings(int aFlags)
8382{
8383 if (aFlags == 0)
8384 return S_OK;
8385
8386 AutoCaller autoCaller(this);
8387 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
8388
8389 /* This object's write lock is also necessary to serialize file access
8390 * (prevent concurrent reads and writes) */
8391 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8392
8393 HRESULT rc = S_OK;
8394
8395 Assert(mData->pMachineConfigFile);
8396
8397 try
8398 {
8399 if (aFlags & SaveSTS_CurStateModified)
8400 mData->pMachineConfigFile->fCurrentStateModified = true;
8401
8402 if (aFlags & SaveSTS_StateFilePath)
8403 {
8404 if (!mSSData->mStateFilePath.isEmpty())
8405 /* try to make the file name relative to the settings file dir */
8406 copyPathRelativeToMachine(mSSData->mStateFilePath, mData->pMachineConfigFile->strStateFile);
8407 else
8408 mData->pMachineConfigFile->strStateFile.setNull();
8409 }
8410
8411 if (aFlags & SaveSTS_StateTimeStamp)
8412 {
8413 Assert( mData->mMachineState != MachineState_Aborted
8414 || mSSData->mStateFilePath.isEmpty());
8415
8416 mData->pMachineConfigFile->timeLastStateChange = mData->mLastStateChange;
8417
8418 mData->pMachineConfigFile->fAborted = (mData->mMachineState == MachineState_Aborted);
8419//@todo live migration mData->pMachineConfigFile->fTeleported = (mData->mMachineState == MachineState_Teleported);
8420 }
8421
8422 mData->pMachineConfigFile->write(mData->m_strConfigFileFull);
8423 }
8424 catch (...)
8425 {
8426 rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
8427 }
8428
8429 return rc;
8430}
8431
8432/**
8433 * Creates differencing hard disks for all normal hard disks attached to this
8434 * machine and a new set of attachments to refer to created disks.
8435 *
8436 * Used when taking a snapshot or when deleting the current state. Gets called
8437 * from SessionMachine::BeginTakingSnapshot() and SessionMachine::restoreSnapshotHandler().
8438 *
8439 * This method assumes that mMediaData contains the original hard disk attachments
8440 * it needs to create diffs for. On success, these attachments will be replaced
8441 * with the created diffs. On failure, #deleteImplicitDiffs() is implicitly
8442 * called to delete created diffs which will also rollback mMediaData and restore
8443 * whatever was backed up before calling this method.
8444 *
8445 * Attachments with non-normal hard disks are left as is.
8446 *
8447 * If @a aOnline is @c false then the original hard disks that require implicit
8448 * diffs will be locked for reading. Otherwise it is assumed that they are
8449 * already locked for writing (when the VM was started). Note that in the latter
8450 * case it is responsibility of the caller to lock the newly created diffs for
8451 * writing if this method succeeds.
8452 *
8453 * @param aProgress Progress object to run (must contain at least as
8454 * many operations left as the number of hard disks
8455 * attached).
8456 * @param aOnline Whether the VM was online prior to this operation.
8457 * @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
8458 * by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
8459 *
8460 * @note The progress object is not marked as completed, neither on success nor
8461 * on failure. This is a responsibility of the caller.
8462 *
8463 * @note Locks this object for writing.
8464 */
8465HRESULT Machine::createImplicitDiffs(IProgress *aProgress,
8466 ULONG aWeight,
8467 bool aOnline,
8468 bool *pfNeedsSaveSettings)
8469{
8470 LogFlowThisFunc(("aOnline=%d\n", aOnline));
8471
8472 AutoCaller autoCaller(this);
8473 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
8474
8475 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8476
8477 /* must be in a protective state because we leave the lock below */
8478 AssertReturn( mData->mMachineState == MachineState_Saving
8479 || mData->mMachineState == MachineState_LiveSnapshotting
8480 || mData->mMachineState == MachineState_RestoringSnapshot
8481 || mData->mMachineState == MachineState_DeletingSnapshot
8482 , E_FAIL);
8483
8484 HRESULT rc = S_OK;
8485
8486 MediumLockListMap lockedMediaOffline;
8487 MediumLockListMap *lockedMediaMap;
8488 if (aOnline)
8489 lockedMediaMap = &mData->mSession.mLockedMedia;
8490 else
8491 lockedMediaMap = &lockedMediaOffline;
8492
8493 try
8494 {
8495 if (!aOnline)
8496 {
8497 /* lock all attached hard disks early to detect "in use"
8498 * situations before creating actual diffs */
8499 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
8500 it != mMediaData->mAttachments.end();
8501 ++it)
8502 {
8503 MediumAttachment* pAtt = *it;
8504 if (pAtt->getType() == DeviceType_HardDisk)
8505 {
8506 Medium* pMedium = pAtt->getMedium();
8507 Assert(pMedium);
8508
8509 MediumLockList *pMediumLockList(new MediumLockList());
8510 rc = pMedium->createMediumLockList(true /* fFailIfInaccessible */,
8511 false /* fMediumLockWrite */,
8512 NULL,
8513 *pMediumLockList);
8514 if (FAILED(rc))
8515 {
8516 delete pMediumLockList;
8517 throw rc;
8518 }
8519 rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
8520 if (FAILED(rc))
8521 {
8522 throw setError(rc,
8523 tr("Collecting locking information for all attached media failed"));
8524 }
8525 }
8526 }
8527
8528 /* Now lock all media. If this fails, nothing is locked. */
8529 rc = lockedMediaMap->Lock();
8530 if (FAILED(rc))
8531 {
8532 throw setError(rc,
8533 tr("Locking of attached media failed"));
8534 }
8535 }
8536
8537 /* remember the current list (note that we don't use backup() since
8538 * mMediaData may be already backed up) */
8539 MediaData::AttachmentList atts = mMediaData->mAttachments;
8540
8541 /* start from scratch */
8542 mMediaData->mAttachments.clear();
8543
8544 /* go through remembered attachments and create diffs for normal hard
8545 * disks and attach them */
8546 for (MediaData::AttachmentList::const_iterator it = atts.begin();
8547 it != atts.end();
8548 ++it)
8549 {
8550 MediumAttachment* pAtt = *it;
8551
8552 DeviceType_T devType = pAtt->getType();
8553 Medium* pMedium = pAtt->getMedium();
8554
8555 if ( devType != DeviceType_HardDisk
8556 || pMedium == NULL
8557 || pMedium->getType() != MediumType_Normal)
8558 {
8559 /* copy the attachment as is */
8560
8561 /** @todo the progress object created in Console::TakeSnaphot
8562 * only expects operations for hard disks. Later other
8563 * device types need to show up in the progress as well. */
8564 if (devType == DeviceType_HardDisk)
8565 {
8566 if (pMedium == NULL)
8567 aProgress->SetNextOperation(Bstr(tr("Skipping attachment without medium")).raw(),
8568 aWeight); // weight
8569 else
8570 aProgress->SetNextOperation(BstrFmt(tr("Skipping medium '%s'"),
8571 pMedium->getBase()->getName().c_str()).raw(),
8572 aWeight); // weight
8573 }
8574
8575 mMediaData->mAttachments.push_back(pAtt);
8576 continue;
8577 }
8578
8579 /* need a diff */
8580 aProgress->SetNextOperation(BstrFmt(tr("Creating differencing hard disk for '%s'"),
8581 pMedium->getBase()->getName().c_str()).raw(),
8582 aWeight); // weight
8583
8584 ComObjPtr<Medium> diff;
8585 diff.createObject();
8586 rc = diff->init(mParent,
8587 pMedium->getPreferredDiffFormat(),
8588 Utf8Str(mUserData->m_strSnapshotFolderFull).append(RTPATH_SLASH_STR),
8589 pMedium->getRegistryMachineId(), // store the diff in the same registry as the parent
8590 pfNeedsSaveSettings);
8591 if (FAILED(rc)) throw rc;
8592
8593 /** @todo r=bird: How is the locking and diff image cleaned up if we fail before
8594 * the push_back? Looks like we're going to leave medium with the
8595 * wrong kind of lock (general issue with if we fail anywhere at all)
8596 * and an orphaned VDI in the snapshots folder. */
8597
8598 /* update the appropriate lock list */
8599 MediumLockList *pMediumLockList;
8600 rc = lockedMediaMap->Get(pAtt, pMediumLockList);
8601 AssertComRCThrowRC(rc);
8602 if (aOnline)
8603 {
8604 rc = pMediumLockList->Update(pMedium, false);
8605 AssertComRCThrowRC(rc);
8606 }
8607
8608 /* leave the lock before the potentially lengthy operation */
8609 alock.leave();
8610 rc = pMedium->createDiffStorage(diff, MediumVariant_Standard,
8611 pMediumLockList,
8612 NULL /* aProgress */,
8613 true /* aWait */,
8614 pfNeedsSaveSettings);
8615 alock.enter();
8616 if (FAILED(rc)) throw rc;
8617
8618 rc = lockedMediaMap->Unlock();
8619 AssertComRCThrowRC(rc);
8620 rc = pMediumLockList->Append(diff, true);
8621 AssertComRCThrowRC(rc);
8622 rc = lockedMediaMap->Lock();
8623 AssertComRCThrowRC(rc);
8624
8625 rc = diff->addBackReference(mData->mUuid);
8626 AssertComRCThrowRC(rc);
8627
8628 /* add a new attachment */
8629 ComObjPtr<MediumAttachment> attachment;
8630 attachment.createObject();
8631 rc = attachment->init(this,
8632 diff,
8633 pAtt->getControllerName(),
8634 pAtt->getPort(),
8635 pAtt->getDevice(),
8636 DeviceType_HardDisk,
8637 true /* aImplicit */,
8638 0 /* No bandwidth limit */);
8639 if (FAILED(rc)) throw rc;
8640
8641 rc = lockedMediaMap->ReplaceKey(pAtt, attachment);
8642 AssertComRCThrowRC(rc);
8643 mMediaData->mAttachments.push_back(attachment);
8644 }
8645 }
8646 catch (HRESULT aRC) { rc = aRC; }
8647
8648 /* unlock all hard disks we locked */
8649 if (!aOnline)
8650 {
8651 ErrorInfoKeeper eik;
8652
8653 rc = lockedMediaMap->Clear();
8654 AssertComRC(rc);
8655 }
8656
8657 if (FAILED(rc))
8658 {
8659 MultiResult mrc = rc;
8660
8661 mrc = deleteImplicitDiffs(pfNeedsSaveSettings);
8662 }
8663
8664 return rc;
8665}
8666
8667/**
8668 * Deletes implicit differencing hard disks created either by
8669 * #createImplicitDiffs() or by #AttachMedium() and rolls back mMediaData.
8670 *
8671 * Note that to delete hard disks created by #AttachMedium() this method is
8672 * called from #fixupMedia() when the changes are rolled back.
8673 *
8674 * @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
8675 * by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
8676 *
8677 * @note Locks this object for writing.
8678 */
8679HRESULT Machine::deleteImplicitDiffs(bool *pfNeedsSaveSettings)
8680{
8681 AutoCaller autoCaller(this);
8682 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
8683
8684 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
8685 LogFlowThisFuncEnter();
8686
8687 AssertReturn(mMediaData.isBackedUp(), E_FAIL);
8688
8689 HRESULT rc = S_OK;
8690
8691 MediaData::AttachmentList implicitAtts;
8692
8693 const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
8694
8695 /* enumerate new attachments */
8696 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
8697 it != mMediaData->mAttachments.end();
8698 ++it)
8699 {
8700 ComObjPtr<Medium> hd = (*it)->getMedium();
8701 if (hd.isNull())
8702 continue;
8703
8704 if ((*it)->isImplicit())
8705 {
8706 /* deassociate and mark for deletion */
8707 LogFlowThisFunc(("Detaching '%s', pending deletion\n", (*it)->getLogName()));
8708 rc = hd->removeBackReference(mData->mUuid);
8709 AssertComRC(rc);
8710 implicitAtts.push_back(*it);
8711 continue;
8712 }
8713
8714 /* was this hard disk attached before? */
8715 if (!findAttachment(oldAtts, hd))
8716 {
8717 /* no: de-associate */
8718 LogFlowThisFunc(("Detaching '%s', no deletion\n", (*it)->getLogName()));
8719 rc = hd->removeBackReference(mData->mUuid);
8720 AssertComRC(rc);
8721 continue;
8722 }
8723 LogFlowThisFunc(("Not detaching '%s'\n", (*it)->getLogName()));
8724 }
8725
8726 /* rollback hard disk changes */
8727 mMediaData.rollback();
8728
8729 MultiResult mrc(S_OK);
8730
8731 /* delete unused implicit diffs */
8732 if (implicitAtts.size() != 0)
8733 {
8734 /* will leave the lock before the potentially lengthy
8735 * operation, so protect with the special state (unless already
8736 * protected) */
8737 MachineState_T oldState = mData->mMachineState;
8738 if ( oldState != MachineState_Saving
8739 && oldState != MachineState_LiveSnapshotting
8740 && oldState != MachineState_RestoringSnapshot
8741 && oldState != MachineState_DeletingSnapshot
8742 && oldState != MachineState_DeletingSnapshotOnline
8743 && oldState != MachineState_DeletingSnapshotPaused
8744 )
8745 setMachineState(MachineState_SettingUp);
8746
8747 alock.leave();
8748
8749 for (MediaData::AttachmentList::const_iterator it = implicitAtts.begin();
8750 it != implicitAtts.end();
8751 ++it)
8752 {
8753 LogFlowThisFunc(("Deleting '%s'\n", (*it)->getLogName()));
8754 ComObjPtr<Medium> hd = (*it)->getMedium();
8755
8756 rc = hd->deleteStorage(NULL /*aProgress*/, true /*aWait*/,
8757 pfNeedsSaveSettings);
8758 AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, (*it)->getLogName(), hd->getLocationFull().c_str() ));
8759 mrc = rc;
8760 }
8761
8762 alock.enter();
8763
8764 if (mData->mMachineState == MachineState_SettingUp)
8765 {
8766 setMachineState(oldState);
8767 }
8768 }
8769
8770 return mrc;
8771}
8772
8773/**
8774 * Looks through the given list of media attachments for one with the given parameters
8775 * and returns it, or NULL if not found. The list is a parameter so that backup lists
8776 * can be searched as well if needed.
8777 *
8778 * @param list
8779 * @param aControllerName
8780 * @param aControllerPort
8781 * @param aDevice
8782 * @return
8783 */
8784MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
8785 IN_BSTR aControllerName,
8786 LONG aControllerPort,
8787 LONG aDevice)
8788{
8789 for (MediaData::AttachmentList::const_iterator it = ll.begin();
8790 it != ll.end();
8791 ++it)
8792 {
8793 MediumAttachment *pAttach = *it;
8794 if (pAttach->matches(aControllerName, aControllerPort, aDevice))
8795 return pAttach;
8796 }
8797
8798 return NULL;
8799}
8800
8801/**
8802 * Looks through the given list of media attachments for one with the given parameters
8803 * and returns it, or NULL if not found. The list is a parameter so that backup lists
8804 * can be searched as well if needed.
8805 *
8806 * @param list
8807 * @param aControllerName
8808 * @param aControllerPort
8809 * @param aDevice
8810 * @return
8811 */
8812MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
8813 ComObjPtr<Medium> pMedium)
8814{
8815 for (MediaData::AttachmentList::const_iterator it = ll.begin();
8816 it != ll.end();
8817 ++it)
8818 {
8819 MediumAttachment *pAttach = *it;
8820 ComObjPtr<Medium> pMediumThis = pAttach->getMedium();
8821 if (pMediumThis == pMedium)
8822 return pAttach;
8823 }
8824
8825 return NULL;
8826}
8827
8828/**
8829 * Looks through the given list of media attachments for one with the given parameters
8830 * and returns it, or NULL if not found. The list is a parameter so that backup lists
8831 * can be searched as well if needed.
8832 *
8833 * @param list
8834 * @param aControllerName
8835 * @param aControllerPort
8836 * @param aDevice
8837 * @return
8838 */
8839MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
8840 Guid &id)
8841{
8842 for (MediaData::AttachmentList::const_iterator it = ll.begin();
8843 it != ll.end();
8844 ++it)
8845 {
8846 MediumAttachment *pAttach = *it;
8847 ComObjPtr<Medium> pMediumThis = pAttach->getMedium();
8848 if (pMediumThis->getId() == id)
8849 return pAttach;
8850 }
8851
8852 return NULL;
8853}
8854
8855/**
8856 * Main implementation for Machine::DetachDevice. This also gets called
8857 * from Machine::prepareUnregister() so it has been taken out for simplicity.
8858 *
8859 * @param pAttach Medium attachment to detach.
8860 * @param writeLock Machine write lock which the caller must have locked once. This may be released temporarily in here.
8861 * @param pSnapshot If NULL, then the detachment is for the current machine. Otherwise this is for a SnapshotMachine, and this must be its snapshot.
8862 * @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
8863 * by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
8864 * @return
8865 */
8866HRESULT Machine::detachDevice(MediumAttachment *pAttach,
8867 AutoWriteLock &writeLock,
8868 Snapshot *pSnapshot,
8869 bool *pfNeedsSaveSettings)
8870{
8871 ComObjPtr<Medium> oldmedium = pAttach->getMedium();
8872 DeviceType_T mediumType = pAttach->getType();
8873
8874 LogFlowThisFunc(("Entering, medium of attachment is %s\n", oldmedium ? oldmedium->getLocationFull().c_str() : "NULL"));
8875
8876 if (pAttach->isImplicit())
8877 {
8878 /* attempt to implicitly delete the implicitly created diff */
8879
8880 /// @todo move the implicit flag from MediumAttachment to Medium
8881 /// and forbid any hard disk operation when it is implicit. Or maybe
8882 /// a special media state for it to make it even more simple.
8883
8884 Assert(mMediaData.isBackedUp());
8885
8886 /* will leave the lock before the potentially lengthy operation, so
8887 * protect with the special state */
8888 MachineState_T oldState = mData->mMachineState;
8889 setMachineState(MachineState_SettingUp);
8890
8891 writeLock.release();
8892
8893 HRESULT rc = oldmedium->deleteStorage(NULL /*aProgress*/, true /*aWait*/,
8894 pfNeedsSaveSettings);
8895
8896 writeLock.acquire();
8897
8898 setMachineState(oldState);
8899
8900 if (FAILED(rc)) return rc;
8901 }
8902
8903 setModified(IsModified_Storage);
8904 mMediaData.backup();
8905
8906 // we cannot use erase (it) below because backup() above will create
8907 // a copy of the list and make this copy active, but the iterator
8908 // still refers to the original and is not valid for the copy
8909 mMediaData->mAttachments.remove(pAttach);
8910
8911 if (!oldmedium.isNull())
8912 {
8913 // if this is from a snapshot, do not defer detachment to commitMedia()
8914 if (pSnapshot)
8915 oldmedium->removeBackReference(mData->mUuid, pSnapshot->getId());
8916 // else if non-hard disk media, do not defer detachment to commitMedia() either
8917 else if (mediumType != DeviceType_HardDisk)
8918 oldmedium->removeBackReference(mData->mUuid);
8919 }
8920
8921 return S_OK;
8922}
8923
8924/**
8925 * Goes thru all medium attachments of the list and calls detachDevice() on each
8926 * of them and attaches all Medium objects found in the process to the given list,
8927 * depending on cleanupMode.
8928 *
8929 * This gets called from Machine::Unregister, both for the actual Machine and
8930 * the SnapshotMachine objects that might be found in the snapshots.
8931 *
8932 * Requires caller and locking.
8933 *
8934 * @param writeLock Machine lock from top-level caller; this gets passed to detachDevice.
8935 * @param pSnapshot Must be NULL when called for a "real" Machine or a snapshot object if called for a SnapshotMachine.
8936 * @param cleanupMode If DetachAllReturnHardDisksOnly, only hard disk media get added to llMedia; if Full, then all media get added;
8937 * otherwise no media get added.
8938 * @param llMedia Caller's list to receive Medium objects which got detached so caller can close() them, depending on cleanupMode.
8939 * @return
8940 */
8941HRESULT Machine::detachAllMedia(AutoWriteLock &writeLock,
8942 Snapshot *pSnapshot,
8943 CleanupMode_T cleanupMode,
8944 MediaList &llMedia)
8945{
8946 Assert(isWriteLockOnCurrentThread());
8947
8948 HRESULT rc;
8949
8950 // make a temporary list because detachDevice invalidates iterators into
8951 // mMediaData->mAttachments
8952 MediaData::AttachmentList llAttachments2 = mMediaData->mAttachments;
8953
8954 for (MediaData::AttachmentList::iterator it = llAttachments2.begin();
8955 it != llAttachments2.end();
8956 ++it)
8957 {
8958 ComObjPtr<MediumAttachment> pAttach = *it;
8959 ComObjPtr<Medium> pMedium = pAttach->getMedium();
8960
8961 if (!pMedium.isNull())
8962 {
8963 DeviceType_T devType = pMedium->getDeviceType();
8964 if ( ( cleanupMode == CleanupMode_DetachAllReturnHardDisksOnly
8965 && devType == DeviceType_HardDisk)
8966 || (cleanupMode == CleanupMode_Full)
8967 )
8968 llMedia.push_back(pMedium);
8969 }
8970
8971 // real machine: then we need to use the proper method
8972 rc = detachDevice(pAttach,
8973 writeLock,
8974 pSnapshot,
8975 NULL /* pfNeedsSaveSettings */);
8976
8977 if (FAILED(rc))
8978 return rc;
8979 }
8980
8981 return S_OK;
8982}
8983
8984/**
8985 * Perform deferred hard disk detachments.
8986 *
8987 * Does nothing if the hard disk attachment data (mMediaData) is not changed (not
8988 * backed up).
8989 *
8990 * If @a aOnline is @c true then this method will also unlock the old hard disks
8991 * for which the new implicit diffs were created and will lock these new diffs for
8992 * writing.
8993 *
8994 * @param aOnline Whether the VM was online prior to this operation.
8995 *
8996 * @note Locks this object for writing!
8997 */
8998void Machine::commitMedia(bool aOnline /*= false*/)
8999{
9000 AutoCaller autoCaller(this);
9001 AssertComRCReturnVoid(autoCaller.rc());
9002
9003 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
9004
9005 LogFlowThisFunc(("Entering, aOnline=%d\n", aOnline));
9006
9007 HRESULT rc = S_OK;
9008
9009 /* no attach/detach operations -- nothing to do */
9010 if (!mMediaData.isBackedUp())
9011 return;
9012
9013 MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
9014 bool fMediaNeedsLocking = false;
9015
9016 /* enumerate new attachments */
9017 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
9018 it != mMediaData->mAttachments.end();
9019 ++it)
9020 {
9021 MediumAttachment *pAttach = *it;
9022
9023 pAttach->commit();
9024
9025 Medium* pMedium = pAttach->getMedium();
9026 bool fImplicit = pAttach->isImplicit();
9027
9028 LogFlowThisFunc(("Examining current medium '%s' (implicit: %d)\n",
9029 (pMedium) ? pMedium->getName().c_str() : "NULL",
9030 fImplicit));
9031
9032 /** @todo convert all this Machine-based voodoo to MediumAttachment
9033 * based commit logic. */
9034 if (fImplicit)
9035 {
9036 /* convert implicit attachment to normal */
9037 pAttach->setImplicit(false);
9038
9039 if ( aOnline
9040 && pMedium
9041 && pAttach->getType() == DeviceType_HardDisk
9042 )
9043 {
9044 ComObjPtr<Medium> parent = pMedium->getParent();
9045 AutoWriteLock parentLock(parent COMMA_LOCKVAL_SRC_POS);
9046
9047 /* update the appropriate lock list */
9048 MediumLockList *pMediumLockList;
9049 rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
9050 AssertComRC(rc);
9051 if (pMediumLockList)
9052 {
9053 /* unlock if there's a need to change the locking */
9054 if (!fMediaNeedsLocking)
9055 {
9056 rc = mData->mSession.mLockedMedia.Unlock();
9057 AssertComRC(rc);
9058 fMediaNeedsLocking = true;
9059 }
9060 rc = pMediumLockList->Update(parent, false);
9061 AssertComRC(rc);
9062 rc = pMediumLockList->Append(pMedium, true);
9063 AssertComRC(rc);
9064 }
9065 }
9066
9067 continue;
9068 }
9069
9070 if (pMedium)
9071 {
9072 /* was this medium attached before? */
9073 for (MediaData::AttachmentList::iterator oldIt = oldAtts.begin();
9074 oldIt != oldAtts.end();
9075 ++oldIt)
9076 {
9077 MediumAttachment *pOldAttach = *oldIt;
9078 if (pOldAttach->getMedium() == pMedium)
9079 {
9080 LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->getName().c_str()));
9081
9082 /* yes: remove from old to avoid de-association */
9083 oldAtts.erase(oldIt);
9084 break;
9085 }
9086 }
9087 }
9088 }
9089
9090 /* enumerate remaining old attachments and de-associate from the
9091 * current machine state */
9092 for (MediaData::AttachmentList::const_iterator it = oldAtts.begin();
9093 it != oldAtts.end();
9094 ++it)
9095 {
9096 MediumAttachment *pAttach = *it;
9097 Medium* pMedium = pAttach->getMedium();
9098
9099 /* Detach only hard disks, since DVD/floppy media is detached
9100 * instantly in MountMedium. */
9101 if (pAttach->getType() == DeviceType_HardDisk && pMedium)
9102 {
9103 LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->getName().c_str()));
9104
9105 /* now de-associate from the current machine state */
9106 rc = pMedium->removeBackReference(mData->mUuid);
9107 AssertComRC(rc);
9108
9109 if (aOnline)
9110 {
9111 /* unlock since medium is not used anymore */
9112 MediumLockList *pMediumLockList;
9113 rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
9114 AssertComRC(rc);
9115 if (pMediumLockList)
9116 {
9117 rc = mData->mSession.mLockedMedia.Remove(pAttach);
9118 AssertComRC(rc);
9119 }
9120 }
9121 }
9122 }
9123
9124 /* take media locks again so that the locking state is consistent */
9125 if (fMediaNeedsLocking)
9126 {
9127 Assert(aOnline);
9128 rc = mData->mSession.mLockedMedia.Lock();
9129 AssertComRC(rc);
9130 }
9131
9132 /* commit the hard disk changes */
9133 mMediaData.commit();
9134
9135 if (isSessionMachine())
9136 {
9137 /* attach new data to the primary machine and reshare it */
9138 mPeer->mMediaData.attach(mMediaData);
9139 }
9140
9141 return;
9142}
9143
9144/**
9145 * Perform deferred deletion of implicitly created diffs.
9146 *
9147 * Does nothing if the hard disk attachment data (mMediaData) is not changed (not
9148 * backed up).
9149 *
9150 * @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
9151 * by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
9152 *
9153 * @note Locks this object for writing!
9154 */
9155void Machine::rollbackMedia()
9156{
9157 AutoCaller autoCaller(this);
9158 AssertComRCReturnVoid (autoCaller.rc());
9159
9160 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
9161
9162 LogFlowThisFunc(("Entering\n"));
9163
9164 HRESULT rc = S_OK;
9165
9166 /* no attach/detach operations -- nothing to do */
9167 if (!mMediaData.isBackedUp())
9168 return;
9169
9170 /* enumerate new attachments */
9171 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
9172 it != mMediaData->mAttachments.end();
9173 ++it)
9174 {
9175 MediumAttachment *pAttach = *it;
9176 /* Fix up the backrefs for DVD/floppy media. */
9177 if (pAttach->getType() != DeviceType_HardDisk)
9178 {
9179 Medium* pMedium = pAttach->getMedium();
9180 if (pMedium)
9181 {
9182 rc = pMedium->removeBackReference(mData->mUuid);
9183 AssertComRC(rc);
9184 }
9185 }
9186
9187 (*it)->rollback();
9188
9189 pAttach = *it;
9190 /* Fix up the backrefs for DVD/floppy media. */
9191 if (pAttach->getType() != DeviceType_HardDisk)
9192 {
9193 Medium* pMedium = pAttach->getMedium();
9194 if (pMedium)
9195 {
9196 rc = pMedium->addBackReference(mData->mUuid);
9197 AssertComRC(rc);
9198 }
9199 }
9200 }
9201
9202 /** @todo convert all this Machine-based voodoo to MediumAttachment
9203 * based rollback logic. */
9204 // @todo r=dj the below totally fails if this gets called from Machine::rollback(),
9205 // which gets called if Machine::registeredInit() fails...
9206 deleteImplicitDiffs(NULL /*pfNeedsSaveSettings*/);
9207
9208 return;
9209}
9210
9211/**
9212 * Returns true if the settings file is located in the directory named exactly
9213 * as the machine. This will be true if the machine settings structure was
9214 * created by default in #openConfigLoader().
9215 *
9216 * @param aSettingsDir if not NULL, the full machine settings file directory
9217 * name will be assigned there.
9218 *
9219 * @note Doesn't lock anything.
9220 * @note Not thread safe (must be called from this object's lock).
9221 */
9222bool Machine::isInOwnDir(Utf8Str *aSettingsDir /* = NULL */) const
9223{
9224 Utf8Str settingsDir = mData->m_strConfigFileFull;
9225 settingsDir.stripFilename();
9226 Utf8Str strDirName = RTPathFilename(settingsDir.c_str());
9227
9228 AssertReturn(!strDirName.isEmpty(), false);
9229
9230 /* if we don't rename anything on name change, return false shorlty */
9231 if (!mUserData->s.fNameSync)
9232 return false;
9233
9234 if (aSettingsDir)
9235 *aSettingsDir = settingsDir;
9236
9237 return strDirName == mUserData->s.strName;
9238}
9239
9240/**
9241 * Discards all changes to machine settings.
9242 *
9243 * @param aNotify Whether to notify the direct session about changes or not.
9244 *
9245 * @note Locks objects for writing!
9246 */
9247void Machine::rollback(bool aNotify)
9248{
9249 AutoCaller autoCaller(this);
9250 AssertComRCReturn(autoCaller.rc(), (void)0);
9251
9252 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
9253
9254 if (!mStorageControllers.isNull())
9255 {
9256 if (mStorageControllers.isBackedUp())
9257 {
9258 /* unitialize all new devices (absent in the backed up list). */
9259 StorageControllerList::const_iterator it = mStorageControllers->begin();
9260 StorageControllerList *backedList = mStorageControllers.backedUpData();
9261 while (it != mStorageControllers->end())
9262 {
9263 if ( std::find(backedList->begin(), backedList->end(), *it)
9264 == backedList->end()
9265 )
9266 {
9267 (*it)->uninit();
9268 }
9269 ++it;
9270 }
9271
9272 /* restore the list */
9273 mStorageControllers.rollback();
9274 }
9275
9276 /* rollback any changes to devices after restoring the list */
9277 if (mData->flModifications & IsModified_Storage)
9278 {
9279 StorageControllerList::const_iterator it = mStorageControllers->begin();
9280 while (it != mStorageControllers->end())
9281 {
9282 (*it)->rollback();
9283 ++it;
9284 }
9285 }
9286 }
9287
9288 mUserData.rollback();
9289
9290 mHWData.rollback();
9291
9292 if (mData->flModifications & IsModified_Storage)
9293 rollbackMedia();
9294
9295 if (mBIOSSettings)
9296 mBIOSSettings->rollback();
9297
9298#ifdef VBOX_WITH_VRDP
9299 if (mVRDPServer && (mData->flModifications & IsModified_VRDPServer))
9300 mVRDPServer->rollback();
9301#endif
9302
9303 if (mAudioAdapter)
9304 mAudioAdapter->rollback();
9305
9306 if (mUSBController && (mData->flModifications & IsModified_USB))
9307 mUSBController->rollback();
9308
9309 ComPtr<INetworkAdapter> networkAdapters[RT_ELEMENTS(mNetworkAdapters)];
9310 ComPtr<ISerialPort> serialPorts[RT_ELEMENTS(mSerialPorts)];
9311 ComPtr<IParallelPort> parallelPorts[RT_ELEMENTS(mParallelPorts)];
9312
9313 if (mData->flModifications & IsModified_NetworkAdapters)
9314 for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
9315 if ( mNetworkAdapters[slot]
9316 && mNetworkAdapters[slot]->isModified())
9317 {
9318 mNetworkAdapters[slot]->rollback();
9319 networkAdapters[slot] = mNetworkAdapters[slot];
9320 }
9321
9322 if (mData->flModifications & IsModified_SerialPorts)
9323 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
9324 if ( mSerialPorts[slot]
9325 && mSerialPorts[slot]->isModified())
9326 {
9327 mSerialPorts[slot]->rollback();
9328 serialPorts[slot] = mSerialPorts[slot];
9329 }
9330
9331 if (mData->flModifications & IsModified_ParallelPorts)
9332 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
9333 if ( mParallelPorts[slot]
9334 && mParallelPorts[slot]->isModified())
9335 {
9336 mParallelPorts[slot]->rollback();
9337 parallelPorts[slot] = mParallelPorts[slot];
9338 }
9339
9340 if (aNotify)
9341 {
9342 /* inform the direct session about changes */
9343
9344 ComObjPtr<Machine> that = this;
9345 uint32_t flModifications = mData->flModifications;
9346 alock.leave();
9347
9348 if (flModifications & IsModified_SharedFolders)
9349 that->onSharedFolderChange();
9350
9351 if (flModifications & IsModified_VRDPServer)
9352 that->onVRDPServerChange(/* aRestart */ TRUE);
9353 if (flModifications & IsModified_USB)
9354 that->onUSBControllerChange();
9355
9356 for (ULONG slot = 0; slot < RT_ELEMENTS(networkAdapters); slot ++)
9357 if (networkAdapters[slot])
9358 that->onNetworkAdapterChange(networkAdapters[slot], FALSE);
9359 for (ULONG slot = 0; slot < RT_ELEMENTS(serialPorts); slot ++)
9360 if (serialPorts[slot])
9361 that->onSerialPortChange(serialPorts[slot]);
9362 for (ULONG slot = 0; slot < RT_ELEMENTS(parallelPorts); slot ++)
9363 if (parallelPorts[slot])
9364 that->onParallelPortChange(parallelPorts[slot]);
9365
9366 if (flModifications & IsModified_Storage)
9367 that->onStorageControllerChange();
9368 }
9369}
9370
9371/**
9372 * Commits all the changes to machine settings.
9373 *
9374 * Note that this operation is supposed to never fail.
9375 *
9376 * @note Locks this object and children for writing.
9377 */
9378void Machine::commit()
9379{
9380 AutoCaller autoCaller(this);
9381 AssertComRCReturnVoid(autoCaller.rc());
9382
9383 AutoCaller peerCaller(mPeer);
9384 AssertComRCReturnVoid(peerCaller.rc());
9385
9386 AutoMultiWriteLock2 alock(mPeer, this COMMA_LOCKVAL_SRC_POS);
9387
9388 /*
9389 * use safe commit to ensure Snapshot machines (that share mUserData)
9390 * will still refer to a valid memory location
9391 */
9392 mUserData.commitCopy();
9393
9394 mHWData.commit();
9395
9396 if (mMediaData.isBackedUp())
9397 commitMedia();
9398
9399 mBIOSSettings->commit();
9400#ifdef VBOX_WITH_VRDP
9401 mVRDPServer->commit();
9402#endif
9403 mAudioAdapter->commit();
9404 mUSBController->commit();
9405
9406 for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
9407 mNetworkAdapters[slot]->commit();
9408 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
9409 mSerialPorts[slot]->commit();
9410 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
9411 mParallelPorts[slot]->commit();
9412
9413 bool commitStorageControllers = false;
9414
9415 if (mStorageControllers.isBackedUp())
9416 {
9417 mStorageControllers.commit();
9418
9419 if (mPeer)
9420 {
9421 AutoWriteLock peerlock(mPeer COMMA_LOCKVAL_SRC_POS);
9422
9423 /* Commit all changes to new controllers (this will reshare data with
9424 * peers for thos who have peers) */
9425 StorageControllerList *newList = new StorageControllerList();
9426 StorageControllerList::const_iterator it = mStorageControllers->begin();
9427 while (it != mStorageControllers->end())
9428 {
9429 (*it)->commit();
9430
9431 /* look if this controller has a peer device */
9432 ComObjPtr<StorageController> peer = (*it)->getPeer();
9433 if (!peer)
9434 {
9435 /* no peer means the device is a newly created one;
9436 * create a peer owning data this device share it with */
9437 peer.createObject();
9438 peer->init(mPeer, *it, true /* aReshare */);
9439 }
9440 else
9441 {
9442 /* remove peer from the old list */
9443 mPeer->mStorageControllers->remove(peer);
9444 }
9445 /* and add it to the new list */
9446 newList->push_back(peer);
9447
9448 ++it;
9449 }
9450
9451 /* uninit old peer's controllers that are left */
9452 it = mPeer->mStorageControllers->begin();
9453 while (it != mPeer->mStorageControllers->end())
9454 {
9455 (*it)->uninit();
9456 ++it;
9457 }
9458
9459 /* attach new list of controllers to our peer */
9460 mPeer->mStorageControllers.attach(newList);
9461 }
9462 else
9463 {
9464 /* we have no peer (our parent is the newly created machine);
9465 * just commit changes to devices */
9466 commitStorageControllers = true;
9467 }
9468 }
9469 else
9470 {
9471 /* the list of controllers itself is not changed,
9472 * just commit changes to controllers themselves */
9473 commitStorageControllers = true;
9474 }
9475
9476 if (commitStorageControllers)
9477 {
9478 StorageControllerList::const_iterator it = mStorageControllers->begin();
9479 while (it != mStorageControllers->end())
9480 {
9481 (*it)->commit();
9482 ++it;
9483 }
9484 }
9485
9486 if (isSessionMachine())
9487 {
9488 /* attach new data to the primary machine and reshare it */
9489 mPeer->mUserData.attach(mUserData);
9490 mPeer->mHWData.attach(mHWData);
9491 /* mMediaData is reshared by fixupMedia */
9492 // mPeer->mMediaData.attach(mMediaData);
9493 Assert(mPeer->mMediaData.data() == mMediaData.data());
9494 }
9495}
9496
9497/**
9498 * Copies all the hardware data from the given machine.
9499 *
9500 * Currently, only called when the VM is being restored from a snapshot. In
9501 * particular, this implies that the VM is not running during this method's
9502 * call.
9503 *
9504 * @note This method must be called from under this object's lock.
9505 *
9506 * @note This method doesn't call #commit(), so all data remains backed up and
9507 * unsaved.
9508 */
9509void Machine::copyFrom(Machine *aThat)
9510{
9511 AssertReturnVoid(!isSnapshotMachine());
9512 AssertReturnVoid(aThat->isSnapshotMachine());
9513
9514 AssertReturnVoid(!Global::IsOnline(mData->mMachineState));
9515
9516 mHWData.assignCopy(aThat->mHWData);
9517
9518 // create copies of all shared folders (mHWData after attiching a copy
9519 // contains just references to original objects)
9520 for (HWData::SharedFolderList::iterator it = mHWData->mSharedFolders.begin();
9521 it != mHWData->mSharedFolders.end();
9522 ++it)
9523 {
9524 ComObjPtr<SharedFolder> folder;
9525 folder.createObject();
9526 HRESULT rc = folder->initCopy(getMachine(), *it);
9527 AssertComRC(rc);
9528 *it = folder;
9529 }
9530
9531 mBIOSSettings->copyFrom(aThat->mBIOSSettings);
9532#ifdef VBOX_WITH_VRDP
9533 mVRDPServer->copyFrom(aThat->mVRDPServer);
9534#endif
9535 mAudioAdapter->copyFrom(aThat->mAudioAdapter);
9536 mUSBController->copyFrom(aThat->mUSBController);
9537
9538 /* create private copies of all controllers */
9539 mStorageControllers.backup();
9540 mStorageControllers->clear();
9541 for (StorageControllerList::iterator it = aThat->mStorageControllers->begin();
9542 it != aThat->mStorageControllers->end();
9543 ++it)
9544 {
9545 ComObjPtr<StorageController> ctrl;
9546 ctrl.createObject();
9547 ctrl->initCopy(this, *it);
9548 mStorageControllers->push_back(ctrl);
9549 }
9550
9551 for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
9552 mNetworkAdapters[slot]->copyFrom(aThat->mNetworkAdapters[slot]);
9553 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
9554 mSerialPorts[slot]->copyFrom(aThat->mSerialPorts[slot]);
9555 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
9556 mParallelPorts[slot]->copyFrom(aThat->mParallelPorts[slot]);
9557}
9558
9559#ifdef VBOX_WITH_RESOURCE_USAGE_API
9560
9561void Machine::registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid)
9562{
9563 AssertReturnVoid(isWriteLockOnCurrentThread());
9564 AssertPtrReturnVoid(aCollector);
9565
9566 pm::CollectorHAL *hal = aCollector->getHAL();
9567 /* Create sub metrics */
9568 pm::SubMetric *cpuLoadUser = new pm::SubMetric("CPU/Load/User",
9569 "Percentage of processor time spent in user mode by the VM process.");
9570 pm::SubMetric *cpuLoadKernel = new pm::SubMetric("CPU/Load/Kernel",
9571 "Percentage of processor time spent in kernel mode by the VM process.");
9572 pm::SubMetric *ramUsageUsed = new pm::SubMetric("RAM/Usage/Used",
9573 "Size of resident portion of VM process in memory.");
9574 /* Create and register base metrics */
9575 pm::BaseMetric *cpuLoad = new pm::MachineCpuLoadRaw(hal, aMachine, pid,
9576 cpuLoadUser, cpuLoadKernel);
9577 aCollector->registerBaseMetric(cpuLoad);
9578 pm::BaseMetric *ramUsage = new pm::MachineRamUsage(hal, aMachine, pid,
9579 ramUsageUsed);
9580 aCollector->registerBaseMetric(ramUsage);
9581
9582 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser, 0));
9583 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
9584 new pm::AggregateAvg()));
9585 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
9586 new pm::AggregateMin()));
9587 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
9588 new pm::AggregateMax()));
9589 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel, 0));
9590 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
9591 new pm::AggregateAvg()));
9592 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
9593 new pm::AggregateMin()));
9594 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
9595 new pm::AggregateMax()));
9596
9597 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed, 0));
9598 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
9599 new pm::AggregateAvg()));
9600 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
9601 new pm::AggregateMin()));
9602 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
9603 new pm::AggregateMax()));
9604
9605
9606 /* Guest metrics */
9607 mGuestHAL = new pm::CollectorGuestHAL(this, hal);
9608
9609 /* Create sub metrics */
9610 pm::SubMetric *guestLoadUser = new pm::SubMetric("Guest/CPU/Load/User",
9611 "Percentage of processor time spent in user mode as seen by the guest.");
9612 pm::SubMetric *guestLoadKernel = new pm::SubMetric("Guest/CPU/Load/Kernel",
9613 "Percentage of processor time spent in kernel mode as seen by the guest.");
9614 pm::SubMetric *guestLoadIdle = new pm::SubMetric("Guest/CPU/Load/Idle",
9615 "Percentage of processor time spent idling as seen by the guest.");
9616
9617 /* The total amount of physical ram is fixed now, but we'll support dynamic guest ram configurations in the future. */
9618 pm::SubMetric *guestMemTotal = new pm::SubMetric("Guest/RAM/Usage/Total", "Total amount of physical guest RAM.");
9619 pm::SubMetric *guestMemFree = new pm::SubMetric("Guest/RAM/Usage/Free", "Free amount of physical guest RAM.");
9620 pm::SubMetric *guestMemBalloon = new pm::SubMetric("Guest/RAM/Usage/Balloon", "Amount of ballooned physical guest RAM.");
9621 pm::SubMetric *guestMemShared = new pm::SubMetric("Guest/RAM/Usage/Shared", "Amount of shared physical guest RAM.");
9622 pm::SubMetric *guestMemCache = new pm::SubMetric("Guest/RAM/Usage/Cache", "Total amount of guest (disk) cache memory.");
9623
9624 pm::SubMetric *guestPagedTotal = new pm::SubMetric("Guest/Pagefile/Usage/Total", "Total amount of space in the page file.");
9625
9626 /* Create and register base metrics */
9627 pm::BaseMetric *guestCpuLoad = new pm::GuestCpuLoad(mGuestHAL, aMachine, guestLoadUser, guestLoadKernel, guestLoadIdle);
9628 aCollector->registerBaseMetric(guestCpuLoad);
9629
9630 pm::BaseMetric *guestCpuMem = new pm::GuestRamUsage(mGuestHAL, aMachine, guestMemTotal, guestMemFree, guestMemBalloon, guestMemShared,
9631 guestMemCache, guestPagedTotal);
9632 aCollector->registerBaseMetric(guestCpuMem);
9633
9634 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, 0));
9635 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateAvg()));
9636 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMin()));
9637 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMax()));
9638
9639 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, 0));
9640 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateAvg()));
9641 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMin()));
9642 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMax()));
9643
9644 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, 0));
9645 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateAvg()));
9646 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMin()));
9647 aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMax()));
9648
9649 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, 0));
9650 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateAvg()));
9651 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMin()));
9652 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMax()));
9653
9654 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, 0));
9655 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateAvg()));
9656 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMin()));
9657 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMax()));
9658
9659 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, 0));
9660 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateAvg()));
9661 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMin()));
9662 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMax()));
9663
9664 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, 0));
9665 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateAvg()));
9666 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMin()));
9667 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMax()));
9668
9669 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, 0));
9670 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateAvg()));
9671 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMin()));
9672 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMax()));
9673
9674 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, 0));
9675 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateAvg()));
9676 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMin()));
9677 aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMax()));
9678}
9679
9680void Machine::unregisterMetrics(PerformanceCollector *aCollector, Machine *aMachine)
9681{
9682 AssertReturnVoid(isWriteLockOnCurrentThread());
9683
9684 if (aCollector)
9685 {
9686 aCollector->unregisterMetricsFor(aMachine);
9687 aCollector->unregisterBaseMetricsFor(aMachine);
9688 }
9689
9690 if (mGuestHAL)
9691 {
9692 delete mGuestHAL;
9693 mGuestHAL = NULL;
9694 }
9695}
9696
9697#endif /* VBOX_WITH_RESOURCE_USAGE_API */
9698
9699
9700////////////////////////////////////////////////////////////////////////////////
9701
9702DEFINE_EMPTY_CTOR_DTOR(SessionMachine)
9703
9704HRESULT SessionMachine::FinalConstruct()
9705{
9706 LogFlowThisFunc(("\n"));
9707
9708#if defined(RT_OS_WINDOWS)
9709 mIPCSem = NULL;
9710#elif defined(RT_OS_OS2)
9711 mIPCSem = NULLHANDLE;
9712#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
9713 mIPCSem = -1;
9714#else
9715# error "Port me!"
9716#endif
9717
9718 return S_OK;
9719}
9720
9721void SessionMachine::FinalRelease()
9722{
9723 LogFlowThisFunc(("\n"));
9724
9725 uninit(Uninit::Unexpected);
9726}
9727
9728/**
9729 * @note Must be called only by Machine::openSession() from its own write lock.
9730 */
9731HRESULT SessionMachine::init(Machine *aMachine)
9732{
9733 LogFlowThisFuncEnter();
9734 LogFlowThisFunc(("mName={%s}\n", aMachine->mUserData->s.strName.c_str()));
9735
9736 AssertReturn(aMachine, E_INVALIDARG);
9737
9738 AssertReturn(aMachine->lockHandle()->isWriteLockOnCurrentThread(), E_FAIL);
9739
9740 /* Enclose the state transition NotReady->InInit->Ready */
9741 AutoInitSpan autoInitSpan(this);
9742 AssertReturn(autoInitSpan.isOk(), E_FAIL);
9743
9744 /* create the interprocess semaphore */
9745#if defined(RT_OS_WINDOWS)
9746 mIPCSemName = aMachine->mData->m_strConfigFileFull;
9747 for (size_t i = 0; i < mIPCSemName.length(); i++)
9748 if (mIPCSemName.raw()[i] == '\\')
9749 mIPCSemName.raw()[i] = '/';
9750 mIPCSem = ::CreateMutex(NULL, FALSE, mIPCSemName.raw());
9751 ComAssertMsgRet(mIPCSem,
9752 ("Cannot create IPC mutex '%ls', err=%d",
9753 mIPCSemName.raw(), ::GetLastError()),
9754 E_FAIL);
9755#elif defined(RT_OS_OS2)
9756 Utf8Str ipcSem = Utf8StrFmt("\\SEM32\\VBOX\\VM\\{%RTuuid}",
9757 aMachine->mData->mUuid.raw());
9758 mIPCSemName = ipcSem;
9759 APIRET arc = ::DosCreateMutexSem((PSZ)ipcSem.raw(), &mIPCSem, 0, FALSE);
9760 ComAssertMsgRet(arc == NO_ERROR,
9761 ("Cannot create IPC mutex '%s', arc=%ld",
9762 ipcSem.raw(), arc),
9763 E_FAIL);
9764#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
9765# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
9766# if defined(RT_OS_FREEBSD) && (HC_ARCH_BITS == 64)
9767 /** @todo Check that this still works correctly. */
9768 AssertCompileSize(key_t, 8);
9769# else
9770 AssertCompileSize(key_t, 4);
9771# endif
9772 key_t key;
9773 mIPCSem = -1;
9774 mIPCKey = "0";
9775 for (uint32_t i = 0; i < 1 << 24; i++)
9776 {
9777 key = ((uint32_t)'V' << 24) | i;
9778 int sem = ::semget(key, 1, S_IRUSR | S_IWUSR | IPC_CREAT | IPC_EXCL);
9779 if (sem >= 0 || (errno != EEXIST && errno != EACCES))
9780 {
9781 mIPCSem = sem;
9782 if (sem >= 0)
9783 mIPCKey = BstrFmt("%u", key);
9784 break;
9785 }
9786 }
9787# else /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
9788 Utf8Str semName = aMachine->mData->m_strConfigFileFull;
9789 char *pszSemName = NULL;
9790 RTStrUtf8ToCurrentCP(&pszSemName, semName);
9791 key_t key = ::ftok(pszSemName, 'V');
9792 RTStrFree(pszSemName);
9793
9794 mIPCSem = ::semget(key, 1, S_IRWXU | S_IRWXG | S_IRWXO | IPC_CREAT);
9795# endif /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
9796
9797 int errnoSave = errno;
9798 if (mIPCSem < 0 && errnoSave == ENOSYS)
9799 {
9800 setError(E_FAIL,
9801 tr("Cannot create IPC semaphore. Most likely your host kernel lacks "
9802 "support for SysV IPC. Check the host kernel configuration for "
9803 "CONFIG_SYSVIPC=y"));
9804 return E_FAIL;
9805 }
9806 /* ENOSPC can also be the result of VBoxSVC crashes without properly freeing
9807 * the IPC semaphores */
9808 if (mIPCSem < 0 && errnoSave == ENOSPC)
9809 {
9810#ifdef RT_OS_LINUX
9811 setError(E_FAIL,
9812 tr("Cannot create IPC semaphore because the system limit for the "
9813 "maximum number of semaphore sets (SEMMNI), or the system wide "
9814 "maximum number of sempahores (SEMMNS) would be exceeded. The "
9815 "current set of SysV IPC semaphores can be determined from "
9816 "the file /proc/sysvipc/sem"));
9817#else
9818 setError(E_FAIL,
9819 tr("Cannot create IPC semaphore because the system-imposed limit "
9820 "on the maximum number of allowed semaphores or semaphore "
9821 "identifiers system-wide would be exceeded"));
9822#endif
9823 return E_FAIL;
9824 }
9825 ComAssertMsgRet(mIPCSem >= 0, ("Cannot create IPC semaphore, errno=%d", errnoSave),
9826 E_FAIL);
9827 /* set the initial value to 1 */
9828 int rv = ::semctl(mIPCSem, 0, SETVAL, 1);
9829 ComAssertMsgRet(rv == 0, ("Cannot init IPC semaphore, errno=%d", errno),
9830 E_FAIL);
9831#else
9832# error "Port me!"
9833#endif
9834
9835 /* memorize the peer Machine */
9836 unconst(mPeer) = aMachine;
9837 /* share the parent pointer */
9838 unconst(mParent) = aMachine->mParent;
9839
9840 /* take the pointers to data to share */
9841 mData.share(aMachine->mData);
9842 mSSData.share(aMachine->mSSData);
9843
9844 mUserData.share(aMachine->mUserData);
9845 mHWData.share(aMachine->mHWData);
9846 mMediaData.share(aMachine->mMediaData);
9847
9848 mStorageControllers.allocate();
9849 for (StorageControllerList::const_iterator it = aMachine->mStorageControllers->begin();
9850 it != aMachine->mStorageControllers->end();
9851 ++it)
9852 {
9853 ComObjPtr<StorageController> ctl;
9854 ctl.createObject();
9855 ctl->init(this, *it);
9856 mStorageControllers->push_back(ctl);
9857 }
9858
9859 unconst(mBIOSSettings).createObject();
9860 mBIOSSettings->init(this, aMachine->mBIOSSettings);
9861#ifdef VBOX_WITH_VRDP
9862 /* create another VRDPServer object that will be mutable */
9863 unconst(mVRDPServer).createObject();
9864 mVRDPServer->init(this, aMachine->mVRDPServer);
9865#endif
9866 /* create another audio adapter object that will be mutable */
9867 unconst(mAudioAdapter).createObject();
9868 mAudioAdapter->init(this, aMachine->mAudioAdapter);
9869 /* create a list of serial ports that will be mutable */
9870 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
9871 {
9872 unconst(mSerialPorts[slot]).createObject();
9873 mSerialPorts[slot]->init(this, aMachine->mSerialPorts[slot]);
9874 }
9875 /* create a list of parallel ports that will be mutable */
9876 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
9877 {
9878 unconst(mParallelPorts[slot]).createObject();
9879 mParallelPorts[slot]->init(this, aMachine->mParallelPorts[slot]);
9880 }
9881 /* create another USB controller object that will be mutable */
9882 unconst(mUSBController).createObject();
9883 mUSBController->init(this, aMachine->mUSBController);
9884
9885 /* create a list of network adapters that will be mutable */
9886 for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
9887 {
9888 unconst(mNetworkAdapters[slot]).createObject();
9889 mNetworkAdapters[slot]->init(this, aMachine->mNetworkAdapters[slot]);
9890 }
9891
9892 /* default is to delete saved state on Saved -> PoweredOff transition */
9893 mRemoveSavedState = true;
9894
9895 /* Confirm a successful initialization when it's the case */
9896 autoInitSpan.setSucceeded();
9897
9898 LogFlowThisFuncLeave();
9899 return S_OK;
9900}
9901
9902/**
9903 * Uninitializes this session object. If the reason is other than
9904 * Uninit::Unexpected, then this method MUST be called from #checkForDeath().
9905 *
9906 * @param aReason uninitialization reason
9907 *
9908 * @note Locks mParent + this object for writing.
9909 */
9910void SessionMachine::uninit(Uninit::Reason aReason)
9911{
9912 LogFlowThisFuncEnter();
9913 LogFlowThisFunc(("reason=%d\n", aReason));
9914
9915 /*
9916 * Strongly reference ourselves to prevent this object deletion after
9917 * mData->mSession.mMachine.setNull() below (which can release the last
9918 * reference and call the destructor). Important: this must be done before
9919 * accessing any members (and before AutoUninitSpan that does it as well).
9920 * This self reference will be released as the very last step on return.
9921 */
9922 ComObjPtr<SessionMachine> selfRef = this;
9923
9924 /* Enclose the state transition Ready->InUninit->NotReady */
9925 AutoUninitSpan autoUninitSpan(this);
9926 if (autoUninitSpan.uninitDone())
9927 {
9928 LogFlowThisFunc(("Already uninitialized\n"));
9929 LogFlowThisFuncLeave();
9930 return;
9931 }
9932
9933 if (autoUninitSpan.initFailed())
9934 {
9935 /* We've been called by init() because it's failed. It's not really
9936 * necessary (nor it's safe) to perform the regular uninit sequense
9937 * below, the following is enough.
9938 */
9939 LogFlowThisFunc(("Initialization failed.\n"));
9940#if defined(RT_OS_WINDOWS)
9941 if (mIPCSem)
9942 ::CloseHandle(mIPCSem);
9943 mIPCSem = NULL;
9944#elif defined(RT_OS_OS2)
9945 if (mIPCSem != NULLHANDLE)
9946 ::DosCloseMutexSem(mIPCSem);
9947 mIPCSem = NULLHANDLE;
9948#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
9949 if (mIPCSem >= 0)
9950 ::semctl(mIPCSem, 0, IPC_RMID);
9951 mIPCSem = -1;
9952# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
9953 mIPCKey = "0";
9954# endif /* VBOX_WITH_NEW_SYS_V_KEYGEN */
9955#else
9956# error "Port me!"
9957#endif
9958 uninitDataAndChildObjects();
9959 mData.free();
9960 unconst(mParent) = NULL;
9961 unconst(mPeer) = NULL;
9962 LogFlowThisFuncLeave();
9963 return;
9964 }
9965
9966 MachineState_T lastState;
9967 {
9968 AutoReadLock tempLock(this COMMA_LOCKVAL_SRC_POS);
9969 lastState = mData->mMachineState;
9970 }
9971 NOREF(lastState);
9972
9973#ifdef VBOX_WITH_USB
9974 // release all captured USB devices, but do this before requesting the locks below
9975 if (aReason == Uninit::Abnormal && Global::IsOnline(lastState))
9976 {
9977 /* Console::captureUSBDevices() is called in the VM process only after
9978 * setting the machine state to Starting or Restoring.
9979 * Console::detachAllUSBDevices() will be called upon successful
9980 * termination. So, we need to release USB devices only if there was
9981 * an abnormal termination of a running VM.
9982 *
9983 * This is identical to SessionMachine::DetachAllUSBDevices except
9984 * for the aAbnormal argument. */
9985 HRESULT rc = mUSBController->notifyProxy(false /* aInsertFilters */);
9986 AssertComRC(rc);
9987 NOREF(rc);
9988
9989 USBProxyService *service = mParent->host()->usbProxyService();
9990 if (service)
9991 service->detachAllDevicesFromVM(this, true /* aDone */, true /* aAbnormal */);
9992 }
9993#endif /* VBOX_WITH_USB */
9994
9995 // we need to lock this object in uninit() because the lock is shared
9996 // with mPeer (as well as data we modify below). mParent->addProcessToReap()
9997 // and others need mParent lock, and USB needs host lock.
9998 AutoMultiWriteLock3 multilock(mParent, mParent->host(), this COMMA_LOCKVAL_SRC_POS);
9999
10000 // Trigger async cleanup tasks, avoid doing things here which are not
10001 // vital to be done immediately and maybe need more locks. This calls
10002 // Machine::unregisterMetrics().
10003 mParent->onMachineUninit(mPeer);
10004
10005 if (aReason == Uninit::Abnormal)
10006 {
10007 LogWarningThisFunc(("ABNORMAL client termination! (wasBusy=%d)\n",
10008 Global::IsOnlineOrTransient(lastState)));
10009
10010 /* reset the state to Aborted */
10011 if (mData->mMachineState != MachineState_Aborted)
10012 setMachineState(MachineState_Aborted);
10013 }
10014
10015 // any machine settings modified?
10016 if (mData->flModifications)
10017 {
10018 LogWarningThisFunc(("Discarding unsaved settings changes!\n"));
10019 rollback(false /* aNotify */);
10020 }
10021
10022 Assert(mSnapshotData.mStateFilePath.isEmpty() || !mSnapshotData.mSnapshot);
10023 if (!mSnapshotData.mStateFilePath.isEmpty())
10024 {
10025 LogWarningThisFunc(("canceling failed save state request!\n"));
10026 endSavingState(FALSE /* aSuccess */);
10027 }
10028 else if (!mSnapshotData.mSnapshot.isNull())
10029 {
10030 LogWarningThisFunc(("canceling untaken snapshot!\n"));
10031
10032 /* delete all differencing hard disks created (this will also attach
10033 * their parents back by rolling back mMediaData) */
10034 rollbackMedia();
10035 /* delete the saved state file (it might have been already created) */
10036 if (mSnapshotData.mSnapshot->stateFilePath().length())
10037 RTFileDelete(mSnapshotData.mSnapshot->stateFilePath().c_str());
10038
10039 mSnapshotData.mSnapshot->uninit();
10040 }
10041
10042 if (!mData->mSession.mType.isEmpty())
10043 {
10044 /* mType is not null when this machine's process has been started by
10045 * Machine::launchVMProcess(), therefore it is our child. We
10046 * need to queue the PID to reap the process (and avoid zombies on
10047 * Linux). */
10048 Assert(mData->mSession.mPid != NIL_RTPROCESS);
10049 mParent->addProcessToReap(mData->mSession.mPid);
10050 }
10051
10052 mData->mSession.mPid = NIL_RTPROCESS;
10053
10054 if (aReason == Uninit::Unexpected)
10055 {
10056 /* Uninitialization didn't come from #checkForDeath(), so tell the
10057 * client watcher thread to update the set of machines that have open
10058 * sessions. */
10059 mParent->updateClientWatcher();
10060 }
10061
10062 /* uninitialize all remote controls */
10063 if (mData->mSession.mRemoteControls.size())
10064 {
10065 LogFlowThisFunc(("Closing remote sessions (%d):\n",
10066 mData->mSession.mRemoteControls.size()));
10067
10068 Data::Session::RemoteControlList::iterator it =
10069 mData->mSession.mRemoteControls.begin();
10070 while (it != mData->mSession.mRemoteControls.end())
10071 {
10072 LogFlowThisFunc((" Calling remoteControl->Uninitialize()...\n"));
10073 HRESULT rc = (*it)->Uninitialize();
10074 LogFlowThisFunc((" remoteControl->Uninitialize() returned %08X\n", rc));
10075 if (FAILED(rc))
10076 LogWarningThisFunc(("Forgot to close the remote session?\n"));
10077 ++it;
10078 }
10079 mData->mSession.mRemoteControls.clear();
10080 }
10081
10082 /*
10083 * An expected uninitialization can come only from #checkForDeath().
10084 * Otherwise it means that something's got really wrong (for examlple,
10085 * the Session implementation has released the VirtualBox reference
10086 * before it triggered #OnSessionEnd(), or before releasing IPC semaphore,
10087 * etc). However, it's also possible, that the client releases the IPC
10088 * semaphore correctly (i.e. before it releases the VirtualBox reference),
10089 * but the VirtualBox release event comes first to the server process.
10090 * This case is practically possible, so we should not assert on an
10091 * unexpected uninit, just log a warning.
10092 */
10093
10094 if ((aReason == Uninit::Unexpected))
10095 LogWarningThisFunc(("Unexpected SessionMachine uninitialization!\n"));
10096
10097 if (aReason != Uninit::Normal)
10098 {
10099 mData->mSession.mDirectControl.setNull();
10100 }
10101 else
10102 {
10103 /* this must be null here (see #OnSessionEnd()) */
10104 Assert(mData->mSession.mDirectControl.isNull());
10105 Assert(mData->mSession.mState == SessionState_Unlocking);
10106 Assert(!mData->mSession.mProgress.isNull());
10107 }
10108 if (mData->mSession.mProgress)
10109 {
10110 if (aReason == Uninit::Normal)
10111 mData->mSession.mProgress->notifyComplete(S_OK);
10112 else
10113 mData->mSession.mProgress->notifyComplete(E_FAIL,
10114 COM_IIDOF(ISession),
10115 getComponentName(),
10116 tr("The VM session was aborted"));
10117 mData->mSession.mProgress.setNull();
10118 }
10119
10120 /* remove the association between the peer machine and this session machine */
10121 Assert( (SessionMachine*)mData->mSession.mMachine == this
10122 || aReason == Uninit::Unexpected);
10123
10124 /* reset the rest of session data */
10125 mData->mSession.mMachine.setNull();
10126 mData->mSession.mState = SessionState_Unlocked;
10127 mData->mSession.mType.setNull();
10128
10129 /* close the interprocess semaphore before leaving the exclusive lock */
10130#if defined(RT_OS_WINDOWS)
10131 if (mIPCSem)
10132 ::CloseHandle(mIPCSem);
10133 mIPCSem = NULL;
10134#elif defined(RT_OS_OS2)
10135 if (mIPCSem != NULLHANDLE)
10136 ::DosCloseMutexSem(mIPCSem);
10137 mIPCSem = NULLHANDLE;
10138#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
10139 if (mIPCSem >= 0)
10140 ::semctl(mIPCSem, 0, IPC_RMID);
10141 mIPCSem = -1;
10142# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
10143 mIPCKey = "0";
10144# endif /* VBOX_WITH_NEW_SYS_V_KEYGEN */
10145#else
10146# error "Port me!"
10147#endif
10148
10149 /* fire an event */
10150 mParent->onSessionStateChange(mData->mUuid, SessionState_Unlocked);
10151
10152 uninitDataAndChildObjects();
10153
10154 /* free the essential data structure last */
10155 mData.free();
10156
10157#if 1 /** @todo Please review this change! (bird) */
10158 /* drop the exclusive lock before setting the below two to NULL */
10159 multilock.release();
10160#else
10161 /* leave the exclusive lock before setting the below two to NULL */
10162 multilock.leave();
10163#endif
10164
10165 unconst(mParent) = NULL;
10166 unconst(mPeer) = NULL;
10167
10168 LogFlowThisFuncLeave();
10169}
10170
10171// util::Lockable interface
10172////////////////////////////////////////////////////////////////////////////////
10173
10174/**
10175 * Overrides VirtualBoxBase::lockHandle() in order to share the lock handle
10176 * with the primary Machine instance (mPeer).
10177 */
10178RWLockHandle *SessionMachine::lockHandle() const
10179{
10180 AssertReturn(mPeer != NULL, NULL);
10181 return mPeer->lockHandle();
10182}
10183
10184// IInternalMachineControl methods
10185////////////////////////////////////////////////////////////////////////////////
10186
10187/**
10188 * @note Locks this object for writing.
10189 */
10190STDMETHODIMP SessionMachine::SetRemoveSavedStateFile(BOOL aRemove)
10191{
10192 AutoCaller autoCaller(this);
10193 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10194
10195 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10196
10197 mRemoveSavedState = aRemove;
10198
10199 return S_OK;
10200}
10201
10202/**
10203 * @note Locks the same as #setMachineState() does.
10204 */
10205STDMETHODIMP SessionMachine::UpdateState(MachineState_T aMachineState)
10206{
10207 return setMachineState(aMachineState);
10208}
10209
10210/**
10211 * @note Locks this object for reading.
10212 */
10213STDMETHODIMP SessionMachine::GetIPCId(BSTR *aId)
10214{
10215 AutoCaller autoCaller(this);
10216 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10217
10218 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
10219
10220#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
10221 mIPCSemName.cloneTo(aId);
10222 return S_OK;
10223#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
10224# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
10225 mIPCKey.cloneTo(aId);
10226# else /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
10227 mData->m_strConfigFileFull.cloneTo(aId);
10228# endif /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
10229 return S_OK;
10230#else
10231# error "Port me!"
10232#endif
10233}
10234
10235/**
10236 * @note Locks this object for writing.
10237 */
10238STDMETHODIMP SessionMachine::BeginPowerUp(IProgress *aProgress)
10239{
10240 LogFlowThisFunc(("aProgress=%p\n", aProgress));
10241 AutoCaller autoCaller(this);
10242 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10243
10244 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10245
10246 if (mData->mSession.mState != SessionState_Locked)
10247 return VBOX_E_INVALID_OBJECT_STATE;
10248
10249 if (!mData->mSession.mProgress.isNull())
10250 mData->mSession.mProgress->setOtherProgressObject(aProgress);
10251
10252 LogFlowThisFunc(("returns S_OK.\n"));
10253 return S_OK;
10254}
10255
10256
10257/**
10258 * @note Locks this object for writing.
10259 */
10260STDMETHODIMP SessionMachine::EndPowerUp(LONG iResult)
10261{
10262 AutoCaller autoCaller(this);
10263 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10264
10265 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10266
10267 if (mData->mSession.mState != SessionState_Locked)
10268 return VBOX_E_INVALID_OBJECT_STATE;
10269
10270 /* Finalize the openRemoteSession progress object. */
10271 if (mData->mSession.mProgress)
10272 {
10273 mData->mSession.mProgress->notifyComplete((HRESULT)iResult);
10274 mData->mSession.mProgress.setNull();
10275 }
10276
10277 if (SUCCEEDED((HRESULT)iResult))
10278 {
10279#ifdef VBOX_WITH_RESOURCE_USAGE_API
10280 /* The VM has been powered up successfully, so it makes sense
10281 * now to offer the performance metrics for a running machine
10282 * object. Doing it earlier wouldn't be safe. */
10283 registerMetrics(mParent->performanceCollector(), mPeer,
10284 mData->mSession.mPid);
10285#endif /* VBOX_WITH_RESOURCE_USAGE_API */
10286 }
10287
10288 return S_OK;
10289}
10290
10291/**
10292 * Goes through the USB filters of the given machine to see if the given
10293 * device matches any filter or not.
10294 *
10295 * @note Locks the same as USBController::hasMatchingFilter() does.
10296 */
10297STDMETHODIMP SessionMachine::RunUSBDeviceFilters(IUSBDevice *aUSBDevice,
10298 BOOL *aMatched,
10299 ULONG *aMaskedIfs)
10300{
10301 LogFlowThisFunc(("\n"));
10302
10303 CheckComArgNotNull(aUSBDevice);
10304 CheckComArgOutPointerValid(aMatched);
10305
10306 AutoCaller autoCaller(this);
10307 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10308
10309#ifdef VBOX_WITH_USB
10310 *aMatched = mUSBController->hasMatchingFilter(aUSBDevice, aMaskedIfs);
10311#else
10312 NOREF(aUSBDevice);
10313 NOREF(aMaskedIfs);
10314 *aMatched = FALSE;
10315#endif
10316
10317 return S_OK;
10318}
10319
10320/**
10321 * @note Locks the same as Host::captureUSBDevice() does.
10322 */
10323STDMETHODIMP SessionMachine::CaptureUSBDevice(IN_BSTR aId)
10324{
10325 LogFlowThisFunc(("\n"));
10326
10327 AutoCaller autoCaller(this);
10328 AssertComRCReturnRC(autoCaller.rc());
10329
10330#ifdef VBOX_WITH_USB
10331 /* if captureDeviceForVM() fails, it must have set extended error info */
10332 MultiResult rc = mParent->host()->checkUSBProxyService();
10333 if (FAILED(rc)) return rc;
10334
10335 USBProxyService *service = mParent->host()->usbProxyService();
10336 AssertReturn(service, E_FAIL);
10337 return service->captureDeviceForVM(this, Guid(aId).ref());
10338#else
10339 NOREF(aId);
10340 return E_NOTIMPL;
10341#endif
10342}
10343
10344/**
10345 * @note Locks the same as Host::detachUSBDevice() does.
10346 */
10347STDMETHODIMP SessionMachine::DetachUSBDevice(IN_BSTR aId, BOOL aDone)
10348{
10349 LogFlowThisFunc(("\n"));
10350
10351 AutoCaller autoCaller(this);
10352 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10353
10354#ifdef VBOX_WITH_USB
10355 USBProxyService *service = mParent->host()->usbProxyService();
10356 AssertReturn(service, E_FAIL);
10357 return service->detachDeviceFromVM(this, Guid(aId).ref(), !!aDone);
10358#else
10359 NOREF(aId);
10360 NOREF(aDone);
10361 return E_NOTIMPL;
10362#endif
10363}
10364
10365/**
10366 * Inserts all machine filters to the USB proxy service and then calls
10367 * Host::autoCaptureUSBDevices().
10368 *
10369 * Called by Console from the VM process upon VM startup.
10370 *
10371 * @note Locks what called methods lock.
10372 */
10373STDMETHODIMP SessionMachine::AutoCaptureUSBDevices()
10374{
10375 LogFlowThisFunc(("\n"));
10376
10377 AutoCaller autoCaller(this);
10378 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10379
10380#ifdef VBOX_WITH_USB
10381 HRESULT rc = mUSBController->notifyProxy(true /* aInsertFilters */);
10382 AssertComRC(rc);
10383 NOREF(rc);
10384
10385 USBProxyService *service = mParent->host()->usbProxyService();
10386 AssertReturn(service, E_FAIL);
10387 return service->autoCaptureDevicesForVM(this);
10388#else
10389 return S_OK;
10390#endif
10391}
10392
10393/**
10394 * Removes all machine filters from the USB proxy service and then calls
10395 * Host::detachAllUSBDevices().
10396 *
10397 * Called by Console from the VM process upon normal VM termination or by
10398 * SessionMachine::uninit() upon abnormal VM termination (from under the
10399 * Machine/SessionMachine lock).
10400 *
10401 * @note Locks what called methods lock.
10402 */
10403STDMETHODIMP SessionMachine::DetachAllUSBDevices(BOOL aDone)
10404{
10405 LogFlowThisFunc(("\n"));
10406
10407 AutoCaller autoCaller(this);
10408 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10409
10410#ifdef VBOX_WITH_USB
10411 HRESULT rc = mUSBController->notifyProxy(false /* aInsertFilters */);
10412 AssertComRC(rc);
10413 NOREF(rc);
10414
10415 USBProxyService *service = mParent->host()->usbProxyService();
10416 AssertReturn(service, E_FAIL);
10417 return service->detachAllDevicesFromVM(this, !!aDone, false /* aAbnormal */);
10418#else
10419 NOREF(aDone);
10420 return S_OK;
10421#endif
10422}
10423
10424/**
10425 * @note Locks this object for writing.
10426 */
10427STDMETHODIMP SessionMachine::OnSessionEnd(ISession *aSession,
10428 IProgress **aProgress)
10429{
10430 LogFlowThisFuncEnter();
10431
10432 AssertReturn(aSession, E_INVALIDARG);
10433 AssertReturn(aProgress, E_INVALIDARG);
10434
10435 AutoCaller autoCaller(this);
10436
10437 LogFlowThisFunc(("callerstate=%d\n", autoCaller.state()));
10438 /*
10439 * We don't assert below because it might happen that a non-direct session
10440 * informs us it is closed right after we've been uninitialized -- it's ok.
10441 */
10442 if (FAILED(autoCaller.rc())) return autoCaller.rc();
10443
10444 /* get IInternalSessionControl interface */
10445 ComPtr<IInternalSessionControl> control(aSession);
10446
10447 ComAssertRet(!control.isNull(), E_INVALIDARG);
10448
10449 /* Creating a Progress object requires the VirtualBox lock, and
10450 * thus locking it here is required by the lock order rules. */
10451 AutoMultiWriteLock2 alock(mParent->lockHandle(), this->lockHandle() COMMA_LOCKVAL_SRC_POS);
10452
10453 if (control == mData->mSession.mDirectControl)
10454 {
10455 ComAssertRet(aProgress, E_POINTER);
10456
10457 /* The direct session is being normally closed by the client process
10458 * ----------------------------------------------------------------- */
10459
10460 /* go to the closing state (essential for all open*Session() calls and
10461 * for #checkForDeath()) */
10462 Assert(mData->mSession.mState == SessionState_Locked);
10463 mData->mSession.mState = SessionState_Unlocking;
10464
10465 /* set direct control to NULL to release the remote instance */
10466 mData->mSession.mDirectControl.setNull();
10467 LogFlowThisFunc(("Direct control is set to NULL\n"));
10468
10469 if (mData->mSession.mProgress)
10470 {
10471 /* finalize the progress, someone might wait if a frontend
10472 * closes the session before powering on the VM. */
10473 mData->mSession.mProgress->notifyComplete(E_FAIL,
10474 COM_IIDOF(ISession),
10475 getComponentName(),
10476 tr("The VM session was closed before any attempt to power it on"));
10477 mData->mSession.mProgress.setNull();
10478 }
10479
10480 /* Create the progress object the client will use to wait until
10481 * #checkForDeath() is called to uninitialize this session object after
10482 * it releases the IPC semaphore.
10483 * Note! Because we're "reusing" mProgress here, this must be a proxy
10484 * object just like for openRemoteSession. */
10485 Assert(mData->mSession.mProgress.isNull());
10486 ComObjPtr<ProgressProxy> progress;
10487 progress.createObject();
10488 ComPtr<IUnknown> pPeer(mPeer);
10489 progress->init(mParent, pPeer,
10490 Bstr(tr("Closing session")).raw(),
10491 FALSE /* aCancelable */);
10492 progress.queryInterfaceTo(aProgress);
10493 mData->mSession.mProgress = progress;
10494 }
10495 else
10496 {
10497 /* the remote session is being normally closed */
10498 Data::Session::RemoteControlList::iterator it =
10499 mData->mSession.mRemoteControls.begin();
10500 while (it != mData->mSession.mRemoteControls.end())
10501 {
10502 if (control == *it)
10503 break;
10504 ++it;
10505 }
10506 BOOL found = it != mData->mSession.mRemoteControls.end();
10507 ComAssertMsgRet(found, ("The session is not found in the session list!"),
10508 E_INVALIDARG);
10509 mData->mSession.mRemoteControls.remove(*it);
10510 }
10511
10512 LogFlowThisFuncLeave();
10513 return S_OK;
10514}
10515
10516/**
10517 * @note Locks this object for writing.
10518 */
10519STDMETHODIMP SessionMachine::BeginSavingState(IProgress *aProgress, BSTR *aStateFilePath)
10520{
10521 LogFlowThisFuncEnter();
10522
10523 AssertReturn(aProgress, E_INVALIDARG);
10524 AssertReturn(aStateFilePath, E_POINTER);
10525
10526 AutoCaller autoCaller(this);
10527 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10528
10529 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10530
10531 AssertReturn( mData->mMachineState == MachineState_Paused
10532 && mSnapshotData.mLastState == MachineState_Null
10533 && mSnapshotData.mProgressId.isEmpty()
10534 && mSnapshotData.mStateFilePath.isEmpty(),
10535 E_FAIL);
10536
10537 /* memorize the progress ID and add it to the global collection */
10538 Bstr progressId;
10539 HRESULT rc = aProgress->COMGETTER(Id)(progressId.asOutParam());
10540 AssertComRCReturn(rc, rc);
10541 rc = mParent->addProgress(aProgress);
10542 AssertComRCReturn(rc, rc);
10543
10544 Bstr stateFilePath;
10545 /* stateFilePath is null when the machine is not running */
10546 if (mData->mMachineState == MachineState_Paused)
10547 {
10548 stateFilePath = Utf8StrFmt("%s%c{%RTuuid}.sav",
10549 mUserData->m_strSnapshotFolderFull.c_str(),
10550 RTPATH_DELIMITER, mData->mUuid.raw());
10551 }
10552
10553 /* fill in the snapshot data */
10554 mSnapshotData.mLastState = mData->mMachineState;
10555 mSnapshotData.mProgressId = Guid(progressId);
10556 mSnapshotData.mStateFilePath = stateFilePath;
10557
10558 /* set the state to Saving (this is expected by Console::SaveState()) */
10559 setMachineState(MachineState_Saving);
10560
10561 stateFilePath.cloneTo(aStateFilePath);
10562
10563 return S_OK;
10564}
10565
10566/**
10567 * @note Locks mParent + this object for writing.
10568 */
10569STDMETHODIMP SessionMachine::EndSavingState(BOOL aSuccess)
10570{
10571 LogFlowThisFunc(("\n"));
10572
10573 AutoCaller autoCaller(this);
10574 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10575
10576 /* endSavingState() need mParent lock */
10577 AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
10578
10579 AssertReturn( mData->mMachineState == MachineState_Saving
10580 && mSnapshotData.mLastState != MachineState_Null
10581 && !mSnapshotData.mProgressId.isEmpty()
10582 && !mSnapshotData.mStateFilePath.isEmpty(),
10583 E_FAIL);
10584
10585 /*
10586 * on success, set the state to Saved;
10587 * on failure, set the state to the state we had when BeginSavingState() was
10588 * called (this is expected by Console::SaveState() and
10589 * Console::saveStateThread())
10590 */
10591 if (aSuccess)
10592 setMachineState(MachineState_Saved);
10593 else
10594 setMachineState(mSnapshotData.mLastState);
10595
10596 return endSavingState(aSuccess);
10597}
10598
10599/**
10600 * @note Locks this object for writing.
10601 */
10602STDMETHODIMP SessionMachine::AdoptSavedState(IN_BSTR aSavedStateFile)
10603{
10604 LogFlowThisFunc(("\n"));
10605
10606 CheckComArgStrNotEmptyOrNull(aSavedStateFile);
10607
10608 AutoCaller autoCaller(this);
10609 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10610
10611 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10612
10613 AssertReturn( mData->mMachineState == MachineState_PoweredOff
10614 || mData->mMachineState == MachineState_Teleported
10615 || mData->mMachineState == MachineState_Aborted
10616 , E_FAIL); /** @todo setError. */
10617
10618 Utf8Str stateFilePathFull = aSavedStateFile;
10619 int vrc = calculateFullPath(stateFilePathFull, stateFilePathFull);
10620 if (RT_FAILURE(vrc))
10621 return setError(VBOX_E_FILE_ERROR,
10622 tr("Invalid saved state file path '%ls' (%Rrc)"),
10623 aSavedStateFile,
10624 vrc);
10625
10626 mSSData->mStateFilePath = stateFilePathFull;
10627
10628 /* The below setMachineState() will detect the state transition and will
10629 * update the settings file */
10630
10631 return setMachineState(MachineState_Saved);
10632}
10633
10634STDMETHODIMP SessionMachine::PullGuestProperties(ComSafeArrayOut(BSTR, aNames),
10635 ComSafeArrayOut(BSTR, aValues),
10636 ComSafeArrayOut(LONG64, aTimestamps),
10637 ComSafeArrayOut(BSTR, aFlags))
10638{
10639 LogFlowThisFunc(("\n"));
10640
10641#ifdef VBOX_WITH_GUEST_PROPS
10642 using namespace guestProp;
10643
10644 AutoCaller autoCaller(this);
10645 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10646
10647 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
10648
10649 AssertReturn(!ComSafeArrayOutIsNull(aNames), E_POINTER);
10650 AssertReturn(!ComSafeArrayOutIsNull(aValues), E_POINTER);
10651 AssertReturn(!ComSafeArrayOutIsNull(aTimestamps), E_POINTER);
10652 AssertReturn(!ComSafeArrayOutIsNull(aFlags), E_POINTER);
10653
10654 size_t cEntries = mHWData->mGuestProperties.size();
10655 com::SafeArray<BSTR> names(cEntries);
10656 com::SafeArray<BSTR> values(cEntries);
10657 com::SafeArray<LONG64> timestamps(cEntries);
10658 com::SafeArray<BSTR> flags(cEntries);
10659 unsigned i = 0;
10660 for (HWData::GuestPropertyList::iterator it = mHWData->mGuestProperties.begin();
10661 it != mHWData->mGuestProperties.end();
10662 ++it)
10663 {
10664 char szFlags[MAX_FLAGS_LEN + 1];
10665 it->strName.cloneTo(&names[i]);
10666 it->strValue.cloneTo(&values[i]);
10667 timestamps[i] = it->mTimestamp;
10668 /* If it is NULL, keep it NULL. */
10669 if (it->mFlags)
10670 {
10671 writeFlags(it->mFlags, szFlags);
10672 Bstr(szFlags).cloneTo(&flags[i]);
10673 }
10674 else
10675 flags[i] = NULL;
10676 ++i;
10677 }
10678 names.detachTo(ComSafeArrayOutArg(aNames));
10679 values.detachTo(ComSafeArrayOutArg(aValues));
10680 timestamps.detachTo(ComSafeArrayOutArg(aTimestamps));
10681 flags.detachTo(ComSafeArrayOutArg(aFlags));
10682 return S_OK;
10683#else
10684 ReturnComNotImplemented();
10685#endif
10686}
10687
10688STDMETHODIMP SessionMachine::PushGuestProperty(IN_BSTR aName,
10689 IN_BSTR aValue,
10690 LONG64 aTimestamp,
10691 IN_BSTR aFlags)
10692{
10693 LogFlowThisFunc(("\n"));
10694
10695#ifdef VBOX_WITH_GUEST_PROPS
10696 using namespace guestProp;
10697
10698 CheckComArgStrNotEmptyOrNull(aName);
10699 if (aValue != NULL && (!VALID_PTR(aValue) || !VALID_PTR(aFlags)))
10700 return E_POINTER; /* aValue can be NULL to indicate deletion */
10701
10702 try
10703 {
10704 /*
10705 * Convert input up front.
10706 */
10707 Utf8Str utf8Name(aName);
10708 uint32_t fFlags = NILFLAG;
10709 if (aFlags)
10710 {
10711 Utf8Str utf8Flags(aFlags);
10712 int vrc = validateFlags(utf8Flags.c_str(), &fFlags);
10713 AssertRCReturn(vrc, E_INVALIDARG);
10714 }
10715
10716 /*
10717 * Now grab the object lock, validate the state and do the update.
10718 */
10719 AutoCaller autoCaller(this);
10720 if (FAILED(autoCaller.rc())) return autoCaller.rc();
10721
10722 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10723
10724 switch (mData->mMachineState)
10725 {
10726 case MachineState_Paused:
10727 case MachineState_Running:
10728 case MachineState_Teleporting:
10729 case MachineState_TeleportingPausedVM:
10730 case MachineState_LiveSnapshotting:
10731 case MachineState_DeletingSnapshotOnline:
10732 case MachineState_DeletingSnapshotPaused:
10733 case MachineState_Saving:
10734 break;
10735
10736 default:
10737#ifndef DEBUG_sunlover
10738 AssertMsgFailedReturn(("%s\n", Global::stringifyMachineState(mData->mMachineState)),
10739 VBOX_E_INVALID_VM_STATE);
10740#else
10741 return VBOX_E_INVALID_VM_STATE;
10742#endif
10743 }
10744
10745 setModified(IsModified_MachineData);
10746 mHWData.backup();
10747
10748 /** @todo r=bird: The careful memory handling doesn't work out here because
10749 * the catch block won't undo any damange we've done. So, if push_back throws
10750 * bad_alloc then you've lost the value.
10751 *
10752 * Another thing. Doing a linear search here isn't extremely efficient, esp.
10753 * since values that changes actually bubbles to the end of the list. Using
10754 * something that has an efficient lookup and can tollerate a bit of updates
10755 * would be nice. RTStrSpace is one suggestion (it's not perfect). Some
10756 * combination of RTStrCache (for sharing names and getting uniqueness into
10757 * the bargain) and hash/tree is another. */
10758 for (HWData::GuestPropertyList::iterator iter = mHWData->mGuestProperties.begin();
10759 iter != mHWData->mGuestProperties.end();
10760 ++iter)
10761 if (utf8Name == iter->strName)
10762 {
10763 mHWData->mGuestProperties.erase(iter);
10764 mData->mGuestPropertiesModified = TRUE;
10765 break;
10766 }
10767 if (aValue != NULL)
10768 {
10769 HWData::GuestProperty property = { aName, aValue, aTimestamp, fFlags };
10770 mHWData->mGuestProperties.push_back(property);
10771 mData->mGuestPropertiesModified = TRUE;
10772 }
10773
10774 /*
10775 * Send a callback notification if appropriate
10776 */
10777 if ( mHWData->mGuestPropertyNotificationPatterns.isEmpty()
10778 || RTStrSimplePatternMultiMatch(mHWData->mGuestPropertyNotificationPatterns.c_str(),
10779 RTSTR_MAX,
10780 utf8Name.c_str(),
10781 RTSTR_MAX, NULL)
10782 )
10783 {
10784 alock.leave();
10785
10786 mParent->onGuestPropertyChange(mData->mUuid,
10787 aName,
10788 aValue,
10789 aFlags);
10790 }
10791 }
10792 catch (...)
10793 {
10794 return VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
10795 }
10796 return S_OK;
10797#else
10798 ReturnComNotImplemented();
10799#endif
10800}
10801
10802// public methods only for internal purposes
10803/////////////////////////////////////////////////////////////////////////////
10804
10805/**
10806 * Called from the client watcher thread to check for expected or unexpected
10807 * death of the client process that has a direct session to this machine.
10808 *
10809 * On Win32 and on OS/2, this method is called only when we've got the
10810 * mutex (i.e. the client has either died or terminated normally) so it always
10811 * returns @c true (the client is terminated, the session machine is
10812 * uninitialized).
10813 *
10814 * On other platforms, the method returns @c true if the client process has
10815 * terminated normally or abnormally and the session machine was uninitialized,
10816 * and @c false if the client process is still alive.
10817 *
10818 * @note Locks this object for writing.
10819 */
10820bool SessionMachine::checkForDeath()
10821{
10822 Uninit::Reason reason;
10823 bool terminated = false;
10824
10825 /* Enclose autoCaller with a block because calling uninit() from under it
10826 * will deadlock. */
10827 {
10828 AutoCaller autoCaller(this);
10829 if (!autoCaller.isOk())
10830 {
10831 /* return true if not ready, to cause the client watcher to exclude
10832 * the corresponding session from watching */
10833 LogFlowThisFunc(("Already uninitialized!\n"));
10834 return true;
10835 }
10836
10837 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
10838
10839 /* Determine the reason of death: if the session state is Closing here,
10840 * everything is fine. Otherwise it means that the client did not call
10841 * OnSessionEnd() before it released the IPC semaphore. This may happen
10842 * either because the client process has abnormally terminated, or
10843 * because it simply forgot to call ISession::Close() before exiting. We
10844 * threat the latter also as an abnormal termination (see
10845 * Session::uninit() for details). */
10846 reason = mData->mSession.mState == SessionState_Unlocking ?
10847 Uninit::Normal :
10848 Uninit::Abnormal;
10849
10850#if defined(RT_OS_WINDOWS)
10851
10852 AssertMsg(mIPCSem, ("semaphore must be created"));
10853
10854 /* release the IPC mutex */
10855 ::ReleaseMutex(mIPCSem);
10856
10857 terminated = true;
10858
10859#elif defined(RT_OS_OS2)
10860
10861 AssertMsg(mIPCSem, ("semaphore must be created"));
10862
10863 /* release the IPC mutex */
10864 ::DosReleaseMutexSem(mIPCSem);
10865
10866 terminated = true;
10867
10868#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
10869
10870 AssertMsg(mIPCSem >= 0, ("semaphore must be created"));
10871
10872 int val = ::semctl(mIPCSem, 0, GETVAL);
10873 if (val > 0)
10874 {
10875 /* the semaphore is signaled, meaning the session is terminated */
10876 terminated = true;
10877 }
10878
10879#else
10880# error "Port me!"
10881#endif
10882
10883 } /* AutoCaller block */
10884
10885 if (terminated)
10886 uninit(reason);
10887
10888 return terminated;
10889}
10890
10891/**
10892 * @note Locks this object for reading.
10893 */
10894HRESULT SessionMachine::onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter)
10895{
10896 LogFlowThisFunc(("\n"));
10897
10898 AutoCaller autoCaller(this);
10899 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10900
10901 ComPtr<IInternalSessionControl> directControl;
10902 {
10903 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
10904 directControl = mData->mSession.mDirectControl;
10905 }
10906
10907 /* ignore notifications sent after #OnSessionEnd() is called */
10908 if (!directControl)
10909 return S_OK;
10910
10911 return directControl->OnNetworkAdapterChange(networkAdapter, changeAdapter);
10912}
10913
10914/**
10915 * @note Locks this object for reading.
10916 */
10917HRESULT SessionMachine::onSerialPortChange(ISerialPort *serialPort)
10918{
10919 LogFlowThisFunc(("\n"));
10920
10921 AutoCaller autoCaller(this);
10922 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10923
10924 ComPtr<IInternalSessionControl> directControl;
10925 {
10926 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
10927 directControl = mData->mSession.mDirectControl;
10928 }
10929
10930 /* ignore notifications sent after #OnSessionEnd() is called */
10931 if (!directControl)
10932 return S_OK;
10933
10934 return directControl->OnSerialPortChange(serialPort);
10935}
10936
10937/**
10938 * @note Locks this object for reading.
10939 */
10940HRESULT SessionMachine::onParallelPortChange(IParallelPort *parallelPort)
10941{
10942 LogFlowThisFunc(("\n"));
10943
10944 AutoCaller autoCaller(this);
10945 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10946
10947 ComPtr<IInternalSessionControl> directControl;
10948 {
10949 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
10950 directControl = mData->mSession.mDirectControl;
10951 }
10952
10953 /* ignore notifications sent after #OnSessionEnd() is called */
10954 if (!directControl)
10955 return S_OK;
10956
10957 return directControl->OnParallelPortChange(parallelPort);
10958}
10959
10960/**
10961 * @note Locks this object for reading.
10962 */
10963HRESULT SessionMachine::onStorageControllerChange()
10964{
10965 LogFlowThisFunc(("\n"));
10966
10967 AutoCaller autoCaller(this);
10968 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10969
10970 ComPtr<IInternalSessionControl> directControl;
10971 {
10972 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
10973 directControl = mData->mSession.mDirectControl;
10974 }
10975
10976 /* ignore notifications sent after #OnSessionEnd() is called */
10977 if (!directControl)
10978 return S_OK;
10979
10980 return directControl->OnStorageControllerChange();
10981}
10982
10983/**
10984 * @note Locks this object for reading.
10985 */
10986HRESULT SessionMachine::onMediumChange(IMediumAttachment *aAttachment, BOOL aForce)
10987{
10988 LogFlowThisFunc(("\n"));
10989
10990 AutoCaller autoCaller(this);
10991 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
10992
10993 ComPtr<IInternalSessionControl> directControl;
10994 {
10995 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
10996 directControl = mData->mSession.mDirectControl;
10997 }
10998
10999 /* ignore notifications sent after #OnSessionEnd() is called */
11000 if (!directControl)
11001 return S_OK;
11002
11003 return directControl->OnMediumChange(aAttachment, aForce);
11004}
11005
11006/**
11007 * @note Locks this object for reading.
11008 */
11009HRESULT SessionMachine::onCPUChange(ULONG aCPU, BOOL aRemove)
11010{
11011 LogFlowThisFunc(("\n"));
11012
11013 AutoCaller autoCaller(this);
11014 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
11015
11016 ComPtr<IInternalSessionControl> directControl;
11017 {
11018 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11019 directControl = mData->mSession.mDirectControl;
11020 }
11021
11022 /* ignore notifications sent after #OnSessionEnd() is called */
11023 if (!directControl)
11024 return S_OK;
11025
11026 return directControl->OnCPUChange(aCPU, aRemove);
11027}
11028
11029HRESULT SessionMachine::onCPUExecutionCapChange(ULONG aExecutionCap)
11030{
11031 LogFlowThisFunc(("\n"));
11032
11033 AutoCaller autoCaller(this);
11034 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
11035
11036 ComPtr<IInternalSessionControl> directControl;
11037 {
11038 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11039 directControl = mData->mSession.mDirectControl;
11040 }
11041
11042 /* ignore notifications sent after #OnSessionEnd() is called */
11043 if (!directControl)
11044 return S_OK;
11045
11046 return directControl->OnCPUExecutionCapChange(aExecutionCap);
11047}
11048
11049/**
11050 * @note Locks this object for reading.
11051 */
11052HRESULT SessionMachine::onVRDPServerChange(BOOL aRestart)
11053{
11054 LogFlowThisFunc(("\n"));
11055
11056 AutoCaller autoCaller(this);
11057 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11058
11059 ComPtr<IInternalSessionControl> directControl;
11060 {
11061 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11062 directControl = mData->mSession.mDirectControl;
11063 }
11064
11065 /* ignore notifications sent after #OnSessionEnd() is called */
11066 if (!directControl)
11067 return S_OK;
11068
11069 return directControl->OnVRDPServerChange(aRestart);
11070}
11071
11072/**
11073 * @note Locks this object for reading.
11074 */
11075HRESULT SessionMachine::onUSBControllerChange()
11076{
11077 LogFlowThisFunc(("\n"));
11078
11079 AutoCaller autoCaller(this);
11080 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11081
11082 ComPtr<IInternalSessionControl> directControl;
11083 {
11084 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11085 directControl = mData->mSession.mDirectControl;
11086 }
11087
11088 /* ignore notifications sent after #OnSessionEnd() is called */
11089 if (!directControl)
11090 return S_OK;
11091
11092 return directControl->OnUSBControllerChange();
11093}
11094
11095/**
11096 * @note Locks this object for reading.
11097 */
11098HRESULT SessionMachine::onSharedFolderChange()
11099{
11100 LogFlowThisFunc(("\n"));
11101
11102 AutoCaller autoCaller(this);
11103 AssertComRCReturnRC(autoCaller.rc());
11104
11105 ComPtr<IInternalSessionControl> directControl;
11106 {
11107 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11108 directControl = mData->mSession.mDirectControl;
11109 }
11110
11111 /* ignore notifications sent after #OnSessionEnd() is called */
11112 if (!directControl)
11113 return S_OK;
11114
11115 return directControl->OnSharedFolderChange(FALSE /* aGlobal */);
11116}
11117
11118/**
11119 * Returns @c true if this machine's USB controller reports it has a matching
11120 * filter for the given USB device and @c false otherwise.
11121 *
11122 * @note Caller must have requested machine read lock.
11123 */
11124bool SessionMachine::hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
11125{
11126 AutoCaller autoCaller(this);
11127 /* silently return if not ready -- this method may be called after the
11128 * direct machine session has been called */
11129 if (!autoCaller.isOk())
11130 return false;
11131
11132
11133#ifdef VBOX_WITH_USB
11134 switch (mData->mMachineState)
11135 {
11136 case MachineState_Starting:
11137 case MachineState_Restoring:
11138 case MachineState_TeleportingIn:
11139 case MachineState_Paused:
11140 case MachineState_Running:
11141 /** @todo Live Migration: snapshoting & teleporting. Need to fend things of
11142 * elsewhere... */
11143 return mUSBController->hasMatchingFilter(aDevice, aMaskedIfs);
11144 default: break;
11145 }
11146#else
11147 NOREF(aDevice);
11148 NOREF(aMaskedIfs);
11149#endif
11150 return false;
11151}
11152
11153/**
11154 * @note The calls shall hold no locks. Will temporarily lock this object for reading.
11155 */
11156HRESULT SessionMachine::onUSBDeviceAttach(IUSBDevice *aDevice,
11157 IVirtualBoxErrorInfo *aError,
11158 ULONG aMaskedIfs)
11159{
11160 LogFlowThisFunc(("\n"));
11161
11162 AutoCaller autoCaller(this);
11163
11164 /* This notification may happen after the machine object has been
11165 * uninitialized (the session was closed), so don't assert. */
11166 if (FAILED(autoCaller.rc())) return autoCaller.rc();
11167
11168 ComPtr<IInternalSessionControl> directControl;
11169 {
11170 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11171 directControl = mData->mSession.mDirectControl;
11172 }
11173
11174 /* fail on notifications sent after #OnSessionEnd() is called, it is
11175 * expected by the caller */
11176 if (!directControl)
11177 return E_FAIL;
11178
11179 /* No locks should be held at this point. */
11180 AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
11181 AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
11182
11183 return directControl->OnUSBDeviceAttach(aDevice, aError, aMaskedIfs);
11184}
11185
11186/**
11187 * @note The calls shall hold no locks. Will temporarily lock this object for reading.
11188 */
11189HRESULT SessionMachine::onUSBDeviceDetach(IN_BSTR aId,
11190 IVirtualBoxErrorInfo *aError)
11191{
11192 LogFlowThisFunc(("\n"));
11193
11194 AutoCaller autoCaller(this);
11195
11196 /* This notification may happen after the machine object has been
11197 * uninitialized (the session was closed), so don't assert. */
11198 if (FAILED(autoCaller.rc())) return autoCaller.rc();
11199
11200 ComPtr<IInternalSessionControl> directControl;
11201 {
11202 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11203 directControl = mData->mSession.mDirectControl;
11204 }
11205
11206 /* fail on notifications sent after #OnSessionEnd() is called, it is
11207 * expected by the caller */
11208 if (!directControl)
11209 return E_FAIL;
11210
11211 /* No locks should be held at this point. */
11212 AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
11213 AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
11214
11215 return directControl->OnUSBDeviceDetach(aId, aError);
11216}
11217
11218// protected methods
11219/////////////////////////////////////////////////////////////////////////////
11220
11221/**
11222 * Helper method to finalize saving the state.
11223 *
11224 * @note Must be called from under this object's lock.
11225 *
11226 * @param aSuccess TRUE if the snapshot has been taken successfully
11227 *
11228 * @note Locks mParent + this objects for writing.
11229 */
11230HRESULT SessionMachine::endSavingState(BOOL aSuccess)
11231{
11232 LogFlowThisFuncEnter();
11233
11234 AutoCaller autoCaller(this);
11235 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11236
11237 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11238
11239 HRESULT rc = S_OK;
11240
11241 if (aSuccess)
11242 {
11243 mSSData->mStateFilePath = mSnapshotData.mStateFilePath;
11244
11245 /* save all VM settings */
11246 rc = saveSettings(NULL);
11247 // no need to check whether VirtualBox.xml needs saving also since
11248 // we can't have a name change pending at this point
11249 }
11250 else
11251 {
11252 /* delete the saved state file (it might have been already created) */
11253 RTFileDelete(mSnapshotData.mStateFilePath.c_str());
11254 }
11255
11256 /* remove the completed progress object */
11257 mParent->removeProgress(mSnapshotData.mProgressId.ref());
11258
11259 /* clear out the temporary saved state data */
11260 mSnapshotData.mLastState = MachineState_Null;
11261 mSnapshotData.mProgressId.clear();
11262 mSnapshotData.mStateFilePath.setNull();
11263
11264 LogFlowThisFuncLeave();
11265 return rc;
11266}
11267
11268/**
11269 * Locks the attached media.
11270 *
11271 * All attached hard disks are locked for writing and DVD/floppy are locked for
11272 * reading. Parents of attached hard disks (if any) are locked for reading.
11273 *
11274 * This method also performs accessibility check of all media it locks: if some
11275 * media is inaccessible, the method will return a failure and a bunch of
11276 * extended error info objects per each inaccessible medium.
11277 *
11278 * Note that this method is atomic: if it returns a success, all media are
11279 * locked as described above; on failure no media is locked at all (all
11280 * succeeded individual locks will be undone).
11281 *
11282 * This method is intended to be called when the machine is in Starting or
11283 * Restoring state and asserts otherwise.
11284 *
11285 * The locks made by this method must be undone by calling #unlockMedia() when
11286 * no more needed.
11287 */
11288HRESULT SessionMachine::lockMedia()
11289{
11290 AutoCaller autoCaller(this);
11291 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11292
11293 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11294
11295 AssertReturn( mData->mMachineState == MachineState_Starting
11296 || mData->mMachineState == MachineState_Restoring
11297 || mData->mMachineState == MachineState_TeleportingIn, E_FAIL);
11298 /* bail out if trying to lock things with already set up locking */
11299 AssertReturn(mData->mSession.mLockedMedia.IsEmpty(), E_FAIL);
11300
11301 MultiResult mrc(S_OK);
11302
11303 /* Collect locking information for all medium objects attached to the VM. */
11304 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
11305 it != mMediaData->mAttachments.end();
11306 ++it)
11307 {
11308 MediumAttachment* pAtt = *it;
11309 DeviceType_T devType = pAtt->getType();
11310 Medium *pMedium = pAtt->getMedium();
11311
11312 MediumLockList *pMediumLockList(new MediumLockList());
11313 // There can be attachments without a medium (floppy/dvd), and thus
11314 // it's impossible to create a medium lock list. It still makes sense
11315 // to have the empty medium lock list in the map in case a medium is
11316 // attached later.
11317 if (pMedium != NULL)
11318 {
11319 MediumType_T mediumType = pMedium->getType();
11320 bool fIsReadOnlyImage = devType == DeviceType_DVD
11321 || mediumType == MediumType_Shareable;
11322 bool fIsVitalImage = (devType == DeviceType_HardDisk);
11323
11324 mrc = pMedium->createMediumLockList(fIsVitalImage /* fFailIfInaccessible */,
11325 !fIsReadOnlyImage /* fMediumLockWrite */,
11326 NULL,
11327 *pMediumLockList);
11328 if (FAILED(mrc))
11329 {
11330 delete pMediumLockList;
11331 mData->mSession.mLockedMedia.Clear();
11332 break;
11333 }
11334 }
11335
11336 HRESULT rc = mData->mSession.mLockedMedia.Insert(pAtt, pMediumLockList);
11337 if (FAILED(rc))
11338 {
11339 mData->mSession.mLockedMedia.Clear();
11340 mrc = setError(rc,
11341 tr("Collecting locking information for all attached media failed"));
11342 break;
11343 }
11344 }
11345
11346 if (SUCCEEDED(mrc))
11347 {
11348 /* Now lock all media. If this fails, nothing is locked. */
11349 HRESULT rc = mData->mSession.mLockedMedia.Lock();
11350 if (FAILED(rc))
11351 {
11352 mrc = setError(rc,
11353 tr("Locking of attached media failed"));
11354 }
11355 }
11356
11357 return mrc;
11358}
11359
11360/**
11361 * Undoes the locks made by by #lockMedia().
11362 */
11363void SessionMachine::unlockMedia()
11364{
11365 AutoCaller autoCaller(this);
11366 AssertComRCReturnVoid(autoCaller.rc());
11367
11368 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11369
11370 /* we may be holding important error info on the current thread;
11371 * preserve it */
11372 ErrorInfoKeeper eik;
11373
11374 HRESULT rc = mData->mSession.mLockedMedia.Clear();
11375 AssertComRC(rc);
11376}
11377
11378/**
11379 * Helper to change the machine state (reimplementation).
11380 *
11381 * @note Locks this object for writing.
11382 */
11383HRESULT SessionMachine::setMachineState(MachineState_T aMachineState)
11384{
11385 LogFlowThisFuncEnter();
11386 LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
11387
11388 AutoCaller autoCaller(this);
11389 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11390
11391 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
11392
11393 MachineState_T oldMachineState = mData->mMachineState;
11394
11395 AssertMsgReturn(oldMachineState != aMachineState,
11396 ("oldMachineState=%s, aMachineState=%s\n",
11397 Global::stringifyMachineState(oldMachineState), Global::stringifyMachineState(aMachineState)),
11398 E_FAIL);
11399
11400 HRESULT rc = S_OK;
11401
11402 int stsFlags = 0;
11403 bool deleteSavedState = false;
11404
11405 /* detect some state transitions */
11406
11407 if ( ( oldMachineState == MachineState_Saved
11408 && aMachineState == MachineState_Restoring)
11409 || ( ( oldMachineState == MachineState_PoweredOff
11410 || oldMachineState == MachineState_Teleported
11411 || oldMachineState == MachineState_Aborted
11412 )
11413 && ( aMachineState == MachineState_TeleportingIn
11414 || aMachineState == MachineState_Starting
11415 )
11416 )
11417 )
11418 {
11419 /* The EMT thread is about to start */
11420
11421 /* Nothing to do here for now... */
11422
11423 /// @todo NEWMEDIA don't let mDVDDrive and other children
11424 /// change anything when in the Starting/Restoring state
11425 }
11426 else if ( ( oldMachineState == MachineState_Running
11427 || oldMachineState == MachineState_Paused
11428 || oldMachineState == MachineState_Teleporting
11429 || oldMachineState == MachineState_LiveSnapshotting
11430 || oldMachineState == MachineState_Stuck
11431 || oldMachineState == MachineState_Starting
11432 || oldMachineState == MachineState_Stopping
11433 || oldMachineState == MachineState_Saving
11434 || oldMachineState == MachineState_Restoring
11435 || oldMachineState == MachineState_TeleportingPausedVM
11436 || oldMachineState == MachineState_TeleportingIn
11437 )
11438 && ( aMachineState == MachineState_PoweredOff
11439 || aMachineState == MachineState_Saved
11440 || aMachineState == MachineState_Teleported
11441 || aMachineState == MachineState_Aborted
11442 )
11443 /* ignore PoweredOff->Saving->PoweredOff transition when taking a
11444 * snapshot */
11445 && ( mSnapshotData.mSnapshot.isNull()
11446 || mSnapshotData.mLastState >= MachineState_Running /** @todo Live Migration: clean up (lazy bird) */
11447 )
11448 )
11449 {
11450 /* The EMT thread has just stopped, unlock attached media. Note that as
11451 * opposed to locking that is done from Console, we do unlocking here
11452 * because the VM process may have aborted before having a chance to
11453 * properly unlock all media it locked. */
11454
11455 unlockMedia();
11456 }
11457
11458 if (oldMachineState == MachineState_Restoring)
11459 {
11460 if (aMachineState != MachineState_Saved)
11461 {
11462 /*
11463 * delete the saved state file once the machine has finished
11464 * restoring from it (note that Console sets the state from
11465 * Restoring to Saved if the VM couldn't restore successfully,
11466 * to give the user an ability to fix an error and retry --
11467 * we keep the saved state file in this case)
11468 */
11469 deleteSavedState = true;
11470 }
11471 }
11472 else if ( oldMachineState == MachineState_Saved
11473 && ( aMachineState == MachineState_PoweredOff
11474 || aMachineState == MachineState_Aborted
11475 || aMachineState == MachineState_Teleported
11476 )
11477 )
11478 {
11479 /*
11480 * delete the saved state after Console::ForgetSavedState() is called
11481 * or if the VM process (owning a direct VM session) crashed while the
11482 * VM was Saved
11483 */
11484
11485 /// @todo (dmik)
11486 // Not sure that deleting the saved state file just because of the
11487 // client death before it attempted to restore the VM is a good
11488 // thing. But when it crashes we need to go to the Aborted state
11489 // which cannot have the saved state file associated... The only
11490 // way to fix this is to make the Aborted condition not a VM state
11491 // but a bool flag: i.e., when a crash occurs, set it to true and
11492 // change the state to PoweredOff or Saved depending on the
11493 // saved state presence.
11494
11495 deleteSavedState = true;
11496 mData->mCurrentStateModified = TRUE;
11497 stsFlags |= SaveSTS_CurStateModified;
11498 }
11499
11500 if ( aMachineState == MachineState_Starting
11501 || aMachineState == MachineState_Restoring
11502 || aMachineState == MachineState_TeleportingIn
11503 )
11504 {
11505 /* set the current state modified flag to indicate that the current
11506 * state is no more identical to the state in the
11507 * current snapshot */
11508 if (!mData->mCurrentSnapshot.isNull())
11509 {
11510 mData->mCurrentStateModified = TRUE;
11511 stsFlags |= SaveSTS_CurStateModified;
11512 }
11513 }
11514
11515 if (deleteSavedState)
11516 {
11517 if (mRemoveSavedState)
11518 {
11519 Assert(!mSSData->mStateFilePath.isEmpty());
11520 RTFileDelete(mSSData->mStateFilePath.c_str());
11521 }
11522 mSSData->mStateFilePath.setNull();
11523 stsFlags |= SaveSTS_StateFilePath;
11524 }
11525
11526 /* redirect to the underlying peer machine */
11527 mPeer->setMachineState(aMachineState);
11528
11529 if ( aMachineState == MachineState_PoweredOff
11530 || aMachineState == MachineState_Teleported
11531 || aMachineState == MachineState_Aborted
11532 || aMachineState == MachineState_Saved)
11533 {
11534 /* the machine has stopped execution
11535 * (or the saved state file was adopted) */
11536 stsFlags |= SaveSTS_StateTimeStamp;
11537 }
11538
11539 if ( ( oldMachineState == MachineState_PoweredOff
11540 || oldMachineState == MachineState_Aborted
11541 || oldMachineState == MachineState_Teleported
11542 )
11543 && aMachineState == MachineState_Saved)
11544 {
11545 /* the saved state file was adopted */
11546 Assert(!mSSData->mStateFilePath.isEmpty());
11547 stsFlags |= SaveSTS_StateFilePath;
11548 }
11549
11550#ifdef VBOX_WITH_GUEST_PROPS
11551 if ( aMachineState == MachineState_PoweredOff
11552 || aMachineState == MachineState_Aborted
11553 || aMachineState == MachineState_Teleported)
11554 {
11555 /* Make sure any transient guest properties get removed from the
11556 * property store on shutdown. */
11557
11558 HWData::GuestPropertyList::iterator it;
11559 BOOL fNeedsSaving = mData->mGuestPropertiesModified;
11560 if (!fNeedsSaving)
11561 for (it = mHWData->mGuestProperties.begin();
11562 it != mHWData->mGuestProperties.end(); ++it)
11563 if (it->mFlags & guestProp::TRANSIENT)
11564 {
11565 fNeedsSaving = true;
11566 break;
11567 }
11568 if (fNeedsSaving)
11569 {
11570 mData->mCurrentStateModified = TRUE;
11571 stsFlags |= SaveSTS_CurStateModified;
11572 SaveSettings(); // @todo r=dj why the public method? why first SaveSettings and then saveStateSettings?
11573 }
11574 }
11575#endif
11576
11577 rc = saveStateSettings(stsFlags);
11578
11579 if ( ( oldMachineState != MachineState_PoweredOff
11580 && oldMachineState != MachineState_Aborted
11581 && oldMachineState != MachineState_Teleported
11582 )
11583 && ( aMachineState == MachineState_PoweredOff
11584 || aMachineState == MachineState_Aborted
11585 || aMachineState == MachineState_Teleported
11586 )
11587 )
11588 {
11589 /* we've been shut down for any reason */
11590 /* no special action so far */
11591 }
11592
11593 LogFlowThisFunc(("rc=%Rhrc [%s]\n", rc, Global::stringifyMachineState(mData->mMachineState) ));
11594 LogFlowThisFuncLeave();
11595 return rc;
11596}
11597
11598/**
11599 * Sends the current machine state value to the VM process.
11600 *
11601 * @note Locks this object for reading, then calls a client process.
11602 */
11603HRESULT SessionMachine::updateMachineStateOnClient()
11604{
11605 AutoCaller autoCaller(this);
11606 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
11607
11608 ComPtr<IInternalSessionControl> directControl;
11609 {
11610 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
11611 AssertReturn(!!mData, E_FAIL);
11612 directControl = mData->mSession.mDirectControl;
11613
11614 /* directControl may be already set to NULL here in #OnSessionEnd()
11615 * called too early by the direct session process while there is still
11616 * some operation (like deleting the snapshot) in progress. The client
11617 * process in this case is waiting inside Session::close() for the
11618 * "end session" process object to complete, while #uninit() called by
11619 * #checkForDeath() on the Watcher thread is waiting for the pending
11620 * operation to complete. For now, we accept this inconsitent behavior
11621 * and simply do nothing here. */
11622
11623 if (mData->mSession.mState == SessionState_Unlocking)
11624 return S_OK;
11625
11626 AssertReturn(!directControl.isNull(), E_FAIL);
11627 }
11628
11629 return directControl->UpdateMachineState(mData->mMachineState);
11630}
Note: See TracBrowser for help on using the repository browser.

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