SystemPropertiesImpl.cpp@ 58043

Last change on this file since 58043 was 57524, checked in by vboxsync, 9 years ago
Main: NVMe integration
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.9 KB

Line
1	/* $Id: SystemPropertiesImpl.cpp 57524 2015-08-25 10:20:15Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 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	#include "SystemPropertiesImpl.h"
19	#include "VirtualBoxImpl.h"
20	#include "MachineImpl.h"
21	#ifdef VBOX_WITH_EXTPACK
22	# include "ExtPackManagerImpl.h"
23	#endif
24	#include "AutoCaller.h"
25	#include "Global.h"
26	#include "Logging.h"
27	#include "AutostartDb.h"
28
29	// generated header
30	#include "SchemaDefs.h"
31
32	#include <iprt/dir.h>
33	#include <iprt/ldr.h>
34	#include <iprt/path.h>
35	#include <iprt/string.h>
36	#include <iprt/cpp/utils.h>
37
38	#include <VBox/err.h>
39	#include <VBox/param.h>
40	#include <VBox/settings.h>
41	#include <VBox/vd.h>
42
43	// defines
44	/////////////////////////////////////////////////////////////////////////////
45
46	// constructor / destructor
47	/////////////////////////////////////////////////////////////////////////////
48
49	SystemProperties::SystemProperties()
50	: mParent(NULL),
51	m(new settings::SystemProperties)
52	{
53	}
54
55	SystemProperties::~SystemProperties()
56	{
57	delete m;
58	}
59
60
61	HRESULT SystemProperties::FinalConstruct()
62	{
63	return BaseFinalConstruct();
64	}
65
66	void SystemProperties::FinalRelease()
67	{
68	uninit();
69	BaseFinalRelease();
70	}
71
72	// public methods only for internal purposes
73	/////////////////////////////////////////////////////////////////////////////
74
75	/**
76	* Initializes the system information object.
77	*
78	* @returns COM result indicator
79	*/
80	HRESULT SystemProperties::init(VirtualBox *aParent)
81	{
82	LogFlowThisFunc(("aParent=%p\n", aParent));
83
84	ComAssertRet(aParent, E_FAIL);
85
86	/* Enclose the state transition NotReady->InInit->Ready */
87	AutoInitSpan autoInitSpan(this);
88	AssertReturn(autoInitSpan.isOk(), E_FAIL);
89
90	unconst(mParent) = aParent;
91
92	i_setDefaultMachineFolder(Utf8Str::Empty);
93	i_setLoggingLevel(Utf8Str::Empty);
94	i_setDefaultHardDiskFormat(Utf8Str::Empty);
95
96	i_setVRDEAuthLibrary(Utf8Str::Empty);
97	i_setDefaultVRDEExtPack(Utf8Str::Empty);
98
99	m->ulLogHistoryCount = 3;
100
101
102	/* On Windows and OS X, HW virtualization use isn't exclusive by
103	* default so that VT-x or AMD-V can be shared with other
104	* hypervisors without requiring user intervention.
105	* NB: See also SystemProperties constructor in settings.h
106	*/
107	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_WINDOWS)
108	m->fExclusiveHwVirt = false;
109	#else
110	m->fExclusiveHwVirt = true;
111	#endif
112
113	HRESULT rc = S_OK;
114
115	/* Fetch info of all available hd backends. */
116
117	/// @todo NEWMEDIA VDBackendInfo needs to be improved to let us enumerate
118	/// any number of backends
119
120	VDBACKENDINFO aVDInfo[100];
121	unsigned cEntries;
122	int vrc = VDBackendInfo(RT_ELEMENTS(aVDInfo), aVDInfo, &cEntries);
123	AssertRC(vrc);
124	if (RT_SUCCESS(vrc))
125	{
126	for (unsigned i = 0; i < cEntries; ++ i)
127	{
128	ComObjPtr<MediumFormat> hdf;
129	rc = hdf.createObject();
130	if (FAILED(rc)) break;
131
132	rc = hdf->init(&aVDInfo[i]);
133	if (FAILED(rc)) break;
134
135	m_llMediumFormats.push_back(hdf);
136	}
137	}
138
139	/* Confirm a successful initialization */
140	if (SUCCEEDED(rc))
141	autoInitSpan.setSucceeded();
142
143	return rc;
144	}
145
146	/**
147	* Uninitializes the instance and sets the ready flag to FALSE.
148	* Called either from FinalRelease() or by the parent when it gets destroyed.
149	*/
150	void SystemProperties::uninit()
151	{
152	LogFlowThisFunc(("\n"));
153
154	/* Enclose the state transition Ready->InUninit->NotReady */
155	AutoUninitSpan autoUninitSpan(this);
156	if (autoUninitSpan.uninitDone())
157	return;
158
159	unconst(mParent) = NULL;
160	}
161
162	// wrapped ISystemProperties properties
163	/////////////////////////////////////////////////////////////////////////////
164
165	HRESULT SystemProperties::getMinGuestRAM(ULONG *minRAM)
166
167	{
168	/* no need to lock, this is const */
169	AssertCompile(MM_RAM_MIN_IN_MB >= SchemaDefs::MinGuestRAM);
170	*minRAM = MM_RAM_MIN_IN_MB;
171
172	return S_OK;
173	}
174
175	HRESULT SystemProperties::getMaxGuestRAM(ULONG *maxRAM)
176	{
177	/* no need to lock, this is const */
178	AssertCompile(MM_RAM_MAX_IN_MB <= SchemaDefs::MaxGuestRAM);
179	ULONG maxRAMSys = MM_RAM_MAX_IN_MB;
180	ULONG maxRAMArch = maxRAMSys;
181	*maxRAM = RT_MIN(maxRAMSys, maxRAMArch);
182
183	return S_OK;
184	}
185
186	HRESULT SystemProperties::getMinGuestVRAM(ULONG *minVRAM)
187	{
188	/* no need to lock, this is const */
189	*minVRAM = SchemaDefs::MinGuestVRAM;
190
191	return S_OK;
192	}
193
194	HRESULT SystemProperties::getMaxGuestVRAM(ULONG *maxVRAM)
195	{
196	/* no need to lock, this is const */
197	*maxVRAM = SchemaDefs::MaxGuestVRAM;
198
199	return S_OK;
200	}
201
202	HRESULT SystemProperties::getMinGuestCPUCount(ULONG *minCPUCount)
203	{
204	/* no need to lock, this is const */
205	*minCPUCount = SchemaDefs::MinCPUCount; // VMM_MIN_CPU_COUNT
206
207	return S_OK;
208	}
209
210	HRESULT SystemProperties::getMaxGuestCPUCount(ULONG *maxCPUCount)
211	{
212	/* no need to lock, this is const */
213	*maxCPUCount = SchemaDefs::MaxCPUCount; // VMM_MAX_CPU_COUNT
214
215	return S_OK;
216	}
217
218	HRESULT SystemProperties::getMaxGuestMonitors(ULONG *maxMonitors)
219	{
220
221	/* no need to lock, this is const */
222	*maxMonitors = SchemaDefs::MaxGuestMonitors;
223
224	return S_OK;
225	}
226
227
228	HRESULT SystemProperties::getInfoVDSize(LONG64 *infoVDSize)
229	{
230	/*
231	* The BIOS supports currently 32 bit LBA numbers (implementing the full
232	* 48 bit range is in theory trivial, but the crappy compiler makes things
233	* more difficult). This translates to almost 2 TiBytes (to be on the safe
234	* side, the reported limit is 1 MiByte less than that, as the total number
235	* of sectors should fit in 32 bits, too), which should be enough for the
236	* moment. Since the MBR partition tables support only 32bit sector numbers
237	* and thus the BIOS can only boot from disks smaller than 2T this is a
238	* rather hard limit.
239	*
240	* The virtual ATA/SATA disks support complete LBA48, and SCSI supports
241	* LBA64 (almost, more like LBA55 in practice), so the theoretical maximum
242	* disk size is 128 PiByte/16 EiByte. The GUI works nicely with 6 orders
243	* of magnitude, but not with 11..13 orders of magnitude.
244	*/
245	/* no need to lock, this is const */
246	infoVDSize = 2 _1T - _1M;
247
248	return S_OK;
249	}
250
251
252	HRESULT SystemProperties::getSerialPortCount(ULONG *count)
253	{
254	/* no need to lock, this is const */
255	*count = SchemaDefs::SerialPortCount;
256
257	return S_OK;
258	}
259
260
261	HRESULT SystemProperties::getParallelPortCount(ULONG *count)
262	{
263	/* no need to lock, this is const */
264	*count = SchemaDefs::ParallelPortCount;
265
266	return S_OK;
267	}
268
269
270	HRESULT SystemProperties::getMaxBootPosition(ULONG *aMaxBootPosition)
271	{
272	/* no need to lock, this is const */
273	*aMaxBootPosition = SchemaDefs::MaxBootPosition;
274
275	return S_OK;
276	}
277
278
279	HRESULT SystemProperties::getRawModeSupported(BOOL *aRawModeSupported)
280	{
281	#ifdef VBOX_WITH_RAW_MODE
282	*aRawModeSupported = TRUE;
283	#else
284	*aRawModeSupported = FALSE;
285	#endif
286	return S_OK;
287	}
288
289
290	HRESULT SystemProperties::getExclusiveHwVirt(BOOL *aExclusiveHwVirt)
291	{
292	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
293
294	*aExclusiveHwVirt = m->fExclusiveHwVirt;
295
296	return S_OK;
297	}
298
299	HRESULT SystemProperties::setExclusiveHwVirt(BOOL aExclusiveHwVirt)
300	{
301	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
302	m->fExclusiveHwVirt = !!aExclusiveHwVirt;
303	alock.release();
304
305	// VirtualBox::i_saveSettings() needs vbox write lock
306	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
307	HRESULT rc = mParent->i_saveSettings();
308
309	return rc;
310	}
311
312	HRESULT SystemProperties::getMaxNetworkAdapters(ChipsetType_T aChipset, ULONG *aMaxNetworkAdapters)
313	{
314	/* no need for locking, no state */
315	uint32_t uResult = Global::getMaxNetworkAdapters(aChipset);
316	if (uResult == 0)
317	AssertMsgFailed(("Invalid chipset type %d\n", aChipset));
318	*aMaxNetworkAdapters = uResult;
319	return S_OK;
320	}
321
322	HRESULT SystemProperties::getMaxNetworkAdaptersOfType(ChipsetType_T aChipset, NetworkAttachmentType_T aType, ULONG *count)
323	{
324	/* no need for locking, no state */
325	uint32_t uResult = Global::getMaxNetworkAdapters(aChipset);
326	if (uResult == 0)
327	AssertMsgFailed(("Invalid chipset type %d\n", aChipset));
328
329	switch (aType)
330	{
331	case NetworkAttachmentType_NAT:
332	case NetworkAttachmentType_Internal:
333	case NetworkAttachmentType_NATNetwork:
334	/* chipset default is OK */
335	break;
336	case NetworkAttachmentType_Bridged:
337	/* Maybe use current host interface count here? */
338	break;
339	case NetworkAttachmentType_HostOnly:
340	uResult = RT_MIN(uResult, 8);
341	break;
342	default:
343	AssertMsgFailed(("Unhandled attachment type %d\n", aType));
344	}
345
346	*count = uResult;
347
348	return S_OK;
349	}
350
351
352	HRESULT SystemProperties::getMaxDevicesPerPortForStorageBus(StorageBus_T aBus,
353	ULONG *aMaxDevicesPerPort)
354	{
355	/* no need to lock, this is const */
356	switch (aBus)
357	{
358	case StorageBus_SATA:
359	case StorageBus_SCSI:
360	case StorageBus_SAS:
361	case StorageBus_USB:
362	case StorageBus_PCIe:
363	{
364	/* SATA and both SCSI controllers only support one device per port. */
365	*aMaxDevicesPerPort = 1;
366	break;
367	}
368	case StorageBus_IDE:
369	case StorageBus_Floppy:
370	{
371	/* The IDE and Floppy controllers support 2 devices. One as master
372	* and one as slave (or floppy drive 0 and 1). */
373	*aMaxDevicesPerPort = 2;
374	break;
375	}
376	default:
377	AssertMsgFailed(("Invalid bus type %d\n", aBus));
378	}
379
380	return S_OK;
381	}
382
383	HRESULT SystemProperties::getMinPortCountForStorageBus(StorageBus_T aBus,
384	ULONG *aMinPortCount)
385	{
386	/* no need to lock, this is const */
387	switch (aBus)
388	{
389	case StorageBus_SATA:
390	case StorageBus_SAS:
391	case StorageBus_PCIe:
392	{
393	*aMinPortCount = 1;
394	break;
395	}
396	case StorageBus_SCSI:
397	{
398	*aMinPortCount = 16;
399	break;
400	}
401	case StorageBus_IDE:
402	{
403	*aMinPortCount = 2;
404	break;
405	}
406	case StorageBus_Floppy:
407	{
408	*aMinPortCount = 1;
409	break;
410	}
411	case StorageBus_USB:
412	{
413	*aMinPortCount = 8;
414	break;
415	}
416	default:
417	AssertMsgFailed(("Invalid bus type %d\n", aBus));
418	}
419
420	return S_OK;
421	}
422
423	HRESULT SystemProperties::getMaxPortCountForStorageBus(StorageBus_T aBus,
424	ULONG *aMaxPortCount)
425	{
426	/* no need to lock, this is const */
427	switch (aBus)
428	{
429	case StorageBus_SATA:
430	{
431	*aMaxPortCount = 30;
432	break;
433	}
434	case StorageBus_SCSI:
435	{
436	*aMaxPortCount = 16;
437	break;
438	}
439	case StorageBus_IDE:
440	{
441	*aMaxPortCount = 2;
442	break;
443	}
444	case StorageBus_Floppy:
445	{
446	*aMaxPortCount = 1;
447	break;
448	}
449	case StorageBus_SAS:
450	case StorageBus_PCIe:
451	{
452	*aMaxPortCount = 255;
453	break;
454	}
455	case StorageBus_USB:
456	{
457	*aMaxPortCount = 8;
458	break;
459	}
460	default:
461	AssertMsgFailed(("Invalid bus type %d\n", aBus));
462	}
463
464	return S_OK;
465	}
466
467	HRESULT SystemProperties::getMaxInstancesOfStorageBus(ChipsetType_T aChipset,
468	StorageBus_T aBus,
469	ULONG *aMaxInstances)
470	{
471	ULONG cCtrs = 0;
472
473	/* no need to lock, this is const */
474	switch (aBus)
475	{
476	case StorageBus_SATA:
477	case StorageBus_SCSI:
478	case StorageBus_SAS:
479	case StorageBus_PCIe:
480	cCtrs = aChipset == ChipsetType_ICH9 ? 8 : 1;
481	break;
482	case StorageBus_USB:
483	case StorageBus_IDE:
484	case StorageBus_Floppy:
485	{
486	cCtrs = 1;
487	break;
488	}
489	default:
490	AssertMsgFailed(("Invalid bus type %d\n", aBus));
491	}
492
493	*aMaxInstances = cCtrs;
494
495	return S_OK;
496	}
497
498	HRESULT SystemProperties::getDeviceTypesForStorageBus(StorageBus_T aBus,
499	std::vector<DeviceType_T> &aDeviceTypes)
500	{
501	aDeviceTypes.resize(0);
502
503	/* no need to lock, this is const */
504	switch (aBus)
505	{
506	case StorageBus_IDE:
507	case StorageBus_SATA:
508	case StorageBus_SCSI:
509	case StorageBus_SAS:
510	case StorageBus_USB:
511	{
512	aDeviceTypes.resize(2);
513	aDeviceTypes[0] = DeviceType_DVD;
514	aDeviceTypes[1] = DeviceType_HardDisk;
515	break;
516	}
517	case StorageBus_Floppy:
518	{
519	aDeviceTypes.resize(1);
520	aDeviceTypes[0] = DeviceType_Floppy;
521	break;
522	}
523	case StorageBus_PCIe:
524	{
525	aDeviceTypes.resize(1);
526	aDeviceTypes[0] = DeviceType_HardDisk;
527	break;
528	}
529	default:
530	AssertMsgFailed(("Invalid bus type %d\n", aBus));
531	}
532
533	return S_OK;
534	}
535
536	HRESULT SystemProperties::getDefaultIoCacheSettingForStorageController(StorageControllerType_T aControllerType,
537	BOOL *aEnabled)
538	{
539	/* no need to lock, this is const */
540	switch (aControllerType)
541	{
542	case StorageControllerType_LsiLogic:
543	case StorageControllerType_BusLogic:
544	case StorageControllerType_IntelAhci:
545	case StorageControllerType_LsiLogicSas:
546	case StorageControllerType_USB:
547	case StorageControllerType_NVMe:
548	*aEnabled = false;
549	break;
550	case StorageControllerType_PIIX3:
551	case StorageControllerType_PIIX4:
552	case StorageControllerType_ICH6:
553	case StorageControllerType_I82078:
554	*aEnabled = true;
555	break;
556	default:
557	AssertMsgFailed(("Invalid controller type %d\n", aControllerType));
558	}
559	return S_OK;
560	}
561
562	HRESULT SystemProperties::getStorageControllerHotplugCapable(StorageControllerType_T aControllerType,
563	BOOL *aHotplugCapable)
564	{
565	switch (aControllerType)
566	{
567	case StorageControllerType_IntelAhci:
568	case StorageControllerType_USB:
569	*aHotplugCapable = true;
570	break;
571	case StorageControllerType_LsiLogic:
572	case StorageControllerType_LsiLogicSas:
573	case StorageControllerType_BusLogic:
574	case StorageControllerType_NVMe:
575	case StorageControllerType_PIIX3:
576	case StorageControllerType_PIIX4:
577	case StorageControllerType_ICH6:
578	case StorageControllerType_I82078:
579	*aHotplugCapable = false;
580	break;
581	default:
582	AssertMsgFailedReturn(("Invalid controller type %d\n", aControllerType), E_FAIL);
583	}
584
585	return S_OK;
586	}
587
588	HRESULT SystemProperties::getMaxInstancesOfUSBControllerType(ChipsetType_T aChipset,
589	USBControllerType_T aType,
590	ULONG *aMaxInstances)
591	{
592	NOREF(aChipset);
593	ULONG cCtrs = 0;
594
595	/* no need to lock, this is const */
596	switch (aType)
597	{
598	case USBControllerType_OHCI:
599	case USBControllerType_EHCI:
600	case USBControllerType_XHCI:
601	{
602	cCtrs = 1;
603	break;
604	}
605	default:
606	AssertMsgFailed(("Invalid bus type %d\n", aType));
607	}
608
609	*aMaxInstances = cCtrs;
610
611	return S_OK;
612	}
613
614	HRESULT SystemProperties::getDefaultMachineFolder(com::Utf8Str &aDefaultMachineFolder)
615	{
616	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
617	aDefaultMachineFolder = m->strDefaultMachineFolder;
618	return S_OK;
619	}
620
621	HRESULT SystemProperties::setDefaultMachineFolder(const com::Utf8Str &aDefaultMachineFolder)
622	{
623	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
624	HRESULT rc = i_setDefaultMachineFolder(aDefaultMachineFolder);
625	alock.release();
626	if (SUCCEEDED(rc))
627	{
628	// VirtualBox::i_saveSettings() needs vbox write lock
629	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
630	rc = mParent->i_saveSettings();
631	}
632
633	return rc;
634	}
635
636	HRESULT SystemProperties::getLoggingLevel(com::Utf8Str &aLoggingLevel)
637	{
638	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
639
640	aLoggingLevel = m->strLoggingLevel;
641
642	if (aLoggingLevel.isEmpty())
643	aLoggingLevel = VBOXSVC_LOG_DEFAULT;
644
645	return S_OK;
646	}
647
648
649	HRESULT SystemProperties::setLoggingLevel(const com::Utf8Str &aLoggingLevel)
650	{
651	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
652	HRESULT rc = i_setLoggingLevel(aLoggingLevel);
653	alock.release();
654
655	if (SUCCEEDED(rc))
656	{
657	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
658	rc = mParent->i_saveSettings();
659	}
660	else
661	LogRel(("Cannot set passed logging level=%s, or the default one - Error=%Rhrc \n", aLoggingLevel.c_str(), rc));
662
663	return rc;
664	}
665
666	HRESULT SystemProperties::getMediumFormats(std::vector<ComPtr<IMediumFormat> > &aMediumFormats)
667	{
668	MediumFormatList mediumFormats(m_llMediumFormats);
669	aMediumFormats.resize(mediumFormats.size());
670	size_t i = 0;
671	for (MediumFormatList::const_iterator it = mediumFormats.begin(); it != mediumFormats.end(); ++it, ++i)
672	(*it).queryInterfaceTo(aMediumFormats[i].asOutParam());
673	return S_OK;
674	}
675
676	HRESULT SystemProperties::getDefaultHardDiskFormat(com::Utf8Str &aDefaultHardDiskFormat)
677	{
678	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
679	aDefaultHardDiskFormat = m->strDefaultHardDiskFormat;
680	return S_OK;
681	}
682
683
684	HRESULT SystemProperties::setDefaultHardDiskFormat(const com::Utf8Str &aDefaultHardDiskFormat)
685	{
686	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
687	HRESULT rc = i_setDefaultHardDiskFormat(aDefaultHardDiskFormat);
688	alock.release();
689	if (SUCCEEDED(rc))
690	{
691	// VirtualBox::i_saveSettings() needs vbox write lock
692	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
693	rc = mParent->i_saveSettings();
694	}
695
696	return rc;
697	}
698
699	HRESULT SystemProperties::getFreeDiskSpaceWarning(LONG64 *aFreeSpace)
700	{
701	NOREF(aFreeSpace);
702	ReturnComNotImplemented();
703	}
704
705	HRESULT SystemProperties::setFreeDiskSpaceWarning(LONG64 /* aFreeSpace */)
706	{
707	ReturnComNotImplemented();
708	}
709
710	HRESULT SystemProperties::getFreeDiskSpacePercentWarning(ULONG *aFreeSpacePercent)
711	{
712	NOREF(aFreeSpacePercent);
713	ReturnComNotImplemented();
714	}
715
716	HRESULT SystemProperties::setFreeDiskSpacePercentWarning(ULONG /* aFreeSpacePercent */)
717	{
718	ReturnComNotImplemented();
719	}
720
721	HRESULT SystemProperties::getFreeDiskSpaceError(LONG64 *aFreeSpace)
722	{
723	NOREF(aFreeSpace);
724	ReturnComNotImplemented();
725	}
726
727	HRESULT SystemProperties::setFreeDiskSpaceError(LONG64 /* aFreeSpace */)
728	{
729	ReturnComNotImplemented();
730	}
731
732	HRESULT SystemProperties::getFreeDiskSpacePercentError(ULONG *aFreeSpacePercent)
733	{
734	NOREF(aFreeSpacePercent);
735	ReturnComNotImplemented();
736	}
737
738	HRESULT SystemProperties::setFreeDiskSpacePercentError(ULONG /* aFreeSpacePercent */)
739	{
740	ReturnComNotImplemented();
741	}
742
743	HRESULT SystemProperties::getVRDEAuthLibrary(com::Utf8Str &aVRDEAuthLibrary)
744	{
745	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
746
747	aVRDEAuthLibrary = m->strVRDEAuthLibrary;
748
749	return S_OK;
750	}
751
752	HRESULT SystemProperties::setVRDEAuthLibrary(const com::Utf8Str &aVRDEAuthLibrary)
753	{
754	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
755	HRESULT rc = i_setVRDEAuthLibrary(aVRDEAuthLibrary);
756	alock.release();
757	if (SUCCEEDED(rc))
758	{
759	// VirtualBox::i_saveSettings() needs vbox write lock
760	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
761	rc = mParent->i_saveSettings();
762	}
763
764	return rc;
765	}
766
767	HRESULT SystemProperties::getWebServiceAuthLibrary(com::Utf8Str &aWebServiceAuthLibrary)
768	{
769	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
770
771	aWebServiceAuthLibrary = m->strWebServiceAuthLibrary;
772
773	return S_OK;
774	}
775
776	HRESULT SystemProperties::setWebServiceAuthLibrary(const com::Utf8Str &aWebServiceAuthLibrary)
777	{
778	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
779	HRESULT rc = i_setWebServiceAuthLibrary(aWebServiceAuthLibrary);
780	alock.release();
781
782	if (SUCCEEDED(rc))
783	{
784	// VirtualBox::i_saveSettings() needs vbox write lock
785	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
786	rc = mParent->i_saveSettings();
787	}
788
789	return rc;
790	}
791
792	HRESULT SystemProperties::getDefaultVRDEExtPack(com::Utf8Str &aExtPack)
793	{
794	HRESULT hrc = S_OK;
795	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
796	Utf8Str strExtPack(m->strDefaultVRDEExtPack);
797	if (strExtPack.isNotEmpty())
798	{
799	if (strExtPack.equals(VBOXVRDP_KLUDGE_EXTPACK_NAME))
800	hrc = S_OK;
801	else
802	#ifdef VBOX_WITH_EXTPACK
803	hrc = mParent->i_getExtPackManager()->i_checkVrdeExtPack(&strExtPack);
804	#else
805	hrc = setError(E_FAIL, tr("The extension pack '%s' does not exist"), strExtPack.c_str());
806	#endif
807	}
808	else
809	{
810	#ifdef VBOX_WITH_EXTPACK
811	hrc = mParent->i_getExtPackManager()->i_getDefaultVrdeExtPack(&strExtPack);
812	#endif
813	if (strExtPack.isEmpty())
814	{
815	/*
816	* Klugde - check if VBoxVRDP.dll/.so/.dylib is installed.
817	* This is hardcoded uglyness, sorry.
818	*/
819	char szPath[RTPATH_MAX];
820	int vrc = RTPathAppPrivateArch(szPath, sizeof(szPath));
821	if (RT_SUCCESS(vrc))
822	vrc = RTPathAppend(szPath, sizeof(szPath), "VBoxVRDP");
823	if (RT_SUCCESS(vrc))
824	vrc = RTStrCat(szPath, sizeof(szPath), RTLdrGetSuff());
825	if (RT_SUCCESS(vrc) && RTFileExists(szPath))
826	{
827	/* Illegal extpack name, so no conflict. */
828	strExtPack = VBOXVRDP_KLUDGE_EXTPACK_NAME;
829	}
830	}
831	}
832
833	if (SUCCEEDED(hrc))
834	aExtPack = strExtPack;
835
836	return S_OK;
837	}
838
839
840	HRESULT SystemProperties::setDefaultVRDEExtPack(const com::Utf8Str &aExtPack)
841	{
842	HRESULT hrc = S_OK;
843	if (aExtPack.isNotEmpty())
844	{
845	if (aExtPack.equals(VBOXVRDP_KLUDGE_EXTPACK_NAME))
846	hrc = S_OK;
847	else
848	#ifdef VBOX_WITH_EXTPACK
849	hrc = mParent->i_getExtPackManager()->i_checkVrdeExtPack(&aExtPack);
850	#else
851	hrc = setError(E_FAIL, tr("The extension pack '%s' does not exist"), aExtPack.c_str());
852	#endif
853	}
854	if (SUCCEEDED(hrc))
855	{
856	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
857	hrc = i_setDefaultVRDEExtPack(aExtPack);
858	if (SUCCEEDED(hrc))
859	{
860	/* VirtualBox::i_saveSettings() needs the VirtualBox write lock. */
861	alock.release();
862	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
863	hrc = mParent->i_saveSettings();
864	}
865	}
866
867	return hrc;
868	}
869
870
871	HRESULT SystemProperties::getLogHistoryCount(ULONG *count)
872	{
873	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
874
875	*count = m->ulLogHistoryCount;
876
877	return S_OK;
878	}
879
880
881	HRESULT SystemProperties::setLogHistoryCount(ULONG count)
882	{
883	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
884	m->ulLogHistoryCount = count;
885	alock.release();
886
887	// VirtualBox::i_saveSettings() needs vbox write lock
888	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
889	HRESULT rc = mParent->i_saveSettings();
890
891	return rc;
892	}
893
894	HRESULT SystemProperties::getDefaultAudioDriver(AudioDriverType_T *aAudioDriver)
895	{
896	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
897
898	*aAudioDriver = settings::MachineConfigFile::getHostDefaultAudioDriver();
899
900	return S_OK;
901	}
902
903	HRESULT SystemProperties::getAutostartDatabasePath(com::Utf8Str &aAutostartDbPath)
904	{
905	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
906
907	aAutostartDbPath = m->strAutostartDatabasePath;
908
909	return S_OK;
910	}
911
912	HRESULT SystemProperties::setAutostartDatabasePath(const com::Utf8Str &aAutostartDbPath)
913	{
914	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
915	HRESULT rc = i_setAutostartDatabasePath(aAutostartDbPath);
916	alock.release();
917
918	if (SUCCEEDED(rc))
919	{
920	// VirtualBox::i_saveSettings() needs vbox write lock
921	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
922	rc = mParent->i_saveSettings();
923	}
924
925	return rc;
926	}
927
928	HRESULT SystemProperties::getDefaultAdditionsISO(com::Utf8Str &aDefaultAdditionsISO)
929	{
930	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
931
932	if (m->strDefaultAdditionsISO.isEmpty())
933	{
934	/* no guest additions, check if it showed up in the mean time */
935	alock.release();
936	{
937	AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);
938	ErrorInfoKeeper eik;
939	(void)setDefaultAdditionsISO("");
940	}
941	alock.acquire();
942	}
943	aDefaultAdditionsISO = m->strDefaultAdditionsISO;
944
945	return S_OK;
946	}
947
948	HRESULT SystemProperties::setDefaultAdditionsISO(const com::Utf8Str &aDefaultAdditionsISO)
949	{
950	/** @todo not yet implemented, settings handling is missing */
951	ReturnComNotImplemented();
952
953	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
954	HRESULT rc = setDefaultAdditionsISO(aDefaultAdditionsISO);
955	alock.release();
956
957	if (SUCCEEDED(rc))
958	{
959	// VirtualBox::i_saveSettings() needs vbox write lock
960	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
961	rc = mParent->i_saveSettings();
962	}
963
964	return rc;
965	}
966
967	HRESULT SystemProperties::getDefaultFrontend(com::Utf8Str &aDefaultFrontend)
968	{
969	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
970	aDefaultFrontend = m->strDefaultFrontend;
971	return S_OK;
972	}
973
974	HRESULT SystemProperties::setDefaultFrontend(const com::Utf8Str &aDefaultFrontend)
975	{
976	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
977	if (m->strDefaultFrontend == Utf8Str(aDefaultFrontend))
978	return S_OK;
979	HRESULT rc = setDefaultFrontend(aDefaultFrontend);
980	alock.release();
981
982	if (SUCCEEDED(rc))
983	{
984	// VirtualBox::i_saveSettings() needs vbox write lock
985	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
986	rc = mParent->i_saveSettings();
987	}
988
989	return rc;
990	}
991
992	HRESULT SystemProperties::getScreenShotFormats(std::vector<BitmapFormat_T> &aBitmapFormats)
993	{
994	aBitmapFormats.push_back(BitmapFormat_BGR0);
995	aBitmapFormats.push_back(BitmapFormat_BGRA);
996	aBitmapFormats.push_back(BitmapFormat_RGBA);
997	aBitmapFormats.push_back(BitmapFormat_PNG);
998	return S_OK;
999	}
1000
1001	// public methods only for internal purposes
1002	/////////////////////////////////////////////////////////////////////////////
1003
1004	HRESULT SystemProperties::i_loadSettings(const settings::SystemProperties &data)
1005	{
1006	AutoCaller autoCaller(this);
1007	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1008
1009	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1010	HRESULT rc = S_OK;
1011	rc = i_setDefaultMachineFolder(data.strDefaultMachineFolder);
1012	if (FAILED(rc)) return rc;
1013
1014	rc = i_setLoggingLevel(data.strLoggingLevel);
1015	if (FAILED(rc)) return rc;
1016
1017	rc = i_setDefaultHardDiskFormat(data.strDefaultHardDiskFormat);
1018	if (FAILED(rc)) return rc;
1019
1020	rc = i_setVRDEAuthLibrary(data.strVRDEAuthLibrary);
1021	if (FAILED(rc)) return rc;
1022
1023	rc = i_setWebServiceAuthLibrary(data.strWebServiceAuthLibrary);
1024	if (FAILED(rc)) return rc;
1025
1026	rc = i_setDefaultVRDEExtPack(data.strDefaultVRDEExtPack);
1027	if (FAILED(rc)) return rc;
1028
1029	m->ulLogHistoryCount = data.ulLogHistoryCount;
1030	m->fExclusiveHwVirt = data.fExclusiveHwVirt;
1031
1032	rc = i_setAutostartDatabasePath(data.strAutostartDatabasePath);
1033	if (FAILED(rc)) return rc;
1034
1035	{
1036	/* must ignore errors signalled here, because the guest additions
1037	* file may not exist, and in this case keep the empty string */
1038	ErrorInfoKeeper eik;
1039	(void)i_setDefaultAdditionsISO(data.strDefaultAdditionsISO);
1040	}
1041
1042	rc = i_setDefaultFrontend(data.strDefaultFrontend);
1043	if (FAILED(rc)) return rc;
1044
1045	return S_OK;
1046	}
1047
1048	HRESULT SystemProperties::i_saveSettings(settings::SystemProperties &data)
1049	{
1050	AutoCaller autoCaller(this);
1051	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1052
1053	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1054
1055	data = *m;
1056
1057	return S_OK;
1058	}
1059
1060	/**
1061	* Returns a medium format object corresponding to the given format
1062	* identifier or null if no such format.
1063	*
1064	* @param aFormat Format identifier.
1065	*
1066	* @return ComObjPtr<MediumFormat>
1067	*/
1068	ComObjPtr<MediumFormat> SystemProperties::i_mediumFormat(const Utf8Str &aFormat)
1069	{
1070	ComObjPtr<MediumFormat> format;
1071
1072	AutoCaller autoCaller(this);
1073	AssertComRCReturn (autoCaller.rc(), format);
1074
1075	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1076
1077	for (MediumFormatList::const_iterator it = m_llMediumFormats.begin();
1078	it != m_llMediumFormats.end();
1079	++ it)
1080	{
1081	/* MediumFormat is all const, no need to lock */
1082
1083	if ((*it)->i_getId().compare(aFormat, Utf8Str::CaseInsensitive) == 0)
1084	{
1085	format = *it;
1086	break;
1087	}
1088	}
1089
1090	return format;
1091	}
1092
1093	/**
1094	* Returns a medium format object corresponding to the given file extension or
1095	* null if no such format.
1096	*
1097	* @param aExt File extension.
1098	*
1099	* @return ComObjPtr<MediumFormat>
1100	*/
1101	ComObjPtr<MediumFormat> SystemProperties::i_mediumFormatFromExtension(const Utf8Str &aExt)
1102	{
1103	ComObjPtr<MediumFormat> format;
1104
1105	AutoCaller autoCaller(this);
1106	AssertComRCReturn (autoCaller.rc(), format);
1107
1108	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1109
1110	bool fFound = false;
1111	for (MediumFormatList::const_iterator it = m_llMediumFormats.begin();
1112	it != m_llMediumFormats.end() && !fFound;
1113	++it)
1114	{
1115	/* MediumFormat is all const, no need to lock */
1116	MediumFormat::StrArray aFileList = (*it)->i_getFileExtensions();
1117	for (MediumFormat::StrArray::const_iterator it1 = aFileList.begin();
1118	it1 != aFileList.end();
1119	++it1)
1120	{
1121	if ((*it1).compare(aExt, Utf8Str::CaseInsensitive) == 0)
1122	{
1123	format = *it;
1124	fFound = true;
1125	break;
1126	}
1127	}
1128	}
1129
1130	return format;
1131	}
1132
1133
1134	/**
1135	* VD plugin load
1136	*/
1137	int SystemProperties::i_loadVDPlugin(const char *pszPluginLibrary)
1138	{
1139	return VDPluginLoadFromFilename(pszPluginLibrary);
1140	}
1141
1142	/**
1143	* VD plugin unload
1144	*/
1145	int SystemProperties::i_unloadVDPlugin(const char *pszPluginLibrary)
1146	{
1147	return VDPluginUnloadFromFilename(pszPluginLibrary);
1148	}
1149
1150	// private methods
1151	/////////////////////////////////////////////////////////////////////////////
1152
1153	/**
1154	* Returns the user's home directory. Wrapper around RTPathUserHome().
1155	* @param strPath
1156	* @return
1157	*/
1158	HRESULT SystemProperties::i_getUserHomeDirectory(Utf8Str &strPath)
1159	{
1160	char szHome[RTPATH_MAX];
1161	int vrc = RTPathUserHome(szHome, sizeof(szHome));
1162	if (RT_FAILURE(vrc))
1163	return setError(E_FAIL,
1164	tr("Cannot determine user home directory (%Rrc)"),
1165	vrc);
1166	strPath = szHome;
1167	return S_OK;
1168	}
1169
1170	/**
1171	* Internal implementation to set the default machine folder. Gets called
1172	* from the public attribute setter as well as loadSettings(). With 4.0,
1173	* the "default default" machine folder has changed, and we now require
1174	* a full path always.
1175	* @param aPath
1176	* @return
1177	*/
1178	HRESULT SystemProperties::i_setDefaultMachineFolder(const Utf8Str &strPath)
1179	{
1180	Utf8Str path(strPath); // make modifiable
1181	if ( path.isEmpty() // used by API calls to reset the default
1182	\|\| path == "Machines" // this value (exactly like this, without path) is stored
1183	// in VirtualBox.xml if user upgrades from before 4.0 and
1184	// has not changed the default machine folder
1185	)
1186	{
1187	// new default with VirtualBox 4.0: "$HOME/VirtualBox VMs"
1188	HRESULT rc = i_getUserHomeDirectory(path);
1189	if (FAILED(rc)) return rc;
1190	path += RTPATH_SLASH_STR "VirtualBox VMs";
1191	}
1192
1193	if (!RTPathStartsWithRoot(path.c_str()))
1194	return setError(E_INVALIDARG,
1195	tr("Given default machine folder '%s' is not fully qualified"),
1196	path.c_str());
1197
1198	m->strDefaultMachineFolder = path;
1199
1200	return S_OK;
1201	}
1202
1203	HRESULT SystemProperties::i_setLoggingLevel(const com::Utf8Str &aLoggingLevel)
1204	{
1205	Utf8Str useLoggingLevel(aLoggingLevel);
1206	if (useLoggingLevel.isEmpty())
1207	useLoggingLevel = VBOXSVC_LOG_DEFAULT;
1208	int rc = RTLogGroupSettings(RTLogRelGetDefaultInstance(), useLoggingLevel.c_str());
1209	// If failed and not the default logging level - try to use the default logging level.
1210	if (RT_FAILURE(rc))
1211	{
1212	// If failed write message to the release log.
1213	LogRel(("Cannot set passed logging level=%s Error=%Rrc \n", useLoggingLevel.c_str(), rc));
1214	// If attempted logging level not the default one then try the default one.
1215	if (!useLoggingLevel.equals(VBOXSVC_LOG_DEFAULT))
1216	{
1217	rc = RTLogGroupSettings(RTLogRelGetDefaultInstance(), VBOXSVC_LOG_DEFAULT);
1218	// If failed report this to the release log.
1219	if (RT_FAILURE(rc))
1220	LogRel(("Cannot set default logging level Error=%Rrc \n", rc));
1221	}
1222	// On any failure - set default level as the one to be stored.
1223	useLoggingLevel = VBOXSVC_LOG_DEFAULT;
1224	}
1225	// Set to passed value or if default used/attempted (even if error condition) use empty string.
1226	m->strLoggingLevel = (useLoggingLevel.equals(VBOXSVC_LOG_DEFAULT) ? "" : useLoggingLevel);
1227	return RT_SUCCESS(rc) ? S_OK : E_FAIL;
1228	}
1229
1230	HRESULT SystemProperties::i_setDefaultHardDiskFormat(const com::Utf8Str &aFormat)
1231	{
1232	if (!aFormat.isEmpty())
1233	m->strDefaultHardDiskFormat = aFormat;
1234	else
1235	m->strDefaultHardDiskFormat = "VDI";
1236
1237	return S_OK;
1238	}
1239
1240	HRESULT SystemProperties::i_setVRDEAuthLibrary(const com::Utf8Str &aPath)
1241	{
1242	if (!aPath.isEmpty())
1243	m->strVRDEAuthLibrary = aPath;
1244	else
1245	m->strVRDEAuthLibrary = "VBoxAuth";
1246
1247	return S_OK;
1248	}
1249
1250	HRESULT SystemProperties::i_setWebServiceAuthLibrary(const com::Utf8Str &aPath)
1251	{
1252	if (!aPath.isEmpty())
1253	m->strWebServiceAuthLibrary = aPath;
1254	else
1255	m->strWebServiceAuthLibrary = "VBoxAuth";
1256
1257	return S_OK;
1258	}
1259
1260	HRESULT SystemProperties::i_setDefaultVRDEExtPack(const com::Utf8Str &aExtPack)
1261	{
1262	m->strDefaultVRDEExtPack = aExtPack;
1263
1264	return S_OK;
1265	}
1266
1267	HRESULT SystemProperties::i_setAutostartDatabasePath(const com::Utf8Str &aPath)
1268	{
1269	HRESULT rc = S_OK;
1270	AutostartDb *autostartDb = this->mParent->i_getAutostartDb();
1271
1272	if (!aPath.isEmpty())
1273	{
1274	/* Update path in the autostart database. */
1275	int vrc = autostartDb->setAutostartDbPath(aPath.c_str());
1276	if (RT_SUCCESS(vrc))
1277	m->strAutostartDatabasePath = aPath;
1278	else
1279	rc = setError(E_FAIL,
1280	tr("Cannot set the autostart database path (%Rrc)"),
1281	vrc);
1282	}
1283	else
1284	{
1285	int vrc = autostartDb->setAutostartDbPath(NULL);
1286	if (RT_SUCCESS(vrc) \|\| vrc == VERR_NOT_SUPPORTED)
1287	m->strAutostartDatabasePath = "";
1288	else
1289	rc = setError(E_FAIL,
1290	tr("Deleting the autostart database path failed (%Rrc)"),
1291	vrc);
1292	}
1293
1294	return rc;
1295	}
1296
1297	HRESULT SystemProperties::i_setDefaultAdditionsISO(const com::Utf8Str &aPath)
1298	{
1299	com::Utf8Str path(aPath);
1300	if (path.isEmpty())
1301	{
1302	char strTemp[RTPATH_MAX];
1303	int vrc = RTPathAppPrivateNoArch(strTemp, sizeof(strTemp));
1304	AssertRC(vrc);
1305	Utf8Str strSrc1 = Utf8Str(strTemp).append("/VBoxGuestAdditions.iso");
1306
1307	vrc = RTPathExecDir(strTemp, sizeof(strTemp));
1308	AssertRC(vrc);
1309	Utf8Str strSrc2 = Utf8Str(strTemp).append("/additions/VBoxGuestAdditions.iso");
1310
1311	vrc = RTPathUserHome(strTemp, sizeof(strTemp));
1312	AssertRC(vrc);
1313	Utf8Str strSrc3 = Utf8StrFmt("%s/VBoxGuestAdditions_%s.iso", strTemp, VirtualBox::i_getVersionNormalized().c_str());
1314
1315	/* Check the standard image locations */
1316	if (RTFileExists(strSrc1.c_str()))
1317	path = strSrc1;
1318	else if (RTFileExists(strSrc2.c_str()))
1319	path = strSrc2;
1320	else if (RTFileExists(strSrc3.c_str()))
1321	path = strSrc3;
1322	else
1323	return setError(E_FAIL,
1324	tr("Cannot determine default Guest Additions ISO location. Most likely they are not available"));
1325	}
1326
1327	if (!RTPathStartsWithRoot(path.c_str()))
1328	return setError(E_INVALIDARG,
1329	tr("Given default machine Guest Additions ISO file '%s' is not fully qualified"),
1330	path.c_str());
1331
1332	if (!RTFileExists(path.c_str()))
1333	return setError(E_INVALIDARG,
1334	tr("Given default machine Guest Additions ISO file '%s' does not exist"),
1335	path.c_str());
1336
1337	m->strDefaultAdditionsISO = path;
1338
1339	return S_OK;
1340	}
1341
1342	HRESULT SystemProperties::i_setDefaultFrontend(const com::Utf8Str &aDefaultFrontend)
1343	{
1344	m->strDefaultFrontend = aDefaultFrontend;
1345
1346	return S_OK;
1347	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/src-server/SystemPropertiesImpl.cpp@ 58043

Download in other formats: