PlatformPropertiesImpl.cpp@ 104846

Last change on this file since 104846 was 104846, checked in by vboxsync, 8 months ago
include/VBox,Main,DevVGA: Folded VBox/graphics.h into VBox/param.h and restored svga_reg.h to its vanilla state. bugref:10693
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.7 KB

Line
1	/* $Id: PlatformPropertiesImpl.cpp 104846 2024-06-05 02:08:09Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation - Platform properties.
4	*/
5
6	/*
7	* Copyright (C) 2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	#define LOG_GROUP LOG_GROUP_MAIN_PLATFORMPROPERTIES
29	#include "PlatformPropertiesImpl.h"
30	#include "VirtualBoxImpl.h"
31	#include "LoggingNew.h"
32	#include "Global.h"
33
34	#include <iprt/cpp/utils.h>
35
36	#include <VBox/param.h> /* For VRAM ranges. */
37	#include <VBox/settings.h>
38
39	// generated header
40	#include "SchemaDefs.h"
41
42
43	/*
44	* PlatformProperties implementation.
45	*/
46	PlatformProperties::PlatformProperties()
47	: mParent(NULL)
48	, mPlatformArchitecture(PlatformArchitecture_None)
49	, mfIsHost(false)
50	{
51	}
52
53	PlatformProperties::~PlatformProperties()
54	{
55	uninit();
56	}
57
58	HRESULT PlatformProperties::FinalConstruct()
59	{
60	return BaseFinalConstruct();
61	}
62
63	void PlatformProperties::FinalRelease()
64	{
65	uninit();
66
67	BaseFinalRelease();
68	}
69
70	/**
71	* Initializes platform properties.
72	*
73	* @returns HRESULT
74	* @param aParent Pointer to IVirtualBox parent object (weak).
75	* @param fIsHost Set to \c true if this instance handles platform properties of the host,
76	* or set to \c false for guests (default).
77	*/
78	HRESULT PlatformProperties::init(VirtualBox aParent, bool fIsHost / = false */)
79	{
80	/* Enclose the state transition NotReady->InInit->Ready */
81	AutoInitSpan autoInitSpan(this);
82	AssertReturn(autoInitSpan.isOk(), E_FAIL);
83
84	unconst(mParent) = aParent;
85
86	m = new settings::PlatformProperties;
87
88	unconst(mfIsHost) = fIsHost;
89
90	if (mfIsHost)
91	{
92	/* On Windows, macOS and Solaris hosts, HW virtualization use isn't exclusive
93	* by default so that VT-x or AMD-V can be shared with other
94	* hypervisors without requiring user intervention.
95	* NB: See also PlatformProperties constructor in settings.h
96	*/
97	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_WINDOWS) \|\| defined(RT_OS_SOLARIS)
98	m->fExclusiveHwVirt = false; /** @todo BUGBUG Applies for MacOS on ARM as well? */
99	#else
100	m->fExclusiveHwVirt = true;
101	#endif
102	}
103
104	/* Confirm a successful initialization */
105	autoInitSpan.setSucceeded();
106
107	return S_OK;
108	}
109
110	/**
111	* Sets the platform architecture.
112	*
113	* @returns HRESULT
114	* @param aArchitecture Platform architecture to set.
115	*
116	* @note Usually only called when creating a new machine.
117	*/
118	HRESULT PlatformProperties::i_setArchitecture(PlatformArchitecture_T aArchitecture)
119	{
120	/* sanity */
121	AutoCaller autoCaller(this);
122	AssertComRCReturn(autoCaller.hrc(), autoCaller.hrc());
123
124	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
125
126	mPlatformArchitecture = aArchitecture;
127
128	return S_OK;
129	}
130
131	/**
132	* Returns the host's platform architecture.
133	*
134	* @returns The host's platform architecture.
135	*/
136	PlatformArchitecture_T PlatformProperties::s_getHostPlatformArchitecture()
137	{
138	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
139	return PlatformArchitecture_x86;
140	#elif defined(RT_ARCH_ARM64) \|\| defined(RT_ARCH_ARM32)
141	return PlatformArchitecture_ARM;
142	#else
143	# error "Port me!"
144	return PlatformArchitecture_None;
145	#endif
146	}
147
148	void PlatformProperties::uninit()
149	{
150	/* Enclose the state transition Ready->InUninit->NotReady */
151	AutoUninitSpan autoUninitSpan(this);
152	if (autoUninitSpan.uninitDone())
153	return;
154
155	if (m)
156	{
157	delete m;
158	m = NULL;
159	}
160	}
161
162	HRESULT PlatformProperties::getSerialPortCount(ULONG *count)
163	{
164	/* no need to lock, this is const */
165	*count = SchemaDefs::SerialPortCount;
166
167	return S_OK;
168	}
169
170	HRESULT PlatformProperties::getParallelPortCount(ULONG *count)
171	{
172	/* no need to lock, this is const */
173	*count = SchemaDefs::ParallelPortCount;
174
175	return S_OK;
176	}
177
178	HRESULT PlatformProperties::getMaxBootPosition(ULONG *aMaxBootPosition)
179	{
180	/* no need to lock, this is const */
181	*aMaxBootPosition = SchemaDefs::MaxBootPosition;
182
183	return S_OK;
184	}
185
186	HRESULT PlatformProperties::getRawModeSupported(BOOL *aRawModeSupported)
187	{
188	*aRawModeSupported = FALSE;
189	return S_OK;
190	}
191
192	HRESULT PlatformProperties::getExclusiveHwVirt(BOOL *aExclusiveHwVirt)
193	{
194	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
195
196	*aExclusiveHwVirt = m->fExclusiveHwVirt;
197
198	/* Makes no sense for guest platform properties, but we return FALSE anyway. */
199	return S_OK;
200	}
201
202	HRESULT PlatformProperties::setExclusiveHwVirt(BOOL aExclusiveHwVirt)
203	{
204	/* Only makes sense when running in VBoxSVC, as this is a pure host setting -- ignored within clients. */
205	#ifdef IN_VBOXSVC
206	/* No locking required, as mfIsHost is const. */
207	if (!mfIsHost) /* Ignore setting the attribute if not host properties. */
208	return S_OK;
209
210	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
211	m->fExclusiveHwVirt = !!aExclusiveHwVirt;
212	alock.release();
213
214	// VirtualBox::i_saveSettings() needs vbox write lock
215	AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
216	return mParent->i_saveSettings();
217	#else /* VBoxC */
218	RT_NOREF(aExclusiveHwVirt);
219	return VBOX_E_NOT_SUPPORTED;
220	#endif
221	}
222
223	/* static */
224	ULONG PlatformProperties::s_getMaxNetworkAdapters(ChipsetType_T aChipset)
225	{
226	AssertReturn(aChipset != ChipsetType_Null, 0);
227
228	/* no need for locking, no state */
229	switch (aChipset)
230	{
231	case ChipsetType_PIIX3: return 8;
232	case ChipsetType_ICH9: return 36;
233	case ChipsetType_ARMv8Virtual: return 64; /** @todo BUGBUG Put a sane value here. Just a wild guess for now. */
234	case ChipsetType_Null:
235	RT_FALL_THROUGH();
236	default:
237	break;
238	}
239
240	AssertMsgFailedReturn(("Chipset type %#x not handled\n", aChipset), 0);
241	}
242
243	HRESULT PlatformProperties::getMaxNetworkAdapters(ChipsetType_T aChipset, ULONG *aMaxNetworkAdapters)
244	{
245	*aMaxNetworkAdapters = PlatformProperties::s_getMaxNetworkAdapters(aChipset);
246
247	return S_OK;
248	}
249
250	/* static */
251	ULONG PlatformProperties::s_getMaxNetworkAdaptersOfType(ChipsetType_T aChipset, NetworkAttachmentType_T aType)
252	{
253	/* no need for locking, no state */
254	uint32_t cMaxNetworkAdapters = PlatformProperties::s_getMaxNetworkAdapters(aChipset);
255
256	switch (aType)
257	{
258	case NetworkAttachmentType_NAT:
259	case NetworkAttachmentType_Internal:
260	case NetworkAttachmentType_NATNetwork:
261	/* chipset default is OK */
262	break;
263	case NetworkAttachmentType_Bridged:
264	/* Maybe use current host interface count here? */
265	break;
266	case NetworkAttachmentType_HostOnly:
267	cMaxNetworkAdapters = RT_MIN(cMaxNetworkAdapters, 8);
268	break;
269	default:
270	AssertMsgFailed(("Unhandled attachment type %d\n", aType));
271	}
272
273	return cMaxNetworkAdapters;
274	}
275
276	HRESULT PlatformProperties::getMaxNetworkAdaptersOfType(ChipsetType_T aChipset, NetworkAttachmentType_T aType,
277	ULONG *aMaxNetworkAdapters)
278	{
279	*aMaxNetworkAdapters = PlatformProperties::s_getMaxNetworkAdaptersOfType(aChipset, aType);
280
281	return S_OK;
282	}
283
284	HRESULT PlatformProperties::getMaxDevicesPerPortForStorageBus(StorageBus_T aBus,
285	ULONG *aMaxDevicesPerPort)
286	{
287	/* no need to lock, this is const */
288	switch (aBus)
289	{
290	case StorageBus_SATA:
291	case StorageBus_SCSI:
292	case StorageBus_SAS:
293	case StorageBus_USB:
294	case StorageBus_PCIe:
295	case StorageBus_VirtioSCSI:
296	{
297	/* SATA and both SCSI controllers only support one device per port. */
298	*aMaxDevicesPerPort = 1;
299	break;
300	}
301	case StorageBus_IDE:
302	case StorageBus_Floppy:
303	{
304	/* The IDE and Floppy controllers support 2 devices. One as master
305	* and one as slave (or floppy drive 0 and 1). */
306	*aMaxDevicesPerPort = 2;
307	break;
308	}
309	default:
310	AssertMsgFailed(("Invalid bus type %d\n", aBus));
311	}
312
313	return S_OK;
314	}
315
316	HRESULT PlatformProperties::getMinPortCountForStorageBus(StorageBus_T aBus,
317	ULONG *aMinPortCount)
318	{
319	/* no need to lock, this is const */
320	switch (aBus)
321	{
322	case StorageBus_SATA:
323	case StorageBus_SAS:
324	case StorageBus_PCIe:
325	case StorageBus_VirtioSCSI:
326	{
327	*aMinPortCount = 1;
328	break;
329	}
330	case StorageBus_SCSI:
331	{
332	*aMinPortCount = 16;
333	break;
334	}
335	case StorageBus_IDE:
336	{
337	*aMinPortCount = 2;
338	break;
339	}
340	case StorageBus_Floppy:
341	{
342	*aMinPortCount = 1;
343	break;
344	}
345	case StorageBus_USB:
346	{
347	*aMinPortCount = 8;
348	break;
349	}
350	default:
351	AssertMsgFailed(("Invalid bus type %d\n", aBus));
352	}
353
354	return S_OK;
355	}
356
357	HRESULT PlatformProperties::getMaxPortCountForStorageBus(StorageBus_T aBus,
358	ULONG *aMaxPortCount)
359	{
360	/* no need to lock, this is const */
361	switch (aBus)
362	{
363	case StorageBus_SATA:
364	{
365	*aMaxPortCount = 30;
366	break;
367	}
368	case StorageBus_SCSI:
369	{
370	*aMaxPortCount = 16;
371	break;
372	}
373	case StorageBus_IDE:
374	{
375	*aMaxPortCount = 2;
376	break;
377	}
378	case StorageBus_Floppy:
379	{
380	*aMaxPortCount = 1;
381	break;
382	}
383	case StorageBus_SAS:
384	case StorageBus_PCIe:
385	{
386	*aMaxPortCount = 255;
387	break;
388	}
389	case StorageBus_USB:
390	{
391	*aMaxPortCount = 8;
392	break;
393	}
394	case StorageBus_VirtioSCSI:
395	{
396	*aMaxPortCount = 256;
397	break;
398	}
399	default:
400	AssertMsgFailed(("Invalid bus type %d\n", aBus));
401	}
402
403	return S_OK;
404	}
405
406	HRESULT PlatformProperties::getMaxInstancesOfStorageBus(ChipsetType_T aChipset,
407	StorageBus_T aBus,
408	ULONG *aMaxInstances)
409	{
410	ULONG cCtrs = 0;
411
412	/* no need to lock, this is const */
413	switch (aBus)
414	{
415	case StorageBus_SATA:
416	case StorageBus_SCSI:
417	case StorageBus_SAS:
418	case StorageBus_PCIe:
419	case StorageBus_VirtioSCSI:
420	cCtrs = aChipset == ChipsetType_ICH9 \|\| aChipset == ChipsetType_ARMv8Virtual ? 8 : 1;
421	break;
422	case StorageBus_USB:
423	case StorageBus_IDE:
424	case StorageBus_Floppy:
425	{
426	cCtrs = 1;
427	break;
428	}
429	default:
430	AssertMsgFailed(("Invalid bus type %d\n", aBus));
431	}
432
433	*aMaxInstances = cCtrs;
434
435	return S_OK;
436	}
437
438	HRESULT PlatformProperties::getDeviceTypesForStorageBus(StorageBus_T aBus,
439	std::vector<DeviceType_T> &aDeviceTypes)
440	{
441	aDeviceTypes.resize(0);
442
443	/* no need to lock, this is const */
444	switch (aBus)
445	{
446	case StorageBus_IDE:
447	case StorageBus_SATA:
448	case StorageBus_SCSI:
449	case StorageBus_SAS:
450	case StorageBus_USB:
451	case StorageBus_VirtioSCSI:
452	{
453	aDeviceTypes.resize(2);
454	aDeviceTypes[0] = DeviceType_DVD;
455	aDeviceTypes[1] = DeviceType_HardDisk;
456	break;
457	}
458	case StorageBus_Floppy:
459	{
460	aDeviceTypes.resize(1);
461	aDeviceTypes[0] = DeviceType_Floppy;
462	break;
463	}
464	case StorageBus_PCIe:
465	{
466	aDeviceTypes.resize(1);
467	aDeviceTypes[0] = DeviceType_HardDisk;
468	break;
469	}
470	default:
471	AssertMsgFailed(("Invalid bus type %d\n", aBus));
472	}
473
474	return S_OK;
475	}
476
477	HRESULT PlatformProperties::getStorageBusForControllerType(StorageControllerType_T aStorageControllerType,
478	StorageBus_T *aStorageBus)
479	{
480	/* no need to lock, this is const */
481	switch (aStorageControllerType)
482	{
483	case StorageControllerType_LsiLogic:
484	case StorageControllerType_BusLogic:
485	*aStorageBus = StorageBus_SCSI;
486	break;
487	case StorageControllerType_IntelAhci:
488	*aStorageBus = StorageBus_SATA;
489	break;
490	case StorageControllerType_PIIX3:
491	case StorageControllerType_PIIX4:
492	case StorageControllerType_ICH6:
493	*aStorageBus = StorageBus_IDE;
494	break;
495	case StorageControllerType_I82078:
496	*aStorageBus = StorageBus_Floppy;
497	break;
498	case StorageControllerType_LsiLogicSas:
499	*aStorageBus = StorageBus_SAS;
500	break;
501	case StorageControllerType_USB:
502	*aStorageBus = StorageBus_USB;
503	break;
504	case StorageControllerType_NVMe:
505	*aStorageBus = StorageBus_PCIe;
506	break;
507	case StorageControllerType_VirtioSCSI:
508	*aStorageBus = StorageBus_VirtioSCSI;
509	break;
510	default:
511	return setError(E_FAIL, tr("Invalid storage controller type %d\n"), aStorageBus);
512	}
513
514	return S_OK;
515	}
516
517	HRESULT PlatformProperties::getStorageControllerTypesForBus(StorageBus_T aStorageBus,
518	std::vector<StorageControllerType_T> &aStorageControllerTypes)
519	{
520	aStorageControllerTypes.resize(0);
521
522	/* no need to lock, this is const */
523	switch (aStorageBus)
524	{
525	case StorageBus_IDE:
526	aStorageControllerTypes.resize(3);
527	aStorageControllerTypes[0] = StorageControllerType_PIIX4;
528	aStorageControllerTypes[1] = StorageControllerType_PIIX3;
529	aStorageControllerTypes[2] = StorageControllerType_ICH6;
530	break;
531	case StorageBus_SATA:
532	aStorageControllerTypes.resize(1);
533	aStorageControllerTypes[0] = StorageControllerType_IntelAhci;
534	break;
535	case StorageBus_SCSI:
536	aStorageControllerTypes.resize(2);
537	aStorageControllerTypes[0] = StorageControllerType_LsiLogic;
538	aStorageControllerTypes[1] = StorageControllerType_BusLogic;
539	break;
540	case StorageBus_Floppy:
541	aStorageControllerTypes.resize(1);
542	aStorageControllerTypes[0] = StorageControllerType_I82078;
543	break;
544	case StorageBus_SAS:
545	aStorageControllerTypes.resize(1);
546	aStorageControllerTypes[0] = StorageControllerType_LsiLogicSas;
547	break;
548	case StorageBus_USB:
549	aStorageControllerTypes.resize(1);
550	aStorageControllerTypes[0] = StorageControllerType_USB;
551	break;
552	case StorageBus_PCIe:
553	aStorageControllerTypes.resize(1);
554	aStorageControllerTypes[0] = StorageControllerType_NVMe;
555	break;
556	case StorageBus_VirtioSCSI:
557	aStorageControllerTypes.resize(1);
558	aStorageControllerTypes[0] = StorageControllerType_VirtioSCSI;
559	break;
560	default:
561	return setError(E_FAIL, tr("Invalid storage bus %d\n"), aStorageBus);
562	}
563
564	return S_OK;
565	}
566
567	HRESULT PlatformProperties::getStorageControllerHotplugCapable(StorageControllerType_T aControllerType,
568	BOOL *aHotplugCapable)
569	{
570	switch (aControllerType)
571	{
572	case StorageControllerType_IntelAhci:
573	case StorageControllerType_USB:
574	*aHotplugCapable = true;
575	break;
576	case StorageControllerType_LsiLogic:
577	case StorageControllerType_LsiLogicSas:
578	case StorageControllerType_BusLogic:
579	case StorageControllerType_NVMe:
580	case StorageControllerType_VirtioSCSI:
581	case StorageControllerType_PIIX3:
582	case StorageControllerType_PIIX4:
583	case StorageControllerType_ICH6:
584	case StorageControllerType_I82078:
585	*aHotplugCapable = false;
586	break;
587	default:
588	AssertMsgFailedReturn(("Invalid controller type %d\n", aControllerType), E_FAIL);
589	}
590
591	return S_OK;
592	}
593
594	HRESULT PlatformProperties::getMaxInstancesOfUSBControllerType(ChipsetType_T aChipset,
595	USBControllerType_T aType,
596	ULONG *aMaxInstances)
597	{
598	NOREF(aChipset);
599	ULONG cCtrs = 0;
600
601	/* no need to lock, this is const */
602	switch (aType)
603	{
604	case USBControllerType_OHCI:
605	case USBControllerType_EHCI:
606	case USBControllerType_XHCI:
607	{
608	cCtrs = 1;
609	break;
610	}
611	default:
612	AssertMsgFailed(("Invalid bus type %d\n", aType));
613	}
614
615	*aMaxInstances = cCtrs;
616
617	return S_OK;
618	}
619
620	HRESULT PlatformProperties::getSupportedParavirtProviders(std::vector<ParavirtProvider_T> &aSupportedParavirtProviders)
621	{
622	static const ParavirtProvider_T aParavirtProviders[] =
623	{
624	ParavirtProvider_None,
625	ParavirtProvider_Default,
626	ParavirtProvider_Legacy,
627	ParavirtProvider_Minimal,
628	ParavirtProvider_HyperV,
629	ParavirtProvider_KVM,
630	};
631	aSupportedParavirtProviders.assign(aParavirtProviders,
632	aParavirtProviders + RT_ELEMENTS(aParavirtProviders));
633	return S_OK;
634	}
635
636	HRESULT PlatformProperties::getSupportedFirmwareTypes(std::vector<FirmwareType_T> &aSupportedFirmwareTypes)
637	{
638	switch (mPlatformArchitecture)
639	{
640	case PlatformArchitecture_x86:
641	{
642	static const FirmwareType_T aFirmwareTypes[] =
643	{
644	FirmwareType_BIOS,
645	FirmwareType_EFI,
646	FirmwareType_EFI32,
647	FirmwareType_EFI64,
648	FirmwareType_EFIDUAL
649	};
650	aSupportedFirmwareTypes.assign(aFirmwareTypes,
651	aFirmwareTypes + RT_ELEMENTS(aFirmwareTypes));
652	break;
653	}
654
655	case PlatformArchitecture_ARM:
656	{
657	static const FirmwareType_T aFirmwareTypes[] =
658	{
659	FirmwareType_EFI,
660	FirmwareType_EFI32,
661	FirmwareType_EFI64,
662	FirmwareType_EFIDUAL
663	};
664	aSupportedFirmwareTypes.assign(aFirmwareTypes,
665	aFirmwareTypes + RT_ELEMENTS(aFirmwareTypes));
666	break;
667	}
668
669	default:
670	AssertFailedStmt(aSupportedFirmwareTypes.clear());
671	break;
672	}
673
674	return S_OK;
675	}
676
677	HRESULT PlatformProperties::getSupportedGraphicsControllerTypes(std::vector<GraphicsControllerType_T> &aSupportedGraphicsControllerTypes)
678	{
679	switch (mPlatformArchitecture)
680	{
681	case PlatformArchitecture_x86:
682	{
683	static const GraphicsControllerType_T aGraphicsControllerTypes[] =
684	{
685	GraphicsControllerType_Null,
686	GraphicsControllerType_VBoxVGA,
687	GraphicsControllerType_VBoxSVGA
688	#ifdef VBOX_WITH_VMSVGA
689	, GraphicsControllerType_VMSVGA
690	#endif
691	};
692	aSupportedGraphicsControllerTypes.assign(aGraphicsControllerTypes + 1 /* Don't include _Null */,
693	aGraphicsControllerTypes + RT_ELEMENTS(aGraphicsControllerTypes));
694	break;
695	}
696
697	case PlatformArchitecture_ARM:
698	{
699	static const GraphicsControllerType_T aGraphicsControllerTypes[] =
700	{
701	GraphicsControllerType_Null,
702	GraphicsControllerType_QemuRamFB
703	#ifdef VBOX_WITH_VMSVGA
704	, GraphicsControllerType_VMSVGA
705	#endif
706	};
707	aSupportedGraphicsControllerTypes.assign(aGraphicsControllerTypes + 1 /* Don't include _Null */,
708	aGraphicsControllerTypes + RT_ELEMENTS(aGraphicsControllerTypes));
709	break;
710	}
711
712	default:
713	AssertFailedStmt(aSupportedGraphicsControllerTypes.clear());
714	break;
715	}
716
717	return S_OK;
718	}
719
720	HRESULT PlatformProperties::getSupportedGuestOSTypes(std::vector<ComPtr<IGuestOSType> > &aSupportedGuestOSTypes)
721	{
722	/* We only have all supported guest OS types as part of VBoxSVC, not in VBoxC itself. */
723	#ifdef IN_VBOXSVC
724	std::vector<PlatformArchitecture_T> vecArchitectures(1 /* Size */, mPlatformArchitecture);
725	return mParent->i_getSupportedGuestOSTypes(vecArchitectures, aSupportedGuestOSTypes);
726	#else /* VBoxC */
727	RT_NOREF(aSupportedGuestOSTypes);
728	return VBOX_E_NOT_SUPPORTED;
729	#endif
730	}
731
732	HRESULT PlatformProperties::getSupportedNetAdpPromiscModePols(std::vector<NetworkAdapterPromiscModePolicy_T> &aSupportedNetworkAdapterPromiscModePolicies)
733	{
734	static const NetworkAdapterPromiscModePolicy_T aNetworkAdapterPromiscModePolicies[] =
735	{
736	NetworkAdapterPromiscModePolicy_Deny,
737	NetworkAdapterPromiscModePolicy_AllowNetwork,
738	NetworkAdapterPromiscModePolicy_AllowAll
739	};
740
741	aSupportedNetworkAdapterPromiscModePolicies.assign(aNetworkAdapterPromiscModePolicies,
742	aNetworkAdapterPromiscModePolicies + RT_ELEMENTS(aNetworkAdapterPromiscModePolicies));
743	return S_OK;
744	}
745
746	HRESULT PlatformProperties::getSupportedNetworkAdapterTypes(std::vector<NetworkAdapterType_T> &aSupportedNetworkAdapterTypes)
747	{
748	switch (mPlatformArchitecture)
749	{
750	case PlatformArchitecture_x86:
751	{
752	static const NetworkAdapterType_T aNetworkAdapterTypes[] =
753	{
754	NetworkAdapterType_Null,
755	NetworkAdapterType_Am79C970A,
756	NetworkAdapterType_Am79C973
757	#ifdef VBOX_WITH_E1000
758	, NetworkAdapterType_I82540EM
759	, NetworkAdapterType_I82543GC
760	, NetworkAdapterType_I82545EM
761	#endif
762	#ifdef VBOX_WITH_VIRTIO
763	, NetworkAdapterType_Virtio
764	#endif
765	};
766	aSupportedNetworkAdapterTypes.assign(aNetworkAdapterTypes + 1 /* Don't include _Null */,
767	aNetworkAdapterTypes + RT_ELEMENTS(aNetworkAdapterTypes));
768	break;
769	}
770
771	case PlatformArchitecture_ARM:
772	{
773	static const NetworkAdapterType_T aNetworkAdapterTypes[] =
774	{
775	NetworkAdapterType_Null
776	#ifdef VBOX_WITH_E1000
777	, NetworkAdapterType_I82540EM
778	, NetworkAdapterType_I82543GC
779	, NetworkAdapterType_I82545EM
780	#endif
781	#ifdef VBOX_WITH_VIRTIO
782	, NetworkAdapterType_Virtio
783	#endif
784	};
785	aSupportedNetworkAdapterTypes.assign(aNetworkAdapterTypes + 1 /* Don't include _Null */,
786	aNetworkAdapterTypes + RT_ELEMENTS(aNetworkAdapterTypes));
787	break;
788	}
789
790	default:
791	AssertFailedStmt(aSupportedNetworkAdapterTypes.clear());
792	break;
793	}
794
795	return S_OK;
796	}
797
798	HRESULT PlatformProperties::getSupportedUartTypes(std::vector<UartType_T> &aSupportedUartTypes)
799	{
800	static const UartType_T aUartTypes[] =
801	{
802	UartType_U16450,
803	UartType_U16550A,
804	UartType_U16750
805	};
806	aSupportedUartTypes.assign(aUartTypes,
807	aUartTypes + RT_ELEMENTS(aUartTypes));
808	return S_OK;
809	}
810
811	HRESULT PlatformProperties::getSupportedUSBControllerTypes(std::vector<USBControllerType_T> &aSupportedUSBControllerTypes)
812	{
813	static const USBControllerType_T aUSBControllerTypes[] =
814	{
815	USBControllerType_OHCI,
816	USBControllerType_EHCI,
817	USBControllerType_XHCI
818	};
819	aSupportedUSBControllerTypes.assign(aUSBControllerTypes,
820	aUSBControllerTypes + RT_ELEMENTS(aUSBControllerTypes));
821	return S_OK;
822	}
823
824	/**
825	* Returns the [minimum, maximum] VRAM range and stride size for a given graphics controller.
826	*
827	* @returns HRESULT
828	* @param aGraphicsControllerType Graphics controller type to return values for.
829	* @param fAccelerate3DEnabled whether 3D acceleration is enabled / disabled for the selected graphics controller.
830	* @param aMinMB Where to return the minimum VRAM (in MB).
831	* @param aMaxMB Where to return the maximum VRAM (in MB).
832	* @param aStrideSizeMB Where to return stride size (in MB). Optional, can be NULL.
833	*/
834	/* static */
835	HRESULT PlatformProperties::s_getSupportedVRAMRange(GraphicsControllerType_T aGraphicsControllerType, BOOL fAccelerate3DEnabled,
836	ULONG aMinMB, ULONG aMaxMB, ULONG *aStrideSizeMB)
837	{
838	#if !defined(VBOX_WITH_VMSVGA) \|\| !defined(VBOX_WITH_VMSVGA3D)
839	RT_NOREF(fAccelerate3DEnabled);
840	#endif
841
842	size_t cbMin;
843	size_t cbMax;
844	size_t cbStride = _1M; /* Default stride for all controllers. */
845
846	switch (aGraphicsControllerType)
847	{
848	case GraphicsControllerType_VBoxVGA:
849	cbMin = VGA_VRAM_MIN;
850	cbMax = VGA_VRAM_MAX;
851	break;
852
853	case GraphicsControllerType_VMSVGA:
854	cbMin = VGA_VRAM_MIN;
855	cbMax = VGA_VRAM_MAX;
856	break;
857
858	/** @todo r=bird: I think this is wrong. The VMSVGA variant is the one that
859	* is trying to be the most compatible with the original HW (same PCI
860	* IDs etc). So, I don't see why we're subjecting VBoxSVGA to the SVGA
861	* limitations and the original VMSVGA variant to the VBox/VGA ones.
862	*
863	* Other than the higher minimum values compared to VGA_VRAM_MIN,
864	* I'm not sure we need to care too much about restricting the MAX to
865	* 128MB for either VMSVGA nor VBoxSVGA. We should be using
866	* VGA_VRAM_MAX for all three. */
867	case GraphicsControllerType_VBoxSVGA:
868	#ifdef VBOX_WITH_VMSVGA
869	# ifdef VBOX_WITH_VMSVGA3D
870	if (fAccelerate3DEnabled)
871	cbMin = VBOX_SVGA_VRAM_MIN_SIZE_3D;
872	else
873	# endif
874	cbMin = VBOX_SVGA_VRAM_MIN_SIZE;
875	cbMax = VBOX_SVGA_VRAM_MAX_SIZE;
876	break;
877	#else
878	return VBOX_E_NOT_SUPPORTED;
879	#endif
880
881	case GraphicsControllerType_QemuRamFB:
882	/* We seem to hardcode 32-bit (4 bytes) as BPP, see RAMFB_BPP in QemuRamfb.c. */
883	cbMin = 4 /* BPP in bytes / 16 * 16; /* Values taken from qemu/hw/display/ramfb.c */
884	cbMax = 4 /* BPP in bytes / 16000 * 12000; /* Values taken from bochs-vbe.h. */
885	break;
886
887	default:
888	return E_INVALIDARG;
889	}
890
891	/* Convert bytes -> MB, align to stride. */
892	cbMin = (ULONG)(RT_ALIGN_64(cbMin, cbStride) / _1M);
893	cbMax = (ULONG)(RT_ALIGN_64(cbMax, cbStride) / _1M);
894	cbStride = (ULONG)cbStride / _1M;
895
896	/** @todo r=bird: Why this? Why do these have to be powers of two?
897	* The algorithm could be better, use ASMBitLastSetU32 next time. */
898	#define MAKE_POWER_OF_TWO(a_MB) \
899	while (!RT_IS_POWER_OF_TWO(a_MB)) \
900	a_MB = a_MB + 1; \
901
902	MAKE_POWER_OF_TWO(cbMin);
903	MAKE_POWER_OF_TWO(cbMax);
904	MAKE_POWER_OF_TWO(cbStride);
905
906	#undef MAKE_POWER_OF_TWO
907
908	/* Finally, clamp the values to our schema definitions before returning. */
909	if (cbMax > SchemaDefs::MaxGuestVRAM)
910	cbMax = SchemaDefs::MaxGuestVRAM;
911
912	*aMinMB = (ULONG)cbMin;
913	*aMaxMB = (ULONG)cbMax;
914	if (aStrideSizeMB)
915	*aStrideSizeMB = (ULONG)cbStride;
916
917	return S_OK;
918	}
919
920	HRESULT PlatformProperties::getSupportedVRAMRange(GraphicsControllerType_T aGraphicsControllerType, BOOL fAccelerate3DEnabled,
921	ULONG aMinMB, ULONG aMaxMB, ULONG *aStrideSizeMB)
922	{
923	HRESULT hrc = PlatformProperties::s_getSupportedVRAMRange(aGraphicsControllerType, fAccelerate3DEnabled, aMinMB, aMaxMB,
924	aStrideSizeMB);
925	switch (hrc)
926	{
927	case VBOX_E_NOT_SUPPORTED:
928	return setError(VBOX_E_NOT_SUPPORTED, tr("Selected graphics controller not supported in this version"));
929
930	case E_INVALIDARG:
931	return setError(E_INVALIDARG, tr("The graphics controller type (%d) is invalid"), aGraphicsControllerType);
932
933	default:
934	break;
935	}
936
937	return S_OK;
938	}
939
940	HRESULT PlatformProperties::getSupportedAudioControllerTypes(std::vector<AudioControllerType_T> &aSupportedAudioControllerTypes)
941	{
942	switch (mPlatformArchitecture)
943	{
944	case PlatformArchitecture_x86:
945	{
946	static const AudioControllerType_T aAudioControllerTypes[] =
947	{
948	AudioControllerType_AC97,
949	AudioControllerType_SB16,
950	AudioControllerType_HDA,
951	};
952	aSupportedAudioControllerTypes.assign(aAudioControllerTypes,
953	aAudioControllerTypes + RT_ELEMENTS(aAudioControllerTypes));
954	break;
955	}
956
957	case PlatformArchitecture_ARM:
958	{
959	static const AudioControllerType_T aAudioControllerTypes[] =
960	{
961	AudioControllerType_AC97,
962	AudioControllerType_HDA,
963	};
964	aSupportedAudioControllerTypes.assign(aAudioControllerTypes,
965	aAudioControllerTypes + RT_ELEMENTS(aAudioControllerTypes));
966	break;
967	}
968
969	default:
970	AssertFailedStmt(aSupportedAudioControllerTypes.clear());
971	break;
972	}
973
974
975	return S_OK;
976	}
977
978	HRESULT PlatformProperties::getSupportedBootDevices(std::vector<DeviceType_T> &aSupportedBootDevices)
979	{
980	/* Note: This function returns the supported boot devices for the given architecture,
981	in the default order, to keep it simple for the caller. */
982
983	switch (mPlatformArchitecture)
984	{
985	case PlatformArchitecture_x86:
986	{
987	static const DeviceType_T aBootDevices[] =
988	{
989	DeviceType_Floppy,
990	DeviceType_DVD,
991	DeviceType_HardDisk,
992	DeviceType_Network
993	};
994	aSupportedBootDevices.assign(aBootDevices,
995	aBootDevices + RT_ELEMENTS(aBootDevices));
996	break;
997	}
998
999	case PlatformArchitecture_ARM:
1000	{
1001	static const DeviceType_T aBootDevices[] =
1002	{
1003	DeviceType_DVD,
1004	DeviceType_HardDisk
1005	/** @todo BUGBUG We need to test network booting via PXE on ARM first! */
1006	};
1007	aSupportedBootDevices.assign(aBootDevices,
1008	aBootDevices + RT_ELEMENTS(aBootDevices));
1009	break;
1010	}
1011
1012	default:
1013	AssertFailedStmt(aSupportedBootDevices.clear());
1014	break;
1015	}
1016
1017	return S_OK;
1018	}
1019
1020	HRESULT PlatformProperties::getSupportedStorageBuses(std::vector<StorageBus_T> &aSupportedStorageBuses)
1021	{
1022	switch (mPlatformArchitecture)
1023	{
1024	case PlatformArchitecture_x86:
1025	{
1026	static const StorageBus_T aStorageBuses[] =
1027	{
1028	StorageBus_SATA,
1029	StorageBus_IDE,
1030	StorageBus_SCSI,
1031	StorageBus_Floppy,
1032	StorageBus_SAS,
1033	StorageBus_USB,
1034	StorageBus_PCIe,
1035	StorageBus_VirtioSCSI,
1036	};
1037	aSupportedStorageBuses.assign(aStorageBuses,
1038	aStorageBuses + RT_ELEMENTS(aStorageBuses));
1039	break;
1040	}
1041
1042	case PlatformArchitecture_ARM:
1043	{
1044	static const StorageBus_T aStorageBuses[] =
1045	{
1046	StorageBus_VirtioSCSI
1047	};
1048	aSupportedStorageBuses.assign(aStorageBuses,
1049	aStorageBuses + RT_ELEMENTS(aStorageBuses));
1050	break;
1051	}
1052
1053	default:
1054	AssertFailedStmt(aSupportedStorageBuses.clear());
1055	break;
1056	}
1057
1058	return S_OK;
1059	}
1060
1061	HRESULT PlatformProperties::getSupportedStorageControllerTypes(std::vector<StorageControllerType_T> &aSupportedStorageControllerTypes)
1062	{
1063	switch (mPlatformArchitecture)
1064	{
1065	case PlatformArchitecture_x86:
1066	{
1067	static const StorageControllerType_T aStorageControllerTypes[] =
1068	{
1069	StorageControllerType_IntelAhci,
1070	StorageControllerType_PIIX4,
1071	StorageControllerType_PIIX3,
1072	StorageControllerType_ICH6,
1073	StorageControllerType_LsiLogic,
1074	StorageControllerType_BusLogic,
1075	StorageControllerType_I82078,
1076	StorageControllerType_LsiLogicSas,
1077	StorageControllerType_USB,
1078	StorageControllerType_NVMe,
1079	StorageControllerType_VirtioSCSI
1080	};
1081	aSupportedStorageControllerTypes.assign(aStorageControllerTypes,
1082	aStorageControllerTypes + RT_ELEMENTS(aStorageControllerTypes));
1083	break;
1084	}
1085
1086	case PlatformArchitecture_ARM:
1087	{
1088	static const StorageControllerType_T aStorageControllerTypes[] =
1089	{
1090	StorageControllerType_VirtioSCSI
1091	};
1092	aSupportedStorageControllerTypes.assign(aStorageControllerTypes,
1093	aStorageControllerTypes + RT_ELEMENTS(aStorageControllerTypes));
1094	break;
1095	}
1096
1097	default:
1098	AssertFailedStmt(aSupportedStorageControllerTypes.clear());
1099	break;
1100	}
1101
1102	return S_OK;
1103	}
1104
1105	HRESULT PlatformProperties::getSupportedChipsetTypes(std::vector<ChipsetType_T> &aSupportedChipsetTypes)
1106	{
1107	switch (mPlatformArchitecture)
1108	{
1109	case PlatformArchitecture_x86:
1110	{
1111	static const ChipsetType_T aChipsetTypes[] =
1112	{
1113	ChipsetType_PIIX3,
1114	ChipsetType_ICH9
1115	};
1116	aSupportedChipsetTypes.assign(aChipsetTypes,
1117	aChipsetTypes + RT_ELEMENTS(aChipsetTypes));
1118	break;
1119	}
1120
1121	case PlatformArchitecture_ARM:
1122	{
1123	static const ChipsetType_T aChipsetTypes[] =
1124	{
1125	ChipsetType_ARMv8Virtual
1126	};
1127	aSupportedChipsetTypes.assign(aChipsetTypes,
1128	aChipsetTypes + RT_ELEMENTS(aChipsetTypes));
1129	break;
1130	}
1131
1132	default:
1133	AssertFailedStmt(aSupportedChipsetTypes.clear());
1134	break;
1135	}
1136
1137	return S_OK;
1138	}
1139
1140	HRESULT PlatformProperties::getSupportedIommuTypes(std::vector<IommuType_T> &aSupportedIommuTypes)
1141	{
1142	switch (mPlatformArchitecture)
1143	{
1144	case PlatformArchitecture_x86:
1145	{
1146	static const IommuType_T aIommuTypes[] =
1147	{
1148	IommuType_None,
1149	IommuType_Automatic,
1150	IommuType_AMD
1151	/** @todo Add Intel when it's supported. */
1152	};
1153	aSupportedIommuTypes.assign(aIommuTypes,
1154	aIommuTypes + RT_ELEMENTS(aIommuTypes));
1155	break;
1156	}
1157
1158	case PlatformArchitecture_ARM:
1159	{
1160	static const IommuType_T aIommuTypes[] =
1161	{
1162	IommuType_None
1163	};
1164	aSupportedIommuTypes.assign(aIommuTypes,
1165	aIommuTypes + RT_ELEMENTS(aIommuTypes));
1166	break;
1167	}
1168
1169	default:
1170	AssertFailedStmt(aSupportedIommuTypes.clear());
1171	break;
1172	}
1173
1174	return S_OK;
1175	}
1176
1177	HRESULT PlatformProperties::getSupportedTpmTypes(std::vector<TpmType_T> &aSupportedTpmTypes)
1178	{
1179	switch (mPlatformArchitecture)
1180	{
1181	case PlatformArchitecture_x86:
1182	{
1183	static const TpmType_T aTpmTypes[] =
1184	{
1185	TpmType_None,
1186	TpmType_v1_2,
1187	TpmType_v2_0
1188	};
1189	aSupportedTpmTypes.assign(aTpmTypes,
1190	aTpmTypes + RT_ELEMENTS(aTpmTypes));
1191	break;
1192	}
1193
1194	case PlatformArchitecture_ARM:
1195	{
1196	static const TpmType_T aTpmTypes[] =
1197	{
1198	TpmType_None
1199	};
1200	aSupportedTpmTypes.assign(aTpmTypes,
1201	aTpmTypes + RT_ELEMENTS(aTpmTypes));
1202	break;
1203	}
1204
1205	default:
1206	AssertFailedStmt(aSupportedTpmTypes.clear());
1207	break;
1208	}
1209
1210	return S_OK;
1211	}

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

source: vbox/trunk/src/VBox/Main/src-all/PlatformPropertiesImpl.cpp@ 104846

Download in other formats: