ConsoleImplConfigX86.cpp@ 100689

Last change on this file since 100689 was 100610, checked in by vboxsync, 21 months ago
Shared Clipboard/Main: Logging nit. bugref:9437
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 155.9 KB

Line
1	/* $Id: ConsoleImplConfigX86.cpp 100610 2023-07-17 17:12:13Z vboxsync $ */
2	/** @file
3	* VBox Console COM Class implementation - VM Configuration Bits.
4	*
5	* @remark We've split out the code that the 64-bit VC++ v8 compiler finds
6	* problematic to optimize so we can disable optimizations and later,
7	* perhaps, find a real solution for it (like rewriting the code and
8	* to stop resemble a tonne of spaghetti).
9	*/
10
11	/*
12	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
13	*
14	* This file is part of VirtualBox base platform packages, as
15	* available from https://www.virtualbox.org.
16	*
17	* This program is free software; you can redistribute it and/or
18	* modify it under the terms of the GNU General Public License
19	* as published by the Free Software Foundation, in version 3 of the
20	* License.
21	*
22	* This program is distributed in the hope that it will be useful, but
23	* WITHOUT ANY WARRANTY; without even the implied warranty of
24	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25	* General Public License for more details.
26	*
27	* You should have received a copy of the GNU General Public License
28	* along with this program; if not, see <https://www.gnu.org/licenses>.
29	*
30	* SPDX-License-Identifier: GPL-3.0-only
31	*/
32
33
34	/*********************************************************************************************************************************
35	* Header Files *
36	*********************************************************************************************************************************/
37	#define LOG_GROUP LOG_GROUP_MAIN_CONSOLE
38	#include "LoggingNew.h"
39
40	// VBoxNetCfg-win.h needs winsock2.h and thus MUST be included before any other
41	// header file includes Windows.h.
42	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
43	# include <VBox/VBoxNetCfg-win.h>
44	#endif
45
46	#include "ConsoleImpl.h"
47	#include "DisplayImpl.h"
48	#include "NvramStoreImpl.h"
49	#ifdef VBOX_WITH_SHARED_CLIPBOARD
50	# include "GuestShClPrivate.h"
51	#endif
52	#ifdef VBOX_WITH_DRAG_AND_DROP
53	# include "GuestImpl.h"
54	# include "GuestDnDPrivate.h"
55	#endif
56	#include "VMMDev.h"
57	#include "Global.h"
58	#ifdef VBOX_WITH_PCI_PASSTHROUGH
59	# include "PCIRawDevImpl.h"
60	#endif
61
62	// generated header
63	#include "SchemaDefs.h"
64
65	#include "AutoCaller.h"
66
67	#include <iprt/base64.h>
68	#include <iprt/buildconfig.h>
69	#include <iprt/ctype.h>
70	#include <iprt/dir.h>
71	#include <iprt/file.h>
72	#include <iprt/param.h>
73	#include <iprt/path.h>
74	#include <iprt/string.h>
75	#include <iprt/system.h>
76	#if 0 /* enable to play with lots of memory. */
77	# include <iprt/env.h>
78	#endif
79	#include <iprt/stream.h>
80
81	#include <iprt/http.h>
82	#include <iprt/socket.h>
83	#include <iprt/uri.h>
84
85	#include <VBox/vmm/vmmr3vtable.h>
86	#include <VBox/vmm/vmapi.h>
87	#include <VBox/err.h>
88	#include <VBox/param.h>
89	#include <VBox/settings.h> /* For MachineConfigFile::getHostDefaultAudioDriver(). */
90	#include <VBox/vmm/pdmapi.h> /* For PDMR3DriverAttach/PDMR3DriverDetach. */
91	#include <VBox/vmm/pdmusb.h> /* For PDMR3UsbCreateEmulatedDevice. */
92	#include <VBox/vmm/pdmdev.h> /* For PDMAPICMODE enum. */
93	#include <VBox/vmm/pdmstorageifs.h>
94	#include <VBox/vmm/gcm.h>
95	#include <VBox/version.h>
96	#ifdef VBOX_WITH_SHARED_CLIPBOARD
97	# include <VBox/HostServices/VBoxClipboardSvc.h>
98	#endif
99	#ifdef VBOX_WITH_GUEST_PROPS
100	# include <VBox/HostServices/GuestPropertySvc.h>
101	# include <VBox/com/defs.h>
102	# include <VBox/com/array.h>
103	# include <vector>
104	#endif /* VBOX_WITH_GUEST_PROPS */
105	#include <VBox/intnet.h>
106
107	#include <VBox/com/com.h>
108	#include <VBox/com/string.h>
109	#include <VBox/com/array.h>
110
111	#ifdef VBOX_WITH_NETFLT
112	# if defined(RT_OS_SOLARIS)
113	# include <zone.h>
114	# elif defined(RT_OS_LINUX)
115	# include <unistd.h>
116	# include <sys/ioctl.h>
117	# include <sys/socket.h>
118	# include <linux/types.h>
119	# include <linux/if.h>
120	# elif defined(RT_OS_FREEBSD)
121	# include <unistd.h>
122	# include <sys/types.h>
123	# include <sys/ioctl.h>
124	# include <sys/socket.h>
125	# include <net/if.h>
126	# include <net80211/ieee80211_ioctl.h>
127	# endif
128	# if defined(RT_OS_WINDOWS)
129	# include <iprt/win/ntddndis.h>
130	# include <devguid.h>
131	# else
132	# include <HostNetworkInterfaceImpl.h>
133	# include <netif.h>
134	# include <stdlib.h>
135	# endif
136	#endif /* VBOX_WITH_NETFLT */
137
138	#ifdef VBOX_WITH_AUDIO_VRDE
139	# include "DrvAudioVRDE.h"
140	#endif
141	#ifdef VBOX_WITH_AUDIO_RECORDING
142	# include "DrvAudioRec.h"
143	#endif
144	#include "NetworkServiceRunner.h"
145	#include "BusAssignmentManager.h"
146	#ifdef VBOX_WITH_EXTPACK
147	# include "ExtPackManagerImpl.h"
148	#endif
149
150
151	/*********************************************************************************************************************************
152	* Internal Functions *
153	*********************************************************************************************************************************/
154
155	/* Darwin compile kludge */
156	#undef PVM
157
158	/* Comment out the following line to remove VMWare compatibility hack. */
159	#define VMWARE_NET_IN_SLOT_11
160
161	/**
162	* Translate IDE StorageControllerType_T to string representation.
163	*/
164	static const char* controllerString(StorageControllerType_T enmType)
165	{
166	switch (enmType)
167	{
168	case StorageControllerType_PIIX3:
169	return "PIIX3";
170	case StorageControllerType_PIIX4:
171	return "PIIX4";
172	case StorageControllerType_ICH6:
173	return "ICH6";
174	default:
175	return "Unknown";
176	}
177	}
178
179	/**
180	* Simple class for storing network boot information.
181	*/
182	struct BootNic
183	{
184	ULONG mInstance;
185	PCIBusAddress mPCIAddress;
186
187	ULONG mBootPrio;
188	bool operator < (const BootNic &rhs) const
189	{
190	ULONG lval = mBootPrio - 1; /* 0 will wrap around and get the lowest priority. */
191	ULONG rval = rhs.mBootPrio - 1;
192	return lval < rval; /* Zero compares as highest number (lowest prio). */
193	}
194	};
195
196	#ifndef VBOX_WITH_EFI_IN_DD2
197	static int findEfiRom(IVirtualBox* vbox, FirmwareType_T aFirmwareType, Utf8Str *pEfiRomFile)
198	{
199	Bstr aFilePath, empty;
200	BOOL fPresent = FALSE;
201	HRESULT hrc = vbox->CheckFirmwarePresent(aFirmwareType, empty.raw(),
202	empty.asOutParam(), aFilePath.asOutParam(), &fPresent);
203	AssertComRCReturn(hrc, Global::vboxStatusCodeFromCOM(hrc));
204
205	if (!fPresent)
206	{
207	LogRel(("Failed to find an EFI ROM file.\n"));
208	return VERR_FILE_NOT_FOUND;
209	}
210
211	*pEfiRomFile = Utf8Str(aFilePath);
212
213	return VINF_SUCCESS;
214	}
215	#endif
216
217	/**
218	* @throws HRESULT on extra data retrival error.
219	*/
220	static int getSmcDeviceKey(IVirtualBox pVirtualBox, IMachine pMachine, Utf8Str pStrKey, bool pfGetKeyFromRealSMC)
221	{
222	*pfGetKeyFromRealSMC = false;
223
224	/*
225	* The extra data takes precedence (if non-zero).
226	*/
227	GetExtraDataBoth(pVirtualBox, pMachine, "VBoxInternal2/SmcDeviceKey", pStrKey);
228	if (pStrKey->isNotEmpty())
229	return VINF_SUCCESS;
230
231	#ifdef RT_OS_DARWIN
232
233	/*
234	* Work done in EFI/DevSmc
235	*/
236	*pfGetKeyFromRealSMC = true;
237	int vrc = VINF_SUCCESS;
238
239	#else
240	/*
241	* Is it apple hardware in bootcamp?
242	*/
243	/** @todo implement + test RTSYSDMISTR_MANUFACTURER on all hosts.
244	* Currently falling back on the product name. */
245	char szManufacturer[256];
246	szManufacturer[0] = '\0';
247	RTSystemQueryDmiString(RTSYSDMISTR_MANUFACTURER, szManufacturer, sizeof(szManufacturer));
248	if (szManufacturer[0] != '\0')
249	{
250	if ( !strcmp(szManufacturer, "Apple Computer, Inc.")
251	\|\| !strcmp(szManufacturer, "Apple Inc.")
252	)
253	*pfGetKeyFromRealSMC = true;
254	}
255	else
256	{
257	char szProdName[256];
258	szProdName[0] = '\0';
259	RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_NAME, szProdName, sizeof(szProdName));
260	if ( ( !strncmp(szProdName, RT_STR_TUPLE("Mac"))
261	\|\| !strncmp(szProdName, RT_STR_TUPLE("iMac"))
262	\|\| !strncmp(szProdName, RT_STR_TUPLE("Xserve"))
263	)
264	&& !strchr(szProdName, ' ') /* no spaces */
265	&& RT_C_IS_DIGIT(szProdName[strlen(szProdName) - 1]) /* version number */
266	)
267	*pfGetKeyFromRealSMC = true;
268	}
269
270	int vrc = VINF_SUCCESS;
271	#endif
272
273	return vrc;
274	}
275
276
277	/*
278	* VC++ 8 / amd64 has some serious trouble with the next functions.
279	* As a temporary measure, we'll drop global optimizations.
280	*/
281	#if defined(_MSC_VER) && defined(RT_ARCH_AMD64)
282	# if _MSC_VER >= RT_MSC_VER_VC80 && _MSC_VER < RT_MSC_VER_VC100
283	# pragma optimize("g", off)
284	# endif
285	#endif
286
287	/** Helper that finds out the next HBA port used
288	*/
289	static LONG GetNextUsedPort(LONG aPortUsed[30], LONG lBaseVal, uint32_t u32Size)
290	{
291	LONG lNextPortUsed = 30;
292	for (size_t j = 0; j < u32Size; ++j)
293	{
294	if ( aPortUsed[j] > lBaseVal
295	&& aPortUsed[j] <= lNextPortUsed)
296	lNextPortUsed = aPortUsed[j];
297	}
298	return lNextPortUsed;
299	}
300
301	#define MAX_BIOS_LUN_COUNT 4
302
303	int Console::SetBiosDiskInfo(ComPtr<IMachine> pMachine, PCFGMNODE pCfg, PCFGMNODE pBiosCfg,
304	Bstr controllerName, const char * const s_apszBiosConfig[4])
305	{
306	RT_NOREF(pCfg);
307	HRESULT hrc;
308	#define MAX_DEVICES 30
309	#define H() AssertLogRelMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR)
310
311	LONG lPortLUN[MAX_BIOS_LUN_COUNT];
312	LONG lPortUsed[MAX_DEVICES];
313	uint32_t u32HDCount = 0;
314
315	/* init to max value */
316	lPortLUN[0] = MAX_DEVICES;
317
318	com::SafeIfaceArray<IMediumAttachment> atts;
319	hrc = pMachine->GetMediumAttachmentsOfController(controllerName.raw(),
320	ComSafeArrayAsOutParam(atts)); H();
321	size_t uNumAttachments = atts.size();
322	if (uNumAttachments > MAX_DEVICES)
323	{
324	LogRel(("Number of Attachments > Max=%d.\n", uNumAttachments));
325	uNumAttachments = MAX_DEVICES;
326	}
327
328	/* Find the relevant ports/IDs, i.e the ones to which a HD is attached. */
329	for (size_t j = 0; j < uNumAttachments; ++j)
330	{
331	IMediumAttachment *pMediumAtt = atts[j];
332	LONG lPortNum = 0;
333	hrc = pMediumAtt->COMGETTER(Port)(&lPortNum); H();
334	if (SUCCEEDED(hrc))
335	{
336	DeviceType_T lType;
337	hrc = pMediumAtt->COMGETTER(Type)(&lType); H();
338	if (SUCCEEDED(hrc) && lType == DeviceType_HardDisk)
339	{
340	/* find min port number used for HD */
341	if (lPortNum < lPortLUN[0])
342	lPortLUN[0] = lPortNum;
343	lPortUsed[u32HDCount++] = lPortNum;
344	LogFlowFunc(("HD port Count=%d\n", u32HDCount));
345	}
346	}
347	}
348
349
350	/* Pick only the top 4 used HD Ports as CMOS doesn't have space
351	* to save details for all 30 ports
352	*/
353	uint32_t u32MaxPortCount = MAX_BIOS_LUN_COUNT;
354	if (u32HDCount < MAX_BIOS_LUN_COUNT)
355	u32MaxPortCount = u32HDCount;
356	for (size_t j = 1; j < u32MaxPortCount; j++)
357	lPortLUN[j] = GetNextUsedPort(lPortUsed, lPortLUN[j-1], u32HDCount);
358	if (pBiosCfg)
359	{
360	for (size_t j = 0; j < u32MaxPortCount; j++)
361	{
362	InsertConfigInteger(pBiosCfg, s_apszBiosConfig[j], lPortLUN[j]);
363	LogFlowFunc(("Top %d HBA ports = %s, %d\n", j, s_apszBiosConfig[j], lPortLUN[j]));
364	}
365	}
366	return VINF_SUCCESS;
367	}
368
369	#ifdef VBOX_WITH_PCI_PASSTHROUGH
370	HRESULT Console::i_attachRawPCIDevices(PUVM pUVM, BusAssignmentManager *pBusMgr, PCFGMNODE pDevices)
371	{
372	# ifndef VBOX_WITH_EXTPACK
373	RT_NOREF(pUVM);
374	# endif
375	HRESULT hrc = S_OK;
376	PCFGMNODE pInst, pCfg, pLunL0, pLunL1;
377
378	SafeIfaceArray<IPCIDeviceAttachment> assignments;
379	ComPtr<IMachine> aMachine = i_machine();
380
381	hrc = aMachine->COMGETTER(PCIDeviceAssignments)(ComSafeArrayAsOutParam(assignments));
382	if ( hrc != S_OK
383	\|\| assignments.size() < 1)
384	return hrc;
385
386	/*
387	* PCI passthrough is only available if the proper ExtPack is installed.
388	*
389	* Note. Configuring PCI passthrough here and providing messages about
390	* the missing extpack isn't exactly clean, but it is a necessary evil
391	* to patch over legacy compatability issues introduced by the new
392	* distribution model.
393	*/
394	# ifdef VBOX_WITH_EXTPACK
395	static const char *s_pszPCIRawExtPackName = "Oracle VM VirtualBox Extension Pack";
396	if (!mptrExtPackManager->i_isExtPackUsable(s_pszPCIRawExtPackName))
397	/* Always fatal! */
398	return pVMM->pfnVMR3SetError(pUVM, VERR_NOT_FOUND, RT_SRC_POS,
399	N_("Implementation of the PCI passthrough framework not found!\n"
400	"The VM cannot be started. To fix this problem, either "
401	"install the '%s' or disable PCI passthrough via VBoxManage"),
402	s_pszPCIRawExtPackName);
403	# endif
404
405	/* Now actually add devices */
406	PCFGMNODE pPCIDevs = NULL;
407
408	if (assignments.size() > 0)
409	{
410	InsertConfigNode(pDevices, "pciraw", &pPCIDevs);
411
412	PCFGMNODE pRoot = CFGMR3GetParent(pDevices); Assert(pRoot);
413
414	/* Tell PGM to tell GPCIRaw about guest mappings. */
415	CFGMR3InsertNode(pRoot, "PGM", NULL);
416	InsertConfigInteger(CFGMR3GetChild(pRoot, "PGM"), "PciPassThrough", 1);
417
418	/*
419	* Currently, using IOMMU needed for PCI passthrough
420	* requires RAM preallocation.
421	*/
422	/** @todo check if we can lift this requirement */
423	CFGMR3RemoveValue(pRoot, "RamPreAlloc");
424	InsertConfigInteger(pRoot, "RamPreAlloc", 1);
425	}
426
427	for (size_t iDev = 0; iDev < assignments.size(); iDev++)
428	{
429	ComPtr<IPCIDeviceAttachment> const assignment = assignments[iDev];
430
431	LONG host;
432	hrc = assignment->COMGETTER(HostAddress)(&host); H();
433	LONG guest;
434	hrc = assignment->COMGETTER(GuestAddress)(&guest); H();
435	Bstr bstrDevName;
436	hrc = assignment->COMGETTER(Name)(bstrDevName.asOutParam()); H();
437
438	InsertConfigNodeF(pPCIDevs, &pInst, "%d", iDev);
439	InsertConfigInteger(pInst, "Trusted", 1);
440
441	PCIBusAddress HostPCIAddress(host);
442	Assert(HostPCIAddress.valid());
443	InsertConfigNode(pInst, "Config", &pCfg);
444	InsertConfigString(pCfg, "DeviceName", bstrDevName);
445
446	InsertConfigInteger(pCfg, "DetachHostDriver", 1);
447	InsertConfigInteger(pCfg, "HostPCIBusNo", HostPCIAddress.miBus);
448	InsertConfigInteger(pCfg, "HostPCIDeviceNo", HostPCIAddress.miDevice);
449	InsertConfigInteger(pCfg, "HostPCIFunctionNo", HostPCIAddress.miFn);
450
451	PCIBusAddress GuestPCIAddress(guest);
452	Assert(GuestPCIAddress.valid());
453	hrc = pBusMgr->assignHostPCIDevice("pciraw", pInst, HostPCIAddress, GuestPCIAddress, true);
454	if (hrc != S_OK)
455	return hrc;
456
457	InsertConfigInteger(pCfg, "GuestPCIBusNo", GuestPCIAddress.miBus);
458	InsertConfigInteger(pCfg, "GuestPCIDeviceNo", GuestPCIAddress.miDevice);
459	InsertConfigInteger(pCfg, "GuestPCIFunctionNo", GuestPCIAddress.miFn);
460
461	/* the driver */
462	InsertConfigNode(pInst, "LUN#0", &pLunL0);
463	InsertConfigString(pLunL0, "Driver", "pciraw");
464	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
465
466	/* the Main driver */
467	InsertConfigString(pLunL1, "Driver", "MainPciRaw");
468	InsertConfigNode(pLunL1, "Config", &pCfg);
469	PCIRawDev *pMainDev = new PCIRawDev(this);
470	# error This is not allowed any more
471	InsertConfigInteger(pCfg, "Object", (uintptr_t)pMainDev);
472	}
473
474	return hrc;
475	}
476	#endif
477
478
479	/**
480	* Worker for configConstructor.
481	*
482	* @return VBox status code.
483	* @param pUVM The user mode VM handle.
484	* @param pVM The cross context VM handle.
485	* @param pVMM The VMM vtable.
486	* @param pAlock The automatic lock instance. This is for when we have
487	* to leave it in order to avoid deadlocks (ext packs and
488	* more).
489	*/
490	int Console::i_configConstructorX86(PUVM pUVM, PVM pVM, PCVMMR3VTABLE pVMM, AutoWriteLock *pAlock)
491	{
492	RT_NOREF(pVM /* when everything is disabled */);
493	VMMDev *pVMMDev = m_pVMMDev; Assert(pVMMDev);
494	ComPtr<IMachine> pMachine = i_machine();
495
496	int vrc;
497	HRESULT hrc;
498	Utf8Str strTmp;
499	Bstr bstr;
500
501	#define H() AssertLogRelMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR)
502
503	/*
504	* Get necessary objects and frequently used parameters.
505	*/
506	ComPtr<IVirtualBox> virtualBox;
507	hrc = pMachine->COMGETTER(Parent)(virtualBox.asOutParam()); H();
508
509	ComPtr<IHost> host;
510	hrc = virtualBox->COMGETTER(Host)(host.asOutParam()); H();
511
512	ComPtr<ISystemProperties> systemProperties;
513	hrc = virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam()); H();
514
515	ComPtr<IBIOSSettings> biosSettings;
516	hrc = pMachine->COMGETTER(BIOSSettings)(biosSettings.asOutParam()); H();
517
518	ComPtr<INvramStore> nvramStore;
519	hrc = pMachine->COMGETTER(NonVolatileStore)(nvramStore.asOutParam()); H();
520
521	hrc = pMachine->COMGETTER(HardwareUUID)(bstr.asOutParam()); H();
522	RTUUID HardwareUuid;
523	vrc = RTUuidFromUtf16(&HardwareUuid, bstr.raw());
524	AssertRCReturn(vrc, vrc);
525
526	ULONG cRamMBs;
527	hrc = pMachine->COMGETTER(MemorySize)(&cRamMBs); H();
528	#if 0 /* enable to play with lots of memory. */
529	if (RTEnvExist("VBOX_RAM_SIZE"))
530	cRamMBs = RTStrToUInt64(RTEnvGet("VBOX_RAM_SIZE"));
531	#endif
532	uint64_t const cbRam = cRamMBs * (uint64_t)_1M;
533	uint32_t cbRamHole = MM_RAM_HOLE_SIZE_DEFAULT;
534	uint64_t uMcfgBase = 0;
535	uint32_t cbMcfgLength = 0;
536
537	ParavirtProvider_T enmParavirtProvider;
538	hrc = pMachine->GetEffectiveParavirtProvider(&enmParavirtProvider); H();
539
540	Bstr strParavirtDebug;
541	hrc = pMachine->COMGETTER(ParavirtDebug)(strParavirtDebug.asOutParam()); H();
542
543	BOOL fIOAPIC;
544	uint32_t uIoApicPciAddress = NIL_PCIBDF;
545	hrc = biosSettings->COMGETTER(IOAPICEnabled)(&fIOAPIC); H();
546
547	ChipsetType_T chipsetType;
548	hrc = pMachine->COMGETTER(ChipsetType)(&chipsetType); H();
549	if (chipsetType == ChipsetType_ICH9)
550	{
551	/* We'd better have 0x10000000 region, to cover 256 buses but this put
552	* too much load on hypervisor heap. Linux 4.8 currently complains with
553	* ``acpi PNP0A03:00: [Firmware Info]: MMCONFIG for domain 0000 [bus 00-3f]
554	* only partially covers this bridge'' */
555	cbMcfgLength = 0x4000000; //0x10000000;
556	cbRamHole += cbMcfgLength;
557	uMcfgBase = _4G - cbRamHole;
558	}
559
560	/* Get the CPU profile name. */
561	Bstr bstrCpuProfile;
562	hrc = pMachine->COMGETTER(CPUProfile)(bstrCpuProfile.asOutParam()); H();
563
564	/* Check if long mode is enabled. */
565	BOOL fIsGuest64Bit;
566	hrc = pMachine->GetCPUProperty(CPUPropertyType_LongMode, &fIsGuest64Bit); H();
567
568	/*
569	* Figure out the IOMMU config.
570	*/
571	#if defined(VBOX_WITH_IOMMU_AMD) \|\| defined(VBOX_WITH_IOMMU_INTEL)
572	IommuType_T enmIommuType;
573	hrc = pMachine->COMGETTER(IommuType)(&enmIommuType); H();
574
575	/* Resolve 'automatic' type to an Intel or AMD IOMMU based on the host CPU. */
576	if (enmIommuType == IommuType_Automatic)
577	{
578	if ( bstrCpuProfile.startsWith("AMD")
579	\|\| bstrCpuProfile.startsWith("Quad-Core AMD")
580	\|\| bstrCpuProfile.startsWith("Hygon"))
581	enmIommuType = IommuType_AMD;
582	else if (bstrCpuProfile.startsWith("Intel"))
583	{
584	if ( bstrCpuProfile.equals("Intel 8086")
585	\|\| bstrCpuProfile.equals("Intel 80186")
586	\|\| bstrCpuProfile.equals("Intel 80286")
587	\|\| bstrCpuProfile.equals("Intel 80386")
588	\|\| bstrCpuProfile.equals("Intel 80486"))
589	enmIommuType = IommuType_None;
590	else
591	enmIommuType = IommuType_Intel;
592	}
593	# if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
594	else if (ASMIsAmdCpu())
595	enmIommuType = IommuType_AMD;
596	else if (ASMIsIntelCpu())
597	enmIommuType = IommuType_Intel;
598	# endif
599	else
600	{
601	/** @todo Should we handle other CPUs like Shanghai, VIA etc. here? */
602	LogRel(("WARNING! Unrecognized CPU type, IOMMU disabled.\n"));
603	enmIommuType = IommuType_None;
604	}
605	}
606
607	if (enmIommuType == IommuType_AMD)
608	{
609	# ifdef VBOX_WITH_IOMMU_AMD
610	/*
611	* Reserve the specific PCI address of the "SB I/O APIC" when using
612	* an AMD IOMMU. Required by Linux guests, see @bugref{9654#c23}.
613	*/
614	uIoApicPciAddress = VBOX_PCI_BDF_SB_IOAPIC;
615	# else
616	LogRel(("WARNING! AMD IOMMU not supported, IOMMU disabled.\n"));
617	enmIommuType = IommuType_None;
618	# endif
619	}
620
621	if (enmIommuType == IommuType_Intel)
622	{
623	# ifdef VBOX_WITH_IOMMU_INTEL
624	/*
625	* Reserve a unique PCI address for the I/O APIC when using
626	* an Intel IOMMU. For convenience we use the same address as
627	* we do on AMD, see @bugref{9967#c13}.
628	*/
629	uIoApicPciAddress = VBOX_PCI_BDF_SB_IOAPIC;
630	# else
631	LogRel(("WARNING! Intel IOMMU not supported, IOMMU disabled.\n"));
632	enmIommuType = IommuType_None;
633	# endif
634	}
635
636	if ( enmIommuType == IommuType_AMD
637	\|\| enmIommuType == IommuType_Intel)
638	{
639	if (chipsetType != ChipsetType_ICH9)
640	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
641	N_("IOMMU uses MSIs which requires the ICH9 chipset implementation."));
642	if (!fIOAPIC)
643	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
644	N_("IOMMU requires an I/O APIC for remapping interrupts."));
645	}
646	#else
647	IommuType_T const enmIommuType = IommuType_None;
648	#endif
649
650	/* Instantiate the bus assignment manager. */
651	Assert(enmIommuType != IommuType_Automatic);
652	BusAssignmentManager *pBusMgr = mBusMgr = BusAssignmentManager::createInstance(pVMM, chipsetType, enmIommuType);
653
654	ULONG cCpus = 1;
655	hrc = pMachine->COMGETTER(CPUCount)(&cCpus); H();
656
657	ULONG ulCpuExecutionCap = 100;
658	hrc = pMachine->COMGETTER(CPUExecutionCap)(&ulCpuExecutionCap); H();
659
660	Bstr osTypeId;
661	hrc = pMachine->COMGETTER(OSTypeId)(osTypeId.asOutParam()); H();
662	LogRel(("Guest OS type: '%s'\n", Utf8Str(osTypeId).c_str()));
663
664	APICMode_T apicMode;
665	hrc = biosSettings->COMGETTER(APICMode)(&apicMode); H();
666	uint32_t uFwAPIC;
667	switch (apicMode)
668	{
669	case APICMode_Disabled:
670	uFwAPIC = 0;
671	break;
672	case APICMode_APIC:
673	uFwAPIC = 1;
674	break;
675	case APICMode_X2APIC:
676	uFwAPIC = 2;
677	break;
678	default:
679	AssertMsgFailed(("Invalid APICMode=%d\n", apicMode));
680	uFwAPIC = 1;
681	break;
682	}
683
684	ComPtr<IGuestOSType> pGuestOSType;
685	virtualBox->GetGuestOSType(osTypeId.raw(), pGuestOSType.asOutParam());
686
687	BOOL fOsXGuest = FALSE;
688	BOOL fWinGuest = FALSE;
689	BOOL fOs2Guest = FALSE;
690	BOOL fW9xGuest = FALSE;
691	BOOL fDosGuest = FALSE;
692	if (!pGuestOSType.isNull())
693	{
694	Bstr guestTypeFamilyId;
695	hrc = pGuestOSType->COMGETTER(FamilyId)(guestTypeFamilyId.asOutParam()); H();
696	fOsXGuest = guestTypeFamilyId == Bstr("MacOS");
697	fWinGuest = guestTypeFamilyId == Bstr("Windows");
698	fOs2Guest = osTypeId.startsWith("OS2");
699	fW9xGuest = osTypeId.startsWith("Windows9"); /* Does not include Windows Me. */
700	fDosGuest = osTypeId.startsWith("DOS") \|\| osTypeId.startsWith("Windows31");
701	}
702
703	ULONG maxNetworkAdapters;
704	hrc = systemProperties->GetMaxNetworkAdapters(chipsetType, &maxNetworkAdapters); H();
705
706	/*
707	* Get root node first.
708	* This is the only node in the tree.
709	*/
710	PCFGMNODE pRoot = pVMM->pfnCFGMR3GetRootU(pUVM);
711	Assert(pRoot);
712
713	// catching throws from InsertConfigString and friends.
714	try
715	{
716
717	/*
718	* Set the root (and VMM) level values.
719	*/
720	hrc = pMachine->COMGETTER(Name)(bstr.asOutParam()); H();
721	InsertConfigString(pRoot, "Name", bstr);
722	InsertConfigBytes(pRoot, "UUID", &HardwareUuid, sizeof(HardwareUuid));
723	InsertConfigInteger(pRoot, "RamSize", cbRam);
724	InsertConfigInteger(pRoot, "RamHoleSize", cbRamHole);
725	InsertConfigInteger(pRoot, "NumCPUs", cCpus);
726	InsertConfigInteger(pRoot, "CpuExecutionCap", ulCpuExecutionCap);
727	InsertConfigInteger(pRoot, "TimerMillies", 10);
728
729	BOOL fPageFusion = FALSE;
730	hrc = pMachine->COMGETTER(PageFusionEnabled)(&fPageFusion); H();
731	InsertConfigInteger(pRoot, "PageFusionAllowed", fPageFusion); /* boolean */
732
733	/* Not necessary, but makes sure this setting ends up in the release log. */
734	ULONG ulBalloonSize = 0;
735	hrc = pMachine->COMGETTER(MemoryBalloonSize)(&ulBalloonSize); H();
736	InsertConfigInteger(pRoot, "MemBalloonSize", ulBalloonSize);
737
738	/*
739	* EM values (before CPUM as it may need to set IemExecutesAll).
740	*/
741	PCFGMNODE pEM;
742	InsertConfigNode(pRoot, "EM", &pEM);
743
744	/* Triple fault behavior. */
745	BOOL fTripleFaultReset = false;
746	hrc = pMachine->GetCPUProperty(CPUPropertyType_TripleFaultReset, &fTripleFaultReset); H();
747	InsertConfigInteger(pEM, "TripleFaultReset", fTripleFaultReset);
748
749	/*
750	* CPUM values.
751	*/
752	PCFGMNODE pCPUM;
753	InsertConfigNode(pRoot, "CPUM", &pCPUM);
754	PCFGMNODE pIsaExts;
755	InsertConfigNode(pCPUM, "IsaExts", &pIsaExts);
756
757	/* Host CPUID leaf overrides. */
758	for (uint32_t iOrdinal = 0; iOrdinal < _4K; iOrdinal++)
759	{
760	ULONG uLeaf, uSubLeaf, uEax, uEbx, uEcx, uEdx;
761	hrc = pMachine->GetCPUIDLeafByOrdinal(iOrdinal, &uLeaf, &uSubLeaf, &uEax, &uEbx, &uEcx, &uEdx);
762	if (hrc == E_INVALIDARG)
763	break;
764	H();
765	PCFGMNODE pLeaf;
766	InsertConfigNode(pCPUM, Utf8StrFmt("HostCPUID/%RX32", uLeaf).c_str(), &pLeaf);
767	/** @todo Figure out how to tell the VMM about uSubLeaf */
768	InsertConfigInteger(pLeaf, "eax", uEax);
769	InsertConfigInteger(pLeaf, "ebx", uEbx);
770	InsertConfigInteger(pLeaf, "ecx", uEcx);
771	InsertConfigInteger(pLeaf, "edx", uEdx);
772	}
773
774	/* We must limit CPUID count for Windows NT 4, as otherwise it stops
775	with error 0x3e (MULTIPROCESSOR_CONFIGURATION_NOT_SUPPORTED). */
776	if (osTypeId == "WindowsNT4")
777	{
778	LogRel(("Limiting CPUID leaf count for NT4 guests\n"));
779	InsertConfigInteger(pCPUM, "NT4LeafLimit", true);
780	}
781
782	if (fOsXGuest)
783	{
784	/* Expose extended MWAIT features to Mac OS X guests. */
785	LogRel(("Using MWAIT extensions\n"));
786	InsertConfigInteger(pIsaExts, "MWaitExtensions", true);
787
788	/* Fake the CPU family/model so the guest works. This is partly
789	because older mac releases really doesn't work on newer cpus,
790	and partly because mac os x expects more from systems with newer
791	cpus (MSRs, power features, whatever). */
792	uint32_t uMaxIntelFamilyModelStep = UINT32_MAX;
793	if ( osTypeId == "MacOS"
794	\|\| osTypeId == "MacOS_64")
795	uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 0); /* Penryn / X5482. */
796	else if ( osTypeId == "MacOS106"
797	\|\| osTypeId == "MacOS106_64")
798	uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 0); /* Penryn / X5482 */
799	else if ( osTypeId == "MacOS107"
800	\|\| osTypeId == "MacOS107_64")
801	uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 0); /* Penryn / X5482 / /* @todo figure out
802	what is required here. */
803	else if ( osTypeId == "MacOS108"
804	\|\| osTypeId == "MacOS108_64")
805	uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 0); /* Penryn / X5482 / /* @todo figure out
806	what is required here. */
807	else if ( osTypeId == "MacOS109"
808	\|\| osTypeId == "MacOS109_64")
809	uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 0); /* Penryn / X5482 / /* @todo figure
810	out what is required here. */
811	if (uMaxIntelFamilyModelStep != UINT32_MAX)
812	InsertConfigInteger(pCPUM, "MaxIntelFamilyModelStep", uMaxIntelFamilyModelStep);
813	}
814
815	/* CPU Portability level, */
816	ULONG uCpuIdPortabilityLevel = 0;
817	hrc = pMachine->COMGETTER(CPUIDPortabilityLevel)(&uCpuIdPortabilityLevel); H();
818	InsertConfigInteger(pCPUM, "PortableCpuIdLevel", uCpuIdPortabilityLevel);
819
820	/* Physical Address Extension (PAE) */
821	BOOL fEnablePAE = false;
822	hrc = pMachine->GetCPUProperty(CPUPropertyType_PAE, &fEnablePAE); H();
823	fEnablePAE \|= fIsGuest64Bit;
824	InsertConfigInteger(pRoot, "EnablePAE", fEnablePAE);
825
826	/* 64-bit guests (long mode) */
827	InsertConfigInteger(pCPUM, "Enable64bit", fIsGuest64Bit);
828
829	/* APIC/X2APIC configuration */
830	BOOL fEnableAPIC = true;
831	BOOL fEnableX2APIC = true;
832	hrc = pMachine->GetCPUProperty(CPUPropertyType_APIC, &fEnableAPIC); H();
833	hrc = pMachine->GetCPUProperty(CPUPropertyType_X2APIC, &fEnableX2APIC); H();
834	if (fEnableX2APIC)
835	Assert(fEnableAPIC);
836
837	/* CPUM profile name. */
838	InsertConfigString(pCPUM, "GuestCpuName", bstrCpuProfile);
839
840	/*
841	* Temporary(?) hack to make sure we emulate the ancient 16-bit CPUs
842	* correctly. There are way too many #UDs we'll miss using VT-x,
843	* raw-mode or qemu for the 186 and 286, while we'll get undefined opcodes
844	* dead wrong on 8086 (see http://www.os2museum.com/wp/undocumented-8086-opcodes/).
845	*/
846	if ( bstrCpuProfile.equals("Intel 80386") /* just for now */
847	\|\| bstrCpuProfile.equals("Intel 80286")
848	\|\| bstrCpuProfile.equals("Intel 80186")
849	\|\| bstrCpuProfile.equals("Nec V20")
850	\|\| bstrCpuProfile.equals("Intel 8086") )
851	{
852	InsertConfigInteger(pEM, "IemExecutesAll", true);
853	if (!bstrCpuProfile.equals("Intel 80386"))
854	{
855	fEnableAPIC = false;
856	fIOAPIC = false;
857	}
858	fEnableX2APIC = false;
859	}
860
861	/* Adjust firmware APIC handling to stay within the VCPU limits. */
862	if (uFwAPIC == 2 && !fEnableX2APIC)
863	{
864	if (fEnableAPIC)
865	uFwAPIC = 1;
866	else
867	uFwAPIC = 0;
868	LogRel(("Limiting the firmware APIC level from x2APIC to %s\n", fEnableAPIC ? "APIC" : "Disabled"));
869	}
870	else if (uFwAPIC == 1 && !fEnableAPIC)
871	{
872	uFwAPIC = 0;
873	LogRel(("Limiting the firmware APIC level from APIC to Disabled\n"));
874	}
875
876	/* Speculation Control. */
877	BOOL fSpecCtrl = FALSE;
878	hrc = pMachine->GetCPUProperty(CPUPropertyType_SpecCtrl, &fSpecCtrl); H();
879	InsertConfigInteger(pCPUM, "SpecCtrl", fSpecCtrl);
880
881	/* Nested VT-x / AMD-V. */
882	BOOL fNestedHWVirt = FALSE;
883	hrc = pMachine->GetCPUProperty(CPUPropertyType_HWVirt, &fNestedHWVirt); H();
884	InsertConfigInteger(pCPUM, "NestedHWVirt", fNestedHWVirt ? true : false);
885
886	/*
887	* Hardware virtualization extensions.
888	*/
889	/* Sanitize valid/useful APIC combinations, see @bugref{8868}. */
890	if (!fEnableAPIC)
891	{
892	if (fIsGuest64Bit)
893	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
894	N_("Cannot disable the APIC for a 64-bit guest."));
895	if (cCpus > 1)
896	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
897	N_("Cannot disable the APIC for an SMP guest."));
898	if (fIOAPIC)
899	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
900	N_("Cannot disable the APIC when the I/O APIC is present."));
901	}
902
903	BOOL fHMEnabled;
904	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_Enabled, &fHMEnabled); H();
905	if (cCpus > 1 && !fHMEnabled)
906	{
907	LogRel(("Forced fHMEnabled to TRUE by SMP guest.\n"));
908	fHMEnabled = TRUE;
909	}
910
911	BOOL fHMForced;
912	fHMEnabled = fHMForced = TRUE;
913	LogRel(("fHMForced=true - No raw-mode support in this build!\n"));
914	if (!fHMForced) /* No need to query if already forced above. */
915	{
916	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_Force, &fHMForced); H();
917	if (fHMForced)
918	LogRel(("fHMForced=true - HWVirtExPropertyType_Force\n"));
919	}
920	InsertConfigInteger(pRoot, "HMEnabled", fHMEnabled);
921
922	/* /HM/xyz */
923	PCFGMNODE pHM;
924	InsertConfigNode(pRoot, "HM", &pHM);
925	InsertConfigInteger(pHM, "HMForced", fHMForced);
926	if (fHMEnabled)
927	{
928	/* Indicate whether 64-bit guests are supported or not. */
929	InsertConfigInteger(pHM, "64bitEnabled", fIsGuest64Bit);
930
931	/** @todo Not exactly pretty to check strings; VBOXOSTYPE would be better,
932	but that requires quite a bit of API change in Main. */
933	if ( fIOAPIC
934	&& ( osTypeId == "WindowsNT4"
935	\|\| osTypeId == "Windows2000"
936	\|\| osTypeId == "WindowsXP"
937	\|\| osTypeId == "Windows2003"))
938	{
939	/* Only allow TPR patching for NT, Win2k, XP and Windows Server 2003. (32 bits mode)
940	* We may want to consider adding more guest OSes (Solaris) later on.
941	*/
942	InsertConfigInteger(pHM, "TPRPatchingEnabled", 1);
943	}
944	}
945
946	/* HWVirtEx exclusive mode */
947	BOOL fHMExclusive = true;
948	hrc = systemProperties->COMGETTER(ExclusiveHwVirt)(&fHMExclusive); H();
949	InsertConfigInteger(pHM, "Exclusive", fHMExclusive);
950
951	/* Nested paging (VT-x/AMD-V) */
952	BOOL fEnableNestedPaging = false;
953	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &fEnableNestedPaging); H();
954	InsertConfigInteger(pHM, "EnableNestedPaging", fEnableNestedPaging);
955
956	/* Large pages; requires nested paging */
957	BOOL fEnableLargePages = false;
958	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &fEnableLargePages); H();
959	InsertConfigInteger(pHM, "EnableLargePages", fEnableLargePages);
960
961	/* VPID (VT-x) */
962	BOOL fEnableVPID = false;
963	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_VPID, &fEnableVPID); H();
964	InsertConfigInteger(pHM, "EnableVPID", fEnableVPID);
965
966	/* Unrestricted execution aka UX (VT-x) */
967	BOOL fEnableUX = false;
968	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, &fEnableUX); H();
969	InsertConfigInteger(pHM, "EnableUX", fEnableUX);
970
971	/* Virtualized VMSAVE/VMLOAD (AMD-V) */
972	BOOL fVirtVmsaveVmload = true;
973	hrc = host->GetProcessorFeature(ProcessorFeature_VirtVmsaveVmload, &fVirtVmsaveVmload); H();
974	InsertConfigInteger(pHM, "SvmVirtVmsaveVmload", fVirtVmsaveVmload);
975
976	/* Indirect branch prediction boundraries. */
977	BOOL fIBPBOnVMExit = false;
978	hrc = pMachine->GetCPUProperty(CPUPropertyType_IBPBOnVMExit, &fIBPBOnVMExit); H();
979	InsertConfigInteger(pHM, "IBPBOnVMExit", fIBPBOnVMExit);
980
981	BOOL fIBPBOnVMEntry = false;
982	hrc = pMachine->GetCPUProperty(CPUPropertyType_IBPBOnVMEntry, &fIBPBOnVMEntry); H();
983	InsertConfigInteger(pHM, "IBPBOnVMEntry", fIBPBOnVMEntry);
984
985	BOOL fSpecCtrlByHost = false;
986	hrc = pMachine->GetCPUProperty(CPUPropertyType_SpecCtrlByHost, &fSpecCtrlByHost); H();
987	InsertConfigInteger(pHM, "SpecCtrlByHost", fSpecCtrlByHost);
988
989	BOOL fL1DFlushOnSched = true;
990	hrc = pMachine->GetCPUProperty(CPUPropertyType_L1DFlushOnEMTScheduling, &fL1DFlushOnSched); H();
991	InsertConfigInteger(pHM, "L1DFlushOnSched", fL1DFlushOnSched);
992
993	BOOL fL1DFlushOnVMEntry = false;
994	hrc = pMachine->GetCPUProperty(CPUPropertyType_L1DFlushOnVMEntry, &fL1DFlushOnVMEntry); H();
995	InsertConfigInteger(pHM, "L1DFlushOnVMEntry", fL1DFlushOnVMEntry);
996
997	BOOL fMDSClearOnSched = true;
998	hrc = pMachine->GetCPUProperty(CPUPropertyType_MDSClearOnEMTScheduling, &fMDSClearOnSched); H();
999	InsertConfigInteger(pHM, "MDSClearOnSched", fMDSClearOnSched);
1000
1001	BOOL fMDSClearOnVMEntry = false;
1002	hrc = pMachine->GetCPUProperty(CPUPropertyType_MDSClearOnVMEntry, &fMDSClearOnVMEntry); H();
1003	InsertConfigInteger(pHM, "MDSClearOnVMEntry", fMDSClearOnVMEntry);
1004
1005	/* Reset overwrite. */
1006	mfTurnResetIntoPowerOff = GetExtraDataBoth(virtualBox, pMachine,
1007	"VBoxInternal2/TurnResetIntoPowerOff", &strTmp)->equals("1");
1008	if (mfTurnResetIntoPowerOff)
1009	InsertConfigInteger(pRoot, "PowerOffInsteadOfReset", 1);
1010
1011	/* Use NEM rather than HM. */
1012	BOOL fUseNativeApi = false;
1013	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_UseNativeApi, &fUseNativeApi); H();
1014	InsertConfigInteger(pHM, "UseNEMInstead", fUseNativeApi);
1015
1016	/* Enable workaround for missing TLB flush for OS/2 guests, see ticketref:20625. */
1017	if (osTypeId.startsWith("OS2"))
1018	InsertConfigInteger(pHM, "MissingOS2TlbFlushWorkaround", 1);
1019
1020	/*
1021	* NEM
1022	*/
1023	PCFGMNODE pNEM;
1024	InsertConfigNode(pRoot, "NEM", &pNEM);
1025	InsertConfigInteger(pNEM, "Allow64BitGuests", fIsGuest64Bit);
1026
1027	/*
1028	* Paravirt. provider.
1029	*/
1030	PCFGMNODE pParavirtNode;
1031	InsertConfigNode(pRoot, "GIM", &pParavirtNode);
1032	const char *pcszParavirtProvider;
1033	bool fGimDeviceNeeded = true;
1034	switch (enmParavirtProvider)
1035	{
1036	case ParavirtProvider_None:
1037	pcszParavirtProvider = "None";
1038	fGimDeviceNeeded = false;
1039	break;
1040
1041	case ParavirtProvider_Minimal:
1042	pcszParavirtProvider = "Minimal";
1043	break;
1044
1045	case ParavirtProvider_HyperV:
1046	pcszParavirtProvider = "HyperV";
1047	break;
1048
1049	case ParavirtProvider_KVM:
1050	pcszParavirtProvider = "KVM";
1051	break;
1052
1053	default:
1054	AssertMsgFailed(("Invalid enmParavirtProvider=%d\n", enmParavirtProvider));
1055	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS, N_("Invalid paravirt. provider '%d'"),
1056	enmParavirtProvider);
1057	}
1058	InsertConfigString(pParavirtNode, "Provider", pcszParavirtProvider);
1059
1060	/*
1061	* Parse paravirt. debug options.
1062	*/
1063	bool fGimDebug = false;
1064	com::Utf8Str strGimDebugAddress = "127.0.0.1";
1065	uint32_t uGimDebugPort = 50000;
1066	if (strParavirtDebug.isNotEmpty())
1067	{
1068	/* Hyper-V debug options. */
1069	if (enmParavirtProvider == ParavirtProvider_HyperV)
1070	{
1071	bool fGimHvDebug = false;
1072	com::Utf8Str strGimHvVendor;
1073	bool fGimHvVsIf = false;
1074	bool fGimHvHypercallIf = false;
1075
1076	size_t uPos = 0;
1077	com::Utf8Str strDebugOptions = strParavirtDebug;
1078	com::Utf8Str strKey;
1079	com::Utf8Str strVal;
1080	while ((uPos = strDebugOptions.parseKeyValue(strKey, strVal, uPos)) != com::Utf8Str::npos)
1081	{
1082	if (strKey == "enabled")
1083	{
1084	if (strVal.toUInt32() == 1)
1085	{
1086	/* Apply defaults.
1087	The defaults are documented in the user manual,
1088	changes need to be reflected accordingly. */
1089	fGimHvDebug = true;
1090	strGimHvVendor = "Microsoft Hv";
1091	fGimHvVsIf = true;
1092	fGimHvHypercallIf = false;
1093	}
1094	/* else: ignore, i.e. don't assert below with 'enabled=0'. */
1095	}
1096	else if (strKey == "address")
1097	strGimDebugAddress = strVal;
1098	else if (strKey == "port")
1099	uGimDebugPort = strVal.toUInt32();
1100	else if (strKey == "vendor")
1101	strGimHvVendor = strVal;
1102	else if (strKey == "vsinterface")
1103	fGimHvVsIf = RT_BOOL(strVal.toUInt32());
1104	else if (strKey == "hypercallinterface")
1105	fGimHvHypercallIf = RT_BOOL(strVal.toUInt32());
1106	else
1107	{
1108	AssertMsgFailed(("Unrecognized Hyper-V debug option '%s'\n", strKey.c_str()));
1109	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
1110	N_("Unrecognized Hyper-V debug option '%s' in '%s'"), strKey.c_str(),
1111	strDebugOptions.c_str());
1112	}
1113	}
1114
1115	/* Update HyperV CFGM node with active debug options. */
1116	if (fGimHvDebug)
1117	{
1118	PCFGMNODE pHvNode;
1119	InsertConfigNode(pParavirtNode, "HyperV", &pHvNode);
1120	InsertConfigString(pHvNode, "VendorID", strGimHvVendor);
1121	InsertConfigInteger(pHvNode, "VSInterface", fGimHvVsIf ? 1 : 0);
1122	InsertConfigInteger(pHvNode, "HypercallDebugInterface", fGimHvHypercallIf ? 1 : 0);
1123	fGimDebug = true;
1124	}
1125	}
1126	}
1127
1128	/*
1129	* Guest Compatibility Manager.
1130	*/
1131	PCFGMNODE pGcmNode;
1132	uint32_t u32FixerSet = 0;
1133	InsertConfigNode(pRoot, "GCM", &pGcmNode);
1134	/* OS/2 and Win9x guests can run DOS apps so they get
1135	* the DOS specific fixes as well.
1136	*/
1137	if (fOs2Guest)
1138	u32FixerSet = GCMFIXER_DBZ_DOS \| GCMFIXER_DBZ_OS2;
1139	else if (fW9xGuest)
1140	u32FixerSet = GCMFIXER_DBZ_DOS \| GCMFIXER_DBZ_WIN9X;
1141	else if (fDosGuest)
1142	u32FixerSet = GCMFIXER_DBZ_DOS;
1143	InsertConfigInteger(pGcmNode, "FixerSet", u32FixerSet);
1144
1145
1146	/*
1147	* MM values.
1148	*/
1149	PCFGMNODE pMM;
1150	InsertConfigNode(pRoot, "MM", &pMM);
1151	InsertConfigInteger(pMM, "CanUseLargerHeap", chipsetType == ChipsetType_ICH9);
1152
1153	/*
1154	* PDM config.
1155	* Load drivers in VBoxC.[so\|dll]
1156	*/
1157	PCFGMNODE pPDM;
1158	PCFGMNODE pNode;
1159	PCFGMNODE pMod;
1160	InsertConfigNode(pRoot, "PDM", &pPDM);
1161	InsertConfigNode(pPDM, "Devices", &pNode);
1162	InsertConfigNode(pPDM, "Drivers", &pNode);
1163	InsertConfigNode(pNode, "VBoxC", &pMod);
1164	#ifdef VBOX_WITH_XPCOM
1165	// VBoxC is located in the components subdirectory
1166	char szPathVBoxC[RTPATH_MAX];
1167	vrc = RTPathAppPrivateArch(szPathVBoxC, RTPATH_MAX - sizeof("/components/VBoxC")); AssertRC(vrc);
1168	strcat(szPathVBoxC, "/components/VBoxC");
1169	InsertConfigString(pMod, "Path", szPathVBoxC);
1170	#else
1171	InsertConfigString(pMod, "Path", "VBoxC");
1172	#endif
1173
1174
1175	/*
1176	* Block cache settings.
1177	*/
1178	PCFGMNODE pPDMBlkCache;
1179	InsertConfigNode(pPDM, "BlkCache", &pPDMBlkCache);
1180
1181	/* I/O cache size */
1182	ULONG ioCacheSize = 5;
1183	hrc = pMachine->COMGETTER(IOCacheSize)(&ioCacheSize); H();
1184	InsertConfigInteger(pPDMBlkCache, "CacheSize", ioCacheSize * _1M);
1185
1186	/*
1187	* Bandwidth groups.
1188	*/
1189	ComPtr<IBandwidthControl> bwCtrl;
1190
1191	hrc = pMachine->COMGETTER(BandwidthControl)(bwCtrl.asOutParam()); H();
1192
1193	com::SafeIfaceArray<IBandwidthGroup> bwGroups;
1194	hrc = bwCtrl->GetAllBandwidthGroups(ComSafeArrayAsOutParam(bwGroups)); H();
1195
1196	PCFGMNODE pAc;
1197	InsertConfigNode(pPDM, "AsyncCompletion", &pAc);
1198	PCFGMNODE pAcFile;
1199	InsertConfigNode(pAc, "File", &pAcFile);
1200	PCFGMNODE pAcFileBwGroups;
1201	InsertConfigNode(pAcFile, "BwGroups", &pAcFileBwGroups);
1202	#ifdef VBOX_WITH_NETSHAPER
1203	PCFGMNODE pNetworkShaper;
1204	InsertConfigNode(pPDM, "NetworkShaper", &pNetworkShaper);
1205	PCFGMNODE pNetworkBwGroups;
1206	InsertConfigNode(pNetworkShaper, "BwGroups", &pNetworkBwGroups);
1207	#endif /* VBOX_WITH_NETSHAPER */
1208
1209	for (size_t i = 0; i < bwGroups.size(); i++)
1210	{
1211	Bstr strName;
1212	hrc = bwGroups[i]->COMGETTER(Name)(strName.asOutParam()); H();
1213	if (strName.isEmpty())
1214	return pVMM->pfnVMR3SetError(pUVM, VERR_CFGM_NO_NODE, RT_SRC_POS, N_("No bandwidth group name specified"));
1215
1216	BandwidthGroupType_T enmType = BandwidthGroupType_Null;
1217	hrc = bwGroups[i]->COMGETTER(Type)(&enmType); H();
1218	LONG64 cMaxBytesPerSec = 0;
1219	hrc = bwGroups[i]->COMGETTER(MaxBytesPerSec)(&cMaxBytesPerSec); H();
1220
1221	if (enmType == BandwidthGroupType_Disk)
1222	{
1223	PCFGMNODE pBwGroup;
1224	InsertConfigNode(pAcFileBwGroups, Utf8Str(strName).c_str(), &pBwGroup);
1225	InsertConfigInteger(pBwGroup, "Max", cMaxBytesPerSec);
1226	InsertConfigInteger(pBwGroup, "Start", cMaxBytesPerSec);
1227	InsertConfigInteger(pBwGroup, "Step", 0);
1228	}
1229	#ifdef VBOX_WITH_NETSHAPER
1230	else if (enmType == BandwidthGroupType_Network)
1231	{
1232	/* Network bandwidth groups. */
1233	PCFGMNODE pBwGroup;
1234	InsertConfigNode(pNetworkBwGroups, Utf8Str(strName).c_str(), &pBwGroup);
1235	InsertConfigInteger(pBwGroup, "Max", cMaxBytesPerSec);
1236	}
1237	#endif /* VBOX_WITH_NETSHAPER */
1238	}
1239
1240	/*
1241	* Devices
1242	*/
1243	PCFGMNODE pDevices = NULL; /* /Devices */
1244	PCFGMNODE pDev = NULL; /* /Devices/Dev/ */
1245	PCFGMNODE pInst = NULL; /* /Devices/Dev/0/ */
1246	PCFGMNODE pCfg = NULL; /* /Devices/Dev/.../Config/ */
1247	PCFGMNODE pLunL0 = NULL; /* /Devices/Dev/0/LUN#0/ */
1248	PCFGMNODE pLunL1 = NULL; /* /Devices/Dev/0/LUN#0/AttachedDriver/ */
1249	PCFGMNODE pBiosCfg = NULL; /* /Devices/pcbios/0/Config/ */
1250	PCFGMNODE pNetBootCfg = NULL; /* /Devices/pcbios/0/Config/NetBoot/ */
1251
1252	InsertConfigNode(pRoot, "Devices", &pDevices);
1253
1254	/*
1255	* GIM Device
1256	*/
1257	if (fGimDeviceNeeded)
1258	{
1259	InsertConfigNode(pDevices, "GIMDev", &pDev);
1260	InsertConfigNode(pDev, "0", &pInst);
1261	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1262	//InsertConfigNode(pInst, "Config", &pCfg);
1263
1264	if (fGimDebug)
1265	{
1266	InsertConfigNode(pInst, "LUN#998", &pLunL0);
1267	InsertConfigString(pLunL0, "Driver", "UDP");
1268	InsertConfigNode(pLunL0, "Config", &pLunL1);
1269	InsertConfigString(pLunL1, "ServerAddress", strGimDebugAddress);
1270	InsertConfigInteger(pLunL1, "ServerPort", uGimDebugPort);
1271	}
1272	}
1273
1274	/*
1275	* PC Arch.
1276	*/
1277	InsertConfigNode(pDevices, "pcarch", &pDev);
1278	InsertConfigNode(pDev, "0", &pInst);
1279	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1280	InsertConfigNode(pInst, "Config", &pCfg);
1281
1282	/*
1283	* The time offset
1284	*/
1285	LONG64 timeOffset;
1286	hrc = biosSettings->COMGETTER(TimeOffset)(&timeOffset); H();
1287	PCFGMNODE pTMNode;
1288	InsertConfigNode(pRoot, "TM", &pTMNode);
1289	InsertConfigInteger(pTMNode, "UTCOffset", timeOffset * 1000000);
1290
1291	/*
1292	* DMA
1293	*/
1294	InsertConfigNode(pDevices, "8237A", &pDev);
1295	InsertConfigNode(pDev, "0", &pInst);
1296	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1297
1298	/*
1299	* PCI buses.
1300	*/
1301	uint32_t uIocPCIAddress, uHbcPCIAddress;
1302	switch (chipsetType)
1303	{
1304	default:
1305	AssertFailed();
1306	RT_FALL_THRU();
1307	case ChipsetType_PIIX3:
1308	/* Create the base for adding bridges on demand */
1309	InsertConfigNode(pDevices, "pcibridge", NULL);
1310
1311	InsertConfigNode(pDevices, "pci", &pDev);
1312	uHbcPCIAddress = (0x0 << 16) \| 0;
1313	uIocPCIAddress = (0x1 << 16) \| 0; // ISA controller
1314	break;
1315	case ChipsetType_ICH9:
1316	/* Create the base for adding bridges on demand */
1317	InsertConfigNode(pDevices, "ich9pcibridge", NULL);
1318
1319	InsertConfigNode(pDevices, "ich9pci", &pDev);
1320	uHbcPCIAddress = (0x1e << 16) \| 0;
1321	uIocPCIAddress = (0x1f << 16) \| 0; // LPC controller
1322	break;
1323	}
1324	InsertConfigNode(pDev, "0", &pInst);
1325	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1326	InsertConfigNode(pInst, "Config", &pCfg);
1327	InsertConfigInteger(pCfg, "IOAPIC", fIOAPIC);
1328	if (chipsetType == ChipsetType_ICH9)
1329	{
1330	/* Provide MCFG info */
1331	InsertConfigInteger(pCfg, "McfgBase", uMcfgBase);
1332	InsertConfigInteger(pCfg, "McfgLength", cbMcfgLength);
1333
1334	#ifdef VBOX_WITH_PCI_PASSTHROUGH
1335	/* Add PCI passthrough devices */
1336	hrc = i_attachRawPCIDevices(pUVM, pBusMgr, pDevices); H();
1337	#endif
1338
1339	if (enmIommuType == IommuType_AMD)
1340	{
1341	/* AMD IOMMU. */
1342	InsertConfigNode(pDevices, "iommu-amd", &pDev);
1343	InsertConfigNode(pDev, "0", &pInst);
1344	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1345	InsertConfigNode(pInst, "Config", &pCfg);
1346	hrc = pBusMgr->assignPCIDevice("iommu-amd", pInst); H();
1347
1348	/* The AMD IOMMU device needs to know which PCI slot it's in, see @bugref{9654#c104}. */
1349	{
1350	PCIBusAddress Address;
1351	if (pBusMgr->findPCIAddress("iommu-amd", 0, Address))
1352	{
1353	uint32_t const u32IommuAddress = (Address.miDevice << 16) \| Address.miFn;
1354	InsertConfigInteger(pCfg, "PCIAddress", u32IommuAddress);
1355	}
1356	else
1357	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
1358	N_("Failed to find PCI address of the assigned IOMMU device!"));
1359	}
1360
1361	PCIBusAddress PCIAddr = PCIBusAddress((int32_t)uIoApicPciAddress);
1362	hrc = pBusMgr->assignPCIDevice("sb-ioapic", NULL /* pCfg /, PCIAddr, true /fGuestAddressRequired*/); H();
1363	}
1364	else if (enmIommuType == IommuType_Intel)
1365	{
1366	/* Intel IOMMU. */
1367	InsertConfigNode(pDevices, "iommu-intel", &pDev);
1368	InsertConfigNode(pDev, "0", &pInst);
1369	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1370	InsertConfigNode(pInst, "Config", &pCfg);
1371	hrc = pBusMgr->assignPCIDevice("iommu-intel", pInst); H();
1372
1373	PCIBusAddress PCIAddr = PCIBusAddress((int32_t)uIoApicPciAddress);
1374	hrc = pBusMgr->assignPCIDevice("sb-ioapic", NULL /* pCfg /, PCIAddr, true /fGuestAddressRequired*/); H();
1375	}
1376	}
1377
1378	/*
1379	* Enable the following devices: HPET, SMC and LPC on MacOS X guests or on ICH9 chipset
1380	*/
1381
1382	/*
1383	* High Precision Event Timer (HPET)
1384	*/
1385	BOOL fHPETEnabled;
1386	/* Other guests may wish to use HPET too, but MacOS X not functional without it */
1387	hrc = pMachine->COMGETTER(HPETEnabled)(&fHPETEnabled); H();
1388	/* so always enable HPET in extended profile */
1389	fHPETEnabled \|= fOsXGuest;
1390	/* HPET is always present on ICH9 */
1391	fHPETEnabled \|= (chipsetType == ChipsetType_ICH9);
1392	if (fHPETEnabled)
1393	{
1394	InsertConfigNode(pDevices, "hpet", &pDev);
1395	InsertConfigNode(pDev, "0", &pInst);
1396	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1397	InsertConfigNode(pInst, "Config", &pCfg);
1398	InsertConfigInteger(pCfg, "ICH9", (chipsetType == ChipsetType_ICH9) ? 1 : 0); /* boolean */
1399	}
1400
1401	/*
1402	* System Management Controller (SMC)
1403	*/
1404	BOOL fSmcEnabled;
1405	fSmcEnabled = fOsXGuest;
1406	if (fSmcEnabled)
1407	{
1408	InsertConfigNode(pDevices, "smc", &pDev);
1409	InsertConfigNode(pDev, "0", &pInst);
1410	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1411	InsertConfigNode(pInst, "Config", &pCfg);
1412
1413	bool fGetKeyFromRealSMC;
1414	Utf8Str strKey;
1415	vrc = getSmcDeviceKey(virtualBox, pMachine, &strKey, &fGetKeyFromRealSMC);
1416	AssertRCReturn(vrc, vrc);
1417
1418	if (!fGetKeyFromRealSMC)
1419	InsertConfigString(pCfg, "DeviceKey", strKey);
1420	InsertConfigInteger(pCfg, "GetKeyFromRealSMC", fGetKeyFromRealSMC);
1421	}
1422
1423	/*
1424	* Low Pin Count (LPC) bus
1425	*/
1426	BOOL fLpcEnabled;
1427	/** @todo implement appropriate getter */
1428	fLpcEnabled = fOsXGuest \|\| (chipsetType == ChipsetType_ICH9);
1429	if (fLpcEnabled)
1430	{
1431	InsertConfigNode(pDevices, "lpc", &pDev);
1432	InsertConfigNode(pDev, "0", &pInst);
1433	hrc = pBusMgr->assignPCIDevice("lpc", pInst); H();
1434	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1435	}
1436
1437	BOOL fShowRtc;
1438	fShowRtc = fOsXGuest \|\| (chipsetType == ChipsetType_ICH9);
1439
1440	/*
1441	* PS/2 keyboard & mouse.
1442	*/
1443	InsertConfigNode(pDevices, "pckbd", &pDev);
1444	InsertConfigNode(pDev, "0", &pInst);
1445	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1446	InsertConfigNode(pInst, "Config", &pCfg);
1447
1448	KeyboardHIDType_T aKbdHID;
1449	hrc = pMachine->COMGETTER(KeyboardHIDType)(&aKbdHID); H();
1450	if (aKbdHID != KeyboardHIDType_None)
1451	{
1452	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1453	InsertConfigString(pLunL0, "Driver", "KeyboardQueue");
1454	InsertConfigNode(pLunL0, "Config", &pCfg);
1455	InsertConfigInteger(pCfg, "QueueSize", 64);
1456
1457	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
1458	InsertConfigString(pLunL1, "Driver", "MainKeyboard");
1459	}
1460
1461	PointingHIDType_T aPointingHID;
1462	hrc = pMachine->COMGETTER(PointingHIDType)(&aPointingHID); H();
1463	if (aPointingHID != PointingHIDType_None)
1464	{
1465	InsertConfigNode(pInst, "LUN#1", &pLunL0);
1466	InsertConfigString(pLunL0, "Driver", "MouseQueue");
1467	InsertConfigNode(pLunL0, "Config", &pCfg);
1468	InsertConfigInteger(pCfg, "QueueSize", 128);
1469
1470	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
1471	InsertConfigString(pLunL1, "Driver", "MainMouse");
1472	}
1473
1474	/*
1475	* i8254 Programmable Interval Timer And Dummy Speaker
1476	*/
1477	InsertConfigNode(pDevices, "i8254", &pDev);
1478	InsertConfigNode(pDev, "0", &pInst);
1479	InsertConfigNode(pInst, "Config", &pCfg);
1480	#ifdef DEBUG
1481	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1482	#endif
1483
1484	/*
1485	* i8259 Programmable Interrupt Controller.
1486	*/
1487	InsertConfigNode(pDevices, "i8259", &pDev);
1488	InsertConfigNode(pDev, "0", &pInst);
1489	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1490	InsertConfigNode(pInst, "Config", &pCfg);
1491
1492	/*
1493	* Advanced Programmable Interrupt Controller.
1494	* SMP: Each CPU has a LAPIC, but we have a single device representing all LAPICs states,
1495	* thus only single insert
1496	*/
1497	if (fEnableAPIC)
1498	{
1499	InsertConfigNode(pDevices, "apic", &pDev);
1500	InsertConfigNode(pDev, "0", &pInst);
1501	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1502	InsertConfigNode(pInst, "Config", &pCfg);
1503	InsertConfigInteger(pCfg, "IOAPIC", fIOAPIC);
1504	PDMAPICMODE enmAPICMode = PDMAPICMODE_APIC;
1505	if (fEnableX2APIC)
1506	enmAPICMode = PDMAPICMODE_X2APIC;
1507	else if (!fEnableAPIC)
1508	enmAPICMode = PDMAPICMODE_NONE;
1509	InsertConfigInteger(pCfg, "Mode", enmAPICMode);
1510	InsertConfigInteger(pCfg, "NumCPUs", cCpus);
1511
1512	if (fIOAPIC)
1513	{
1514	/*
1515	* I/O Advanced Programmable Interrupt Controller.
1516	*/
1517	InsertConfigNode(pDevices, "ioapic", &pDev);
1518	InsertConfigNode(pDev, "0", &pInst);
1519	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1520	InsertConfigNode(pInst, "Config", &pCfg);
1521	InsertConfigInteger(pCfg, "NumCPUs", cCpus);
1522	if (enmIommuType == IommuType_AMD)
1523	InsertConfigInteger(pCfg, "PCIAddress", uIoApicPciAddress);
1524	else if (enmIommuType == IommuType_Intel)
1525	{
1526	InsertConfigString(pCfg, "ChipType", "DMAR");
1527	InsertConfigInteger(pCfg, "PCIAddress", uIoApicPciAddress);
1528	}
1529	}
1530	}
1531
1532	/*
1533	* RTC MC146818.
1534	*/
1535	InsertConfigNode(pDevices, "mc146818", &pDev);
1536	InsertConfigNode(pDev, "0", &pInst);
1537	InsertConfigNode(pInst, "Config", &pCfg);
1538	BOOL fRTCUseUTC;
1539	hrc = pMachine->COMGETTER(RTCUseUTC)(&fRTCUseUTC); H();
1540	InsertConfigInteger(pCfg, "UseUTC", fRTCUseUTC ? 1 : 0);
1541
1542	/*
1543	* VGA.
1544	*/
1545	ComPtr<IGraphicsAdapter> pGraphicsAdapter;
1546	hrc = pMachine->COMGETTER(GraphicsAdapter)(pGraphicsAdapter.asOutParam()); H();
1547	GraphicsControllerType_T enmGraphicsController;
1548	hrc = pGraphicsAdapter->COMGETTER(GraphicsControllerType)(&enmGraphicsController); H();
1549	switch (enmGraphicsController)
1550	{
1551	case GraphicsControllerType_Null:
1552	break;
1553	#ifdef VBOX_WITH_VMSVGA
1554	case GraphicsControllerType_VMSVGA:
1555	InsertConfigInteger(pHM, "LovelyMesaDrvWorkaround", 1); /* hits someone else logging backdoor. */
1556	InsertConfigInteger(pNEM, "LovelyMesaDrvWorkaround", 1); /* hits someone else logging backdoor. */
1557	RT_FALL_THROUGH();
1558	case GraphicsControllerType_VBoxSVGA:
1559	#endif
1560	case GraphicsControllerType_VBoxVGA:
1561	vrc = i_configGraphicsController(pDevices, enmGraphicsController, pBusMgr, pMachine, pGraphicsAdapter, biosSettings,
1562	RT_BOOL(fHMEnabled));
1563	if (FAILED(vrc))
1564	return vrc;
1565	break;
1566	default:
1567	AssertMsgFailed(("Invalid graphicsController=%d\n", enmGraphicsController));
1568	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
1569	N_("Invalid graphics controller type '%d'"), enmGraphicsController);
1570	}
1571
1572	/*
1573	* Firmware.
1574	*/
1575	FirmwareType_T eFwType = FirmwareType_BIOS;
1576	hrc = pMachine->COMGETTER(FirmwareType)(&eFwType); H();
1577
1578	#ifdef VBOX_WITH_EFI
1579	BOOL fEfiEnabled = (eFwType >= FirmwareType_EFI) && (eFwType <= FirmwareType_EFIDUAL);
1580	#else
1581	BOOL fEfiEnabled = false;
1582	#endif
1583	if (!fEfiEnabled)
1584	{
1585	/*
1586	* PC Bios.
1587	*/
1588	InsertConfigNode(pDevices, "pcbios", &pDev);
1589	InsertConfigNode(pDev, "0", &pInst);
1590	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1591	InsertConfigNode(pInst, "Config", &pBiosCfg);
1592	InsertConfigInteger(pBiosCfg, "NumCPUs", cCpus);
1593	InsertConfigString(pBiosCfg, "HardDiskDevice", "piix3ide");
1594	InsertConfigString(pBiosCfg, "FloppyDevice", "i82078");
1595	InsertConfigInteger(pBiosCfg, "IOAPIC", fIOAPIC);
1596	InsertConfigInteger(pBiosCfg, "APIC", uFwAPIC);
1597	BOOL fPXEDebug;
1598	hrc = biosSettings->COMGETTER(PXEDebugEnabled)(&fPXEDebug); H();
1599	InsertConfigInteger(pBiosCfg, "PXEDebug", fPXEDebug);
1600	InsertConfigBytes(pBiosCfg, "UUID", &HardwareUuid,sizeof(HardwareUuid));
1601	BOOL fUuidLe;
1602	hrc = biosSettings->COMGETTER(SMBIOSUuidLittleEndian)(&fUuidLe); H();
1603	InsertConfigInteger(pBiosCfg, "UuidLe", fUuidLe);
1604	InsertConfigNode(pBiosCfg, "NetBoot", &pNetBootCfg);
1605	InsertConfigInteger(pBiosCfg, "McfgBase", uMcfgBase);
1606	InsertConfigInteger(pBiosCfg, "McfgLength", cbMcfgLength);
1607
1608	AssertMsgReturn(SchemaDefs::MaxBootPosition <= 9, ("Too many boot devices %d\n", SchemaDefs::MaxBootPosition),
1609	VERR_INVALID_PARAMETER);
1610
1611	for (ULONG pos = 1; pos <= SchemaDefs::MaxBootPosition; ++pos)
1612	{
1613	DeviceType_T enmBootDevice;
1614	hrc = pMachine->GetBootOrder(pos, &enmBootDevice); H();
1615
1616	char szParamName[] = "BootDeviceX";
1617	szParamName[sizeof(szParamName) - 2] = (char)(pos - 1 + '0');
1618
1619	const char *pszBootDevice;
1620	switch (enmBootDevice)
1621	{
1622	case DeviceType_Null:
1623	pszBootDevice = "NONE";
1624	break;
1625	case DeviceType_HardDisk:
1626	pszBootDevice = "IDE";
1627	break;
1628	case DeviceType_DVD:
1629	pszBootDevice = "DVD";
1630	break;
1631	case DeviceType_Floppy:
1632	pszBootDevice = "FLOPPY";
1633	break;
1634	case DeviceType_Network:
1635	pszBootDevice = "LAN";
1636	break;
1637	default:
1638	AssertMsgFailed(("Invalid enmBootDevice=%d\n", enmBootDevice));
1639	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
1640	N_("Invalid boot device '%d'"), enmBootDevice);
1641	}
1642	InsertConfigString(pBiosCfg, szParamName, pszBootDevice);
1643	}
1644
1645	/** @todo @bugref{7145}: We might want to enable this by default for new VMs. For now,
1646	* this is required for Windows 2012 guests. */
1647	if (osTypeId == "Windows2012_64")
1648	InsertConfigInteger(pBiosCfg, "DmiExposeMemoryTable", 1); /* boolean */
1649	}
1650	else
1651	{
1652	/* Autodetect firmware type, basing on guest type */
1653	if (eFwType == FirmwareType_EFI)
1654	eFwType = fIsGuest64Bit ? FirmwareType_EFI64 : FirmwareType_EFI32;
1655	bool const f64BitEntry = eFwType == FirmwareType_EFI64;
1656
1657	Assert(eFwType == FirmwareType_EFI64 \|\| eFwType == FirmwareType_EFI32 \|\| eFwType == FirmwareType_EFIDUAL);
1658	#ifdef VBOX_WITH_EFI_IN_DD2
1659	const char *pszEfiRomFile = eFwType == FirmwareType_EFIDUAL ? "VBoxEFIDual.fd"
1660	: eFwType == FirmwareType_EFI32 ? "VBoxEFI32.fd"
1661	: "VBoxEFI64.fd";
1662	#else
1663	Utf8Str efiRomFile;
1664	vrc = findEfiRom(virtualBox, eFwType, &efiRomFile);
1665	AssertRCReturn(vrc, vrc);
1666	const char *pszEfiRomFile = efiRomFile.c_str();
1667	#endif
1668
1669	/* Get boot args */
1670	Utf8Str bootArgs;
1671	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiBootArgs", &bootArgs);
1672
1673	/* Get device props */
1674	Utf8Str deviceProps;
1675	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiDeviceProps", &deviceProps);
1676
1677	/* Get NVRAM file name */
1678	Utf8Str strNvram = mptrNvramStore->i_getNonVolatileStorageFile();
1679
1680	BOOL fUuidLe;
1681	hrc = biosSettings->COMGETTER(SMBIOSUuidLittleEndian)(&fUuidLe); H();
1682
1683	/* Get graphics mode settings */
1684	uint32_t u32GraphicsMode = UINT32_MAX;
1685	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiGraphicsMode", &strTmp);
1686	if (strTmp.isEmpty())
1687	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiGopMode", &strTmp);
1688	if (!strTmp.isEmpty())
1689	u32GraphicsMode = strTmp.toUInt32();
1690
1691	/* Get graphics resolution settings, with some sanity checking */
1692	Utf8Str strResolution;
1693	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiGraphicsResolution", &strResolution);
1694	if (!strResolution.isEmpty())
1695	{
1696	size_t pos = strResolution.find("x");
1697	if (pos != strResolution.npos)
1698	{
1699	Utf8Str strH, strV;
1700	strH.assignEx(strResolution, 0, pos);
1701	strV.assignEx(strResolution, pos+1, strResolution.length()-pos-1);
1702	uint32_t u32H = strH.toUInt32();
1703	uint32_t u32V = strV.toUInt32();
1704	if (u32H == 0 \|\| u32V == 0)
1705	strResolution.setNull();
1706	}
1707	else
1708	strResolution.setNull();
1709	}
1710	else
1711	{
1712	uint32_t u32H = 0;
1713	uint32_t u32V = 0;
1714	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiHorizontalResolution", &strTmp);
1715	if (strTmp.isEmpty())
1716	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiUgaHorizontalResolution", &strTmp);
1717	if (!strTmp.isEmpty())
1718	u32H = strTmp.toUInt32();
1719
1720	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiVerticalResolution", &strTmp);
1721	if (strTmp.isEmpty())
1722	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiUgaVerticalResolution", &strTmp);
1723	if (!strTmp.isEmpty())
1724	u32V = strTmp.toUInt32();
1725	if (u32H != 0 && u32V != 0)
1726	strResolution = Utf8StrFmt("%ux%u", u32H, u32V);
1727	}
1728
1729	/*
1730	* EFI subtree.
1731	*/
1732	InsertConfigNode(pDevices, "efi", &pDev);
1733	InsertConfigNode(pDev, "0", &pInst);
1734	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1735	InsertConfigNode(pInst, "Config", &pCfg);
1736	InsertConfigInteger(pCfg, "NumCPUs", cCpus);
1737	InsertConfigInteger(pCfg, "McfgBase", uMcfgBase);
1738	InsertConfigInteger(pCfg, "McfgLength", cbMcfgLength);
1739	InsertConfigString(pCfg, "EfiRom", pszEfiRomFile);
1740	InsertConfigString(pCfg, "BootArgs", bootArgs);
1741	InsertConfigString(pCfg, "DeviceProps", deviceProps);
1742	InsertConfigInteger(pCfg, "IOAPIC", fIOAPIC);
1743	InsertConfigInteger(pCfg, "APIC", uFwAPIC);
1744	InsertConfigBytes(pCfg, "UUID", &HardwareUuid,sizeof(HardwareUuid));
1745	InsertConfigInteger(pCfg, "UuidLe", fUuidLe);
1746	InsertConfigInteger(pCfg, "64BitEntry", f64BitEntry); /* boolean */
1747	InsertConfigString(pCfg, "NvramFile", strNvram);
1748	if (u32GraphicsMode != UINT32_MAX)
1749	InsertConfigInteger(pCfg, "GraphicsMode", u32GraphicsMode);
1750	if (!strResolution.isEmpty())
1751	InsertConfigString(pCfg, "GraphicsResolution", strResolution);
1752
1753	/* For OS X guests we'll force passing host's DMI info to the guest */
1754	if (fOsXGuest)
1755	{
1756	InsertConfigInteger(pCfg, "DmiUseHostInfo", 1);
1757	InsertConfigInteger(pCfg, "DmiExposeMemoryTable", 1);
1758	}
1759
1760	/* Attach the NVRAM storage driver. */
1761	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1762	InsertConfigString(pLunL0, "Driver", "NvramStore");
1763	}
1764
1765	/*
1766	* The USB Controllers.
1767	*/
1768	com::SafeIfaceArray<IUSBController> usbCtrls;
1769	hrc = pMachine->COMGETTER(USBControllers)(ComSafeArrayAsOutParam(usbCtrls));
1770	bool fOhciPresent = false; /*< Flag whether at least one OHCI controller is present. /
1771	bool fXhciPresent = false; /*< Flag whether at least one XHCI controller is present. /
1772
1773	if (SUCCEEDED(hrc))
1774	{
1775	for (size_t i = 0; i < usbCtrls.size(); ++i)
1776	{
1777	USBControllerType_T enmCtrlType;
1778	vrc = usbCtrls[i]->COMGETTER(Type)(&enmCtrlType); H();
1779	if (enmCtrlType == USBControllerType_OHCI)
1780	{
1781	fOhciPresent = true;
1782	break;
1783	}
1784	else if (enmCtrlType == USBControllerType_XHCI)
1785	{
1786	fXhciPresent = true;
1787	break;
1788	}
1789	}
1790	}
1791	else if (hrc != E_NOTIMPL)
1792	{
1793	H();
1794	}
1795
1796	/*
1797	* Currently EHCI is only enabled when an OHCI or XHCI controller is present as well.
1798	*/
1799	if (fOhciPresent \|\| fXhciPresent)
1800	mfVMHasUsbController = true;
1801
1802	PCFGMNODE pUsbDevices = NULL; /*< Required for USB storage controller later. /
1803	if (mfVMHasUsbController)
1804	{
1805	for (size_t i = 0; i < usbCtrls.size(); ++i)
1806	{
1807	USBControllerType_T enmCtrlType;
1808	vrc = usbCtrls[i]->COMGETTER(Type)(&enmCtrlType); H();
1809
1810	if (enmCtrlType == USBControllerType_OHCI)
1811	{
1812	InsertConfigNode(pDevices, "usb-ohci", &pDev);
1813	InsertConfigNode(pDev, "0", &pInst);
1814	InsertConfigNode(pInst, "Config", &pCfg);
1815	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1816	hrc = pBusMgr->assignPCIDevice("usb-ohci", pInst); H();
1817	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1818	InsertConfigString(pLunL0, "Driver", "VUSBRootHub");
1819	InsertConfigNode(pLunL0, "Config", &pCfg);
1820
1821	/*
1822	* Attach the status driver.
1823	*/
1824	i_attachStatusDriver(pInst, DeviceType_USB);
1825	}
1826	#ifdef VBOX_WITH_EHCI
1827	else if (enmCtrlType == USBControllerType_EHCI)
1828	{
1829	InsertConfigNode(pDevices, "usb-ehci", &pDev);
1830	InsertConfigNode(pDev, "0", &pInst);
1831	InsertConfigNode(pInst, "Config", &pCfg);
1832	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1833	hrc = pBusMgr->assignPCIDevice("usb-ehci", pInst); H();
1834
1835	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1836	InsertConfigString(pLunL0, "Driver", "VUSBRootHub");
1837	InsertConfigNode(pLunL0, "Config", &pCfg);
1838
1839	/*
1840	* Attach the status driver.
1841	*/
1842	i_attachStatusDriver(pInst, DeviceType_USB);
1843	}
1844	#endif
1845	else if (enmCtrlType == USBControllerType_XHCI)
1846	{
1847	InsertConfigNode(pDevices, "usb-xhci", &pDev);
1848	InsertConfigNode(pDev, "0", &pInst);
1849	InsertConfigNode(pInst, "Config", &pCfg);
1850	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1851	hrc = pBusMgr->assignPCIDevice("usb-xhci", pInst); H();
1852
1853	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1854	InsertConfigString(pLunL0, "Driver", "VUSBRootHub");
1855	InsertConfigNode(pLunL0, "Config", &pCfg);
1856
1857	InsertConfigNode(pInst, "LUN#1", &pLunL1);
1858	InsertConfigString(pLunL1, "Driver", "VUSBRootHub");
1859	InsertConfigNode(pLunL1, "Config", &pCfg);
1860
1861	/*
1862	* Attach the status driver.
1863	*/
1864	i_attachStatusDriver(pInst, DeviceType_USB, 2);
1865	}
1866	} /* for every USB controller. */
1867
1868
1869	/*
1870	* Virtual USB Devices.
1871	*/
1872	InsertConfigNode(pRoot, "USB", &pUsbDevices);
1873
1874	#ifdef VBOX_WITH_USB
1875	{
1876	/*
1877	* Global USB options, currently unused as we'll apply the 2.0 -> 1.1 morphing
1878	* on a per device level now.
1879	*/
1880	InsertConfigNode(pUsbDevices, "USBProxy", &pCfg);
1881	InsertConfigNode(pCfg, "GlobalConfig", &pCfg);
1882	// This globally enables the 2.0 -> 1.1 device morphing of proxied devices to keep windows quiet.
1883	//InsertConfigInteger(pCfg, "Force11Device", true);
1884	// The following breaks stuff, but it makes MSDs work in vista. (I include it here so
1885	// that it's documented somewhere.) Users needing it can use:
1886	// VBoxManage setextradata "myvm" "VBoxInternal/USB/USBProxy/GlobalConfig/Force11PacketSize" 1
1887	//InsertConfigInteger(pCfg, "Force11PacketSize", true);
1888	}
1889	#endif
1890
1891	#ifdef VBOX_WITH_USB_CARDREADER
1892	BOOL aEmulatedUSBCardReaderEnabled = FALSE;
1893	hrc = pMachine->COMGETTER(EmulatedUSBCardReaderEnabled)(&aEmulatedUSBCardReaderEnabled); H();
1894	if (aEmulatedUSBCardReaderEnabled)
1895	{
1896	InsertConfigNode(pUsbDevices, "CardReader", &pDev);
1897	InsertConfigNode(pDev, "0", &pInst);
1898	InsertConfigNode(pInst, "Config", &pCfg);
1899
1900	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1901	# ifdef VBOX_WITH_USB_CARDREADER_TEST
1902	InsertConfigString(pLunL0, "Driver", "DrvDirectCardReader");
1903	InsertConfigNode(pLunL0, "Config", &pCfg);
1904	# else
1905	InsertConfigString(pLunL0, "Driver", "UsbCardReader");
1906	InsertConfigNode(pLunL0, "Config", &pCfg);
1907	# endif
1908	}
1909	#endif
1910
1911	/* Virtual USB Mouse/Tablet */
1912	if ( aPointingHID == PointingHIDType_USBMouse
1913	\|\| aPointingHID == PointingHIDType_USBTablet
1914	\|\| aPointingHID == PointingHIDType_USBMultiTouch
1915	\|\| aPointingHID == PointingHIDType_USBMultiTouchScreenPlusPad)
1916	{
1917	InsertConfigNode(pUsbDevices, "HidMouse", &pDev);
1918	InsertConfigNode(pDev, "0", &pInst);
1919	InsertConfigNode(pInst, "Config", &pCfg);
1920
1921	if (aPointingHID == PointingHIDType_USBMouse)
1922	InsertConfigString(pCfg, "Mode", "relative");
1923	else
1924	InsertConfigString(pCfg, "Mode", "absolute");
1925	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1926	InsertConfigString(pLunL0, "Driver", "MouseQueue");
1927	InsertConfigNode(pLunL0, "Config", &pCfg);
1928	InsertConfigInteger(pCfg, "QueueSize", 128);
1929
1930	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
1931	InsertConfigString(pLunL1, "Driver", "MainMouse");
1932	}
1933	if ( aPointingHID == PointingHIDType_USBMultiTouch
1934	\|\| aPointingHID == PointingHIDType_USBMultiTouchScreenPlusPad)
1935	{
1936	InsertConfigNode(pDev, "1", &pInst);
1937	InsertConfigNode(pInst, "Config", &pCfg);
1938
1939	InsertConfigString(pCfg, "Mode", "multitouch");
1940	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1941	InsertConfigString(pLunL0, "Driver", "MouseQueue");
1942	InsertConfigNode(pLunL0, "Config", &pCfg);
1943	InsertConfigInteger(pCfg, "QueueSize", 128);
1944
1945	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
1946	InsertConfigString(pLunL1, "Driver", "MainMouse");
1947	}
1948	if (aPointingHID == PointingHIDType_USBMultiTouchScreenPlusPad)
1949	{
1950	InsertConfigNode(pDev, "2", &pInst);
1951	InsertConfigNode(pInst, "Config", &pCfg);
1952
1953	InsertConfigString(pCfg, "Mode", "touchpad");
1954	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1955	InsertConfigString(pLunL0, "Driver", "MouseQueue");
1956	InsertConfigNode(pLunL0, "Config", &pCfg);
1957	InsertConfigInteger(pCfg, "QueueSize", 128);
1958
1959	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
1960	InsertConfigString(pLunL1, "Driver", "MainMouse");
1961	}
1962
1963	/* Virtual USB Keyboard */
1964	if (aKbdHID == KeyboardHIDType_USBKeyboard)
1965	{
1966	InsertConfigNode(pUsbDevices, "HidKeyboard", &pDev);
1967	InsertConfigNode(pDev, "0", &pInst);
1968	InsertConfigNode(pInst, "Config", &pCfg);
1969
1970	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1971	InsertConfigString(pLunL0, "Driver", "KeyboardQueue");
1972	InsertConfigNode(pLunL0, "Config", &pCfg);
1973	InsertConfigInteger(pCfg, "QueueSize", 64);
1974
1975	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
1976	InsertConfigString(pLunL1, "Driver", "MainKeyboard");
1977	}
1978	}
1979
1980	/*
1981	* Storage controllers.
1982	*/
1983	com::SafeIfaceArray<IStorageController> ctrls;
1984	PCFGMNODE aCtrlNodes[StorageControllerType_VirtioSCSI + 1] = {};
1985	hrc = pMachine->COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(ctrls)); H();
1986
1987	bool fFdcEnabled = false;
1988	for (size_t i = 0; i < ctrls.size(); ++i)
1989	{
1990	DeviceType_T *paLedDevType = NULL;
1991
1992	StorageControllerType_T enmCtrlType;
1993	hrc = ctrls[i]->COMGETTER(ControllerType)(&enmCtrlType); H();
1994	AssertRelease((unsigned)enmCtrlType < RT_ELEMENTS(aCtrlNodes)
1995	\|\| enmCtrlType == StorageControllerType_USB);
1996
1997	StorageBus_T enmBus;
1998	hrc = ctrls[i]->COMGETTER(Bus)(&enmBus); H();
1999
2000	Bstr controllerName;
2001	hrc = ctrls[i]->COMGETTER(Name)(controllerName.asOutParam()); H();
2002
2003	ULONG ulInstance = 999;
2004	hrc = ctrls[i]->COMGETTER(Instance)(&ulInstance); H();
2005
2006	BOOL fUseHostIOCache;
2007	hrc = ctrls[i]->COMGETTER(UseHostIOCache)(&fUseHostIOCache); H();
2008
2009	BOOL fBootable;
2010	hrc = ctrls[i]->COMGETTER(Bootable)(&fBootable); H();
2011
2012	PCFGMNODE pCtlInst = NULL;
2013	const char *pszCtrlDev = i_storageControllerTypeToStr(enmCtrlType);
2014	if (enmCtrlType != StorageControllerType_USB)
2015	{
2016	/* /Devices/<ctrldev>/ */
2017	pDev = aCtrlNodes[enmCtrlType];
2018	if (!pDev)
2019	{
2020	InsertConfigNode(pDevices, pszCtrlDev, &pDev);
2021	aCtrlNodes[enmCtrlType] = pDev; /* IDE variants are handled in the switch */
2022	}
2023
2024	/* /Devices/<ctrldev>/<instance>/ */
2025	InsertConfigNode(pDev, Utf8StrFmt("%u", ulInstance).c_str(), &pCtlInst);
2026
2027	/* Device config: /Devices/<ctrldev>/<instance>/<values> & /ditto/Config/<values> */
2028	InsertConfigInteger(pCtlInst, "Trusted", 1);
2029	InsertConfigNode(pCtlInst, "Config", &pCfg);
2030	}
2031
2032	static const char * const apszBiosConfigScsi[MAX_BIOS_LUN_COUNT] =
2033	{ "ScsiLUN1", "ScsiLUN2", "ScsiLUN3", "ScsiLUN4" };
2034
2035	static const char * const apszBiosConfigSata[MAX_BIOS_LUN_COUNT] =
2036	{ "SataLUN1", "SataLUN2", "SataLUN3", "SataLUN4" };
2037
2038	switch (enmCtrlType)
2039	{
2040	case StorageControllerType_LsiLogic:
2041	{
2042	hrc = pBusMgr->assignPCIDevice("lsilogic", pCtlInst); H();
2043
2044	InsertConfigInteger(pCfg, "Bootable", fBootable);
2045
2046	/* BIOS configuration values, first SCSI controller only. */
2047	if ( !pBusMgr->hasPCIDevice("lsilogic", 1)
2048	&& !pBusMgr->hasPCIDevice("buslogic", 0)
2049	&& !pBusMgr->hasPCIDevice("lsilogicsas", 0)
2050	&& pBiosCfg)
2051	{
2052	InsertConfigString(pBiosCfg, "ScsiHardDiskDevice", "lsilogicscsi");
2053	hrc = SetBiosDiskInfo(pMachine, pCfg, pBiosCfg, controllerName, apszBiosConfigScsi); H();
2054	}
2055
2056	/* Attach the status driver */
2057	i_attachStatusDriver(pCtlInst, RT_BIT_32(DeviceType_HardDisk) \| RT_BIT_32(DeviceType_DVD),
2058	16, &paLedDevType, &mapMediumAttachments, pszCtrlDev, ulInstance);
2059	break;
2060	}
2061
2062	case StorageControllerType_BusLogic:
2063	{
2064	hrc = pBusMgr->assignPCIDevice("buslogic", pCtlInst); H();
2065
2066	InsertConfigInteger(pCfg, "Bootable", fBootable);
2067
2068	/* BIOS configuration values, first SCSI controller only. */
2069	if ( !pBusMgr->hasPCIDevice("lsilogic", 0)
2070	&& !pBusMgr->hasPCIDevice("buslogic", 1)
2071	&& !pBusMgr->hasPCIDevice("lsilogicsas", 0)
2072	&& pBiosCfg)
2073	{
2074	InsertConfigString(pBiosCfg, "ScsiHardDiskDevice", "buslogic");
2075	hrc = SetBiosDiskInfo(pMachine, pCfg, pBiosCfg, controllerName, apszBiosConfigScsi); H();
2076	}
2077
2078	/* Attach the status driver */
2079	i_attachStatusDriver(pCtlInst, RT_BIT_32(DeviceType_HardDisk) \| RT_BIT_32(DeviceType_DVD),
2080	16, &paLedDevType, &mapMediumAttachments, pszCtrlDev, ulInstance);
2081	break;
2082	}
2083
2084	case StorageControllerType_IntelAhci:
2085	{
2086	hrc = pBusMgr->assignPCIDevice("ahci", pCtlInst); H();
2087
2088	ULONG cPorts = 0;
2089	hrc = ctrls[i]->COMGETTER(PortCount)(&cPorts); H();
2090	InsertConfigInteger(pCfg, "PortCount", cPorts);
2091	InsertConfigInteger(pCfg, "Bootable", fBootable);
2092
2093	com::SafeIfaceArray<IMediumAttachment> atts;
2094	hrc = pMachine->GetMediumAttachmentsOfController(controllerName.raw(),
2095	ComSafeArrayAsOutParam(atts)); H();
2096
2097	/* Configure the hotpluggable flag for the port. */
2098	for (unsigned idxAtt = 0; idxAtt < atts.size(); ++idxAtt)
2099	{
2100	IMediumAttachment *pMediumAtt = atts[idxAtt];
2101
2102	LONG lPortNum = 0;
2103	hrc = pMediumAtt->COMGETTER(Port)(&lPortNum); H();
2104
2105	BOOL fHotPluggable = FALSE;
2106	hrc = pMediumAtt->COMGETTER(HotPluggable)(&fHotPluggable); H();
2107	if (SUCCEEDED(hrc))
2108	{
2109	PCFGMNODE pPortCfg;
2110	char szName[24];
2111	RTStrPrintf(szName, sizeof(szName), "Port%d", lPortNum);
2112
2113	InsertConfigNode(pCfg, szName, &pPortCfg);
2114	InsertConfigInteger(pPortCfg, "Hotpluggable", fHotPluggable ? 1 : 0);
2115	}
2116	}
2117
2118	/* BIOS configuration values, first AHCI controller only. */
2119	if ( !pBusMgr->hasPCIDevice("ahci", 1)
2120	&& pBiosCfg)
2121	{
2122	InsertConfigString(pBiosCfg, "SataHardDiskDevice", "ahci");
2123	hrc = SetBiosDiskInfo(pMachine, pCfg, pBiosCfg, controllerName, apszBiosConfigSata); H();
2124	}
2125
2126	/* Attach the status driver */
2127	i_attachStatusDriver(pCtlInst, RT_BIT_32(DeviceType_HardDisk) \| RT_BIT_32(DeviceType_DVD),
2128	cPorts, &paLedDevType, &mapMediumAttachments, pszCtrlDev, ulInstance);
2129	break;
2130	}
2131
2132	case StorageControllerType_PIIX3:
2133	case StorageControllerType_PIIX4:
2134	case StorageControllerType_ICH6:
2135	{
2136	/*
2137	* IDE (update this when the main interface changes)
2138	*/
2139	hrc = pBusMgr->assignPCIDevice("piix3ide", pCtlInst); H();
2140	InsertConfigString(pCfg, "Type", controllerString(enmCtrlType));
2141
2142	/* Attach the status driver */
2143	i_attachStatusDriver(pCtlInst, RT_BIT_32(DeviceType_HardDisk) \| RT_BIT_32(DeviceType_DVD),
2144	4, &paLedDevType, &mapMediumAttachments, pszCtrlDev, ulInstance);
2145
2146	/* IDE flavors */
2147	aCtrlNodes[StorageControllerType_PIIX3] = pDev;
2148	aCtrlNodes[StorageControllerType_PIIX4] = pDev;
2149	aCtrlNodes[StorageControllerType_ICH6] = pDev;
2150	break;
2151	}
2152
2153	case StorageControllerType_I82078:
2154	{
2155	/*
2156	* i82078 Floppy drive controller
2157	*/
2158	fFdcEnabled = true;
2159	InsertConfigInteger(pCfg, "IRQ", 6);
2160	InsertConfigInteger(pCfg, "DMA", 2);
2161	InsertConfigInteger(pCfg, "MemMapped", 0 );
2162	InsertConfigInteger(pCfg, "IOBase", 0x3f0);
2163
2164	/* Attach the status driver */
2165	i_attachStatusDriver(pCtlInst, RT_BIT_32(DeviceType_Floppy),
2166	2, NULL, &mapMediumAttachments, pszCtrlDev, ulInstance);
2167	break;
2168	}
2169
2170	case StorageControllerType_LsiLogicSas:
2171	{
2172	hrc = pBusMgr->assignPCIDevice("lsilogicsas", pCtlInst); H();
2173
2174	InsertConfigString(pCfg, "ControllerType", "SAS1068");
2175	InsertConfigInteger(pCfg, "Bootable", fBootable);
2176
2177	/* BIOS configuration values, first SCSI controller only. */
2178	if ( !pBusMgr->hasPCIDevice("lsilogic", 0)
2179	&& !pBusMgr->hasPCIDevice("buslogic", 0)
2180	&& !pBusMgr->hasPCIDevice("lsilogicsas", 1)
2181	&& pBiosCfg)
2182	{
2183	InsertConfigString(pBiosCfg, "ScsiHardDiskDevice", "lsilogicsas");
2184	hrc = SetBiosDiskInfo(pMachine, pCfg, pBiosCfg, controllerName, apszBiosConfigScsi); H();
2185	}
2186
2187	ULONG cPorts = 0;
2188	hrc = ctrls[i]->COMGETTER(PortCount)(&cPorts); H();
2189	InsertConfigInteger(pCfg, "NumPorts", cPorts);
2190
2191	/* Attach the status driver */
2192	i_attachStatusDriver(pCtlInst, RT_BIT_32(DeviceType_HardDisk) \| RT_BIT_32(DeviceType_DVD) /?/,
2193	8, &paLedDevType, &mapMediumAttachments, pszCtrlDev, ulInstance);
2194	break;
2195	}
2196
2197	case StorageControllerType_USB:
2198	{
2199	if (pUsbDevices)
2200	{
2201	/*
2202	* USB MSDs are handled a bit different as the device instance
2203	* doesn't match the storage controller instance but the port.
2204	*/
2205	InsertConfigNode(pUsbDevices, "Msd", &pDev);
2206	pCtlInst = pDev;
2207	}
2208	else
2209	return pVMM->pfnVMR3SetError(pUVM, VERR_NOT_FOUND, RT_SRC_POS,
2210	N_("There is no USB controller enabled but there\n"
2211	"is at least one USB storage device configured for this VM.\n"
2212	"To fix this problem either enable the USB controller or remove\n"
2213	"the storage device from the VM"));
2214	break;
2215	}
2216
2217	case StorageControllerType_NVMe:
2218	{
2219	hrc = pBusMgr->assignPCIDevice("nvme", pCtlInst); H();
2220
2221	ULONG cPorts = 0;
2222	hrc = ctrls[i]->COMGETTER(PortCount)(&cPorts); H();
2223	InsertConfigInteger(pCfg, "NamespacesMax", cPorts);
2224
2225	/* Attach the status driver */
2226	i_attachStatusDriver(pCtlInst, RT_BIT_32(DeviceType_HardDisk),
2227	cPorts, NULL, &mapMediumAttachments, pszCtrlDev, ulInstance);
2228	break;
2229	}
2230
2231	case StorageControllerType_VirtioSCSI:
2232	{
2233	hrc = pBusMgr->assignPCIDevice("virtio-scsi", pCtlInst); H();
2234
2235	ULONG cPorts = 0;
2236	hrc = ctrls[i]->COMGETTER(PortCount)(&cPorts); H();
2237	InsertConfigInteger(pCfg, "NumTargets", cPorts);
2238	InsertConfigInteger(pCfg, "Bootable", fBootable);
2239
2240	/* Attach the status driver */
2241	i_attachStatusDriver(pCtlInst, RT_BIT_32(DeviceType_HardDisk) \| RT_BIT_32(DeviceType_DVD) /?/,
2242	cPorts, &paLedDevType, &mapMediumAttachments, pszCtrlDev, ulInstance);
2243	break;
2244	}
2245
2246	default:
2247	AssertLogRelMsgFailedReturn(("invalid storage controller type: %d\n", enmCtrlType), VERR_MAIN_CONFIG_CONSTRUCTOR_IPE);
2248	}
2249
2250	/* Attach the media to the storage controllers. */
2251	com::SafeIfaceArray<IMediumAttachment> atts;
2252	hrc = pMachine->GetMediumAttachmentsOfController(controllerName.raw(),
2253	ComSafeArrayAsOutParam(atts)); H();
2254
2255	/* Builtin I/O cache - per device setting. */
2256	BOOL fBuiltinIOCache = true;
2257	hrc = pMachine->COMGETTER(IOCacheEnabled)(&fBuiltinIOCache); H();
2258
2259	bool fInsertDiskIntegrityDrv = false;
2260	Bstr strDiskIntegrityFlag;
2261	hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EnableDiskIntegrityDriver").raw(),
2262	strDiskIntegrityFlag.asOutParam());
2263	if ( hrc == S_OK
2264	&& strDiskIntegrityFlag == "1")
2265	fInsertDiskIntegrityDrv = true;
2266
2267	for (size_t j = 0; j < atts.size(); ++j)
2268	{
2269	IMediumAttachment *pMediumAtt = atts[j];
2270	vrc = i_configMediumAttachment(pszCtrlDev,
2271	ulInstance,
2272	enmBus,
2273	!!fUseHostIOCache,
2274	enmCtrlType == StorageControllerType_NVMe ? false : !!fBuiltinIOCache,
2275	fInsertDiskIntegrityDrv,
2276	false /* fSetupMerge */,
2277	0 /* uMergeSource */,
2278	0 /* uMergeTarget */,
2279	pMediumAtt,
2280	mMachineState,
2281	NULL /* phrc */,
2282	false /* fAttachDetach */,
2283	false /* fForceUnmount */,
2284	false /* fHotplug */,
2285	pUVM,
2286	pVMM,
2287	paLedDevType,
2288	NULL /* ppLunL0 */);
2289	if (RT_FAILURE(vrc))
2290	return vrc;
2291	}
2292	H();
2293	}
2294	H();
2295
2296	/*
2297	* Network adapters
2298	*/
2299	#ifdef VMWARE_NET_IN_SLOT_11
2300	bool fSwapSlots3and11 = false;
2301	#endif
2302	PCFGMNODE pDevPCNet = NULL; /* PCNet-type devices */
2303	InsertConfigNode(pDevices, "pcnet", &pDevPCNet);
2304	#ifdef VBOX_WITH_E1000
2305	PCFGMNODE pDevE1000 = NULL; /* E1000-type devices */
2306	InsertConfigNode(pDevices, "e1000", &pDevE1000);
2307	#endif
2308	#ifdef VBOX_WITH_VIRTIO
2309	PCFGMNODE pDevVirtioNet = NULL; /* Virtio network devices */
2310	InsertConfigNode(pDevices, "virtio-net", &pDevVirtioNet);
2311	#endif /* VBOX_WITH_VIRTIO */
2312	PCFGMNODE pDevDP8390 = NULL; /* DP8390-type devices */
2313	InsertConfigNode(pDevices, "dp8390", &pDevDP8390);
2314	PCFGMNODE pDev3C501 = NULL; /* EtherLink-type devices */
2315	InsertConfigNode(pDevices, "3c501", &pDev3C501);
2316
2317	std::list<BootNic> llBootNics;
2318	for (ULONG uInstance = 0; uInstance < maxNetworkAdapters; ++uInstance)
2319	{
2320	ComPtr<INetworkAdapter> networkAdapter;
2321	hrc = pMachine->GetNetworkAdapter(uInstance, networkAdapter.asOutParam()); H();
2322	BOOL fEnabledNetAdapter = FALSE;
2323	hrc = networkAdapter->COMGETTER(Enabled)(&fEnabledNetAdapter); H();
2324	if (!fEnabledNetAdapter)
2325	continue;
2326
2327	/*
2328	* The virtual hardware type. Create appropriate device first.
2329	*/
2330	const char *pszAdapterName = "pcnet";
2331	NetworkAdapterType_T adapterType;
2332	hrc = networkAdapter->COMGETTER(AdapterType)(&adapterType); H();
2333	switch (adapterType)
2334	{
2335	case NetworkAdapterType_Am79C970A:
2336	case NetworkAdapterType_Am79C973:
2337	case NetworkAdapterType_Am79C960:
2338	pDev = pDevPCNet;
2339	break;
2340	#ifdef VBOX_WITH_E1000
2341	case NetworkAdapterType_I82540EM:
2342	case NetworkAdapterType_I82543GC:
2343	case NetworkAdapterType_I82545EM:
2344	pDev = pDevE1000;
2345	pszAdapterName = "e1000";
2346	break;
2347	#endif
2348	#ifdef VBOX_WITH_VIRTIO
2349	case NetworkAdapterType_Virtio:
2350	pDev = pDevVirtioNet;
2351	pszAdapterName = "virtio-net";
2352	break;
2353	#endif /* VBOX_WITH_VIRTIO */
2354	case NetworkAdapterType_NE1000:
2355	case NetworkAdapterType_NE2000:
2356	case NetworkAdapterType_WD8003:
2357	case NetworkAdapterType_WD8013:
2358	case NetworkAdapterType_ELNK2:
2359	pDev = pDevDP8390;
2360	break;
2361	case NetworkAdapterType_ELNK1:
2362	pDev = pDev3C501;
2363	break;
2364	default:
2365	AssertMsgFailed(("Invalid network adapter type '%d' for slot '%d'", adapterType, uInstance));
2366	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
2367	N_("Invalid network adapter type '%d' for slot '%d'"), adapterType, uInstance);
2368	}
2369
2370	InsertConfigNode(pDev, Utf8StrFmt("%u", uInstance).c_str(), &pInst);
2371	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
2372	/* the first network card gets the PCI ID 3, the next 3 gets 8..10,
2373	* next 4 get 16..19. */
2374	int iPCIDeviceNo;
2375	switch (uInstance)
2376	{
2377	case 0:
2378	iPCIDeviceNo = 3;
2379	break;
2380	case 1: case 2: case 3:
2381	iPCIDeviceNo = uInstance - 1 + 8;
2382	break;
2383	case 4: case 5: case 6: case 7:
2384	iPCIDeviceNo = uInstance - 4 + 16;
2385	break;
2386	default:
2387	/* auto assignment */
2388	iPCIDeviceNo = -1;
2389	break;
2390	}
2391	#ifdef VMWARE_NET_IN_SLOT_11
2392	/*
2393	* Dirty hack for PCI slot compatibility with VMWare,
2394	* it assigns slot 0x11 to the first network controller.
2395	*/
2396	if (iPCIDeviceNo == 3 && adapterType == NetworkAdapterType_I82545EM)
2397	{
2398	iPCIDeviceNo = 0x11;
2399	fSwapSlots3and11 = true;
2400	}
2401	else if (iPCIDeviceNo == 0x11 && fSwapSlots3and11)
2402	iPCIDeviceNo = 3;
2403	#endif
2404	PCIBusAddress PCIAddr = PCIBusAddress(0, iPCIDeviceNo, 0);
2405	hrc = pBusMgr->assignPCIDevice(pszAdapterName, pInst, PCIAddr); H();
2406
2407	InsertConfigNode(pInst, "Config", &pCfg);
2408	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE /* not safe here yet. / /* @todo Make PCNet ring-0 safe on 32-bit mac kernels! */
2409	if (pDev == pDevPCNet)
2410	InsertConfigInteger(pCfg, "R0Enabled", false);
2411	#endif
2412	/*
2413	* Collect information needed for network booting and add it to the list.
2414	*/
2415	BootNic nic;
2416
2417	nic.mInstance = uInstance;
2418	/* Could be updated by reference, if auto assigned */
2419	nic.mPCIAddress = PCIAddr;
2420
2421	hrc = networkAdapter->COMGETTER(BootPriority)(&nic.mBootPrio); H();
2422
2423	llBootNics.push_back(nic);
2424
2425	/*
2426	* The virtual hardware type. PCNet supports three types, E1000 three,
2427	* but VirtIO only one.
2428	*/
2429	switch (adapterType)
2430	{
2431	case NetworkAdapterType_Am79C970A:
2432	InsertConfigString(pCfg, "ChipType", "Am79C970A");
2433	break;
2434	case NetworkAdapterType_Am79C973:
2435	InsertConfigString(pCfg, "ChipType", "Am79C973");
2436	break;
2437	case NetworkAdapterType_Am79C960:
2438	InsertConfigString(pCfg, "ChipType", "Am79C960");
2439	break;
2440	case NetworkAdapterType_I82540EM:
2441	InsertConfigInteger(pCfg, "AdapterType", 0);
2442	break;
2443	case NetworkAdapterType_I82543GC:
2444	InsertConfigInteger(pCfg, "AdapterType", 1);
2445	break;
2446	case NetworkAdapterType_I82545EM:
2447	InsertConfigInteger(pCfg, "AdapterType", 2);
2448	break;
2449	case NetworkAdapterType_Virtio:
2450	break;
2451	case NetworkAdapterType_NE1000:
2452	InsertConfigString(pCfg, "DeviceType", "NE1000");
2453	break;
2454	case NetworkAdapterType_NE2000:
2455	InsertConfigString(pCfg, "DeviceType", "NE2000");
2456	break;
2457	case NetworkAdapterType_WD8003:
2458	InsertConfigString(pCfg, "DeviceType", "WD8003");
2459	break;
2460	case NetworkAdapterType_WD8013:
2461	InsertConfigString(pCfg, "DeviceType", "WD8013");
2462	break;
2463	case NetworkAdapterType_ELNK2:
2464	InsertConfigString(pCfg, "DeviceType", "3C503");
2465	break;
2466	case NetworkAdapterType_ELNK1:
2467	break;
2468	case NetworkAdapterType_Null: AssertFailedBreak(); /* (compiler warnings) */
2469	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
2470	case NetworkAdapterType_32BitHack: AssertFailedBreak(); /* (compiler warnings) */
2471	#endif
2472	}
2473
2474	/*
2475	* Get the MAC address and convert it to binary representation
2476	*/
2477	Bstr macAddr;
2478	hrc = networkAdapter->COMGETTER(MACAddress)(macAddr.asOutParam()); H();
2479	Assert(!macAddr.isEmpty());
2480	Utf8Str macAddrUtf8 = macAddr;
2481	#ifdef VBOX_WITH_CLOUD_NET
2482	NetworkAttachmentType_T eAttachmentType;
2483	hrc = networkAdapter->COMGETTER(AttachmentType)(&eAttachmentType); H();
2484	if (eAttachmentType == NetworkAttachmentType_Cloud)
2485	{
2486	mGateway.setLocalMacAddress(macAddrUtf8);
2487	/* We'll insert cloud MAC later, when it becomes known. */
2488	}
2489	else
2490	{
2491	#endif
2492	char macStr = (char)macAddrUtf8.c_str();
2493	Assert(strlen(macStr) == 12);
2494	RTMAC Mac;
2495	RT_ZERO(Mac);
2496	char pMac = (char)&Mac;
2497	for (uint32_t i = 0; i < 6; ++i)
2498	{
2499	int c1 = *macStr++ - '0';
2500	if (c1 > 9)
2501	c1 -= 7;
2502	int c2 = *macStr++ - '0';
2503	if (c2 > 9)
2504	c2 -= 7;
2505	*pMac++ = (char)(((c1 & 0x0f) << 4) \| (c2 & 0x0f));
2506	}
2507	InsertConfigBytes(pCfg, "MAC", &Mac, sizeof(Mac));
2508	#ifdef VBOX_WITH_CLOUD_NET
2509	}
2510	#endif
2511	/*
2512	* Check if the cable is supposed to be unplugged
2513	*/
2514	BOOL fCableConnected;
2515	hrc = networkAdapter->COMGETTER(CableConnected)(&fCableConnected); H();
2516	InsertConfigInteger(pCfg, "CableConnected", fCableConnected ? 1 : 0);
2517
2518	/*
2519	* Line speed to report from custom drivers
2520	*/
2521	ULONG ulLineSpeed;
2522	hrc = networkAdapter->COMGETTER(LineSpeed)(&ulLineSpeed); H();
2523	InsertConfigInteger(pCfg, "LineSpeed", ulLineSpeed);
2524
2525	/*
2526	* Attach the status driver.
2527	*/
2528	i_attachStatusDriver(pInst, DeviceType_Network);
2529
2530	/*
2531	* Configure the network card now
2532	*/
2533	bool fIgnoreConnectFailure = mMachineState == MachineState_Restoring;
2534	vrc = i_configNetwork(pszAdapterName,
2535	uInstance,
2536	0,
2537	networkAdapter,
2538	pCfg,
2539	pLunL0,
2540	pInst,
2541	false /fAttachDetach/,
2542	fIgnoreConnectFailure,
2543	pUVM,
2544	pVMM);
2545	if (RT_FAILURE(vrc))
2546	return vrc;
2547	}
2548
2549	/*
2550	* Build network boot information and transfer it to the BIOS.
2551	*/
2552	if (pNetBootCfg && !llBootNics.empty()) /* NetBoot node doesn't exist for EFI! */
2553	{
2554	llBootNics.sort(); /* Sort the list by boot priority. */
2555
2556	char achBootIdx[] = "0";
2557	unsigned uBootIdx = 0;
2558
2559	for (std::list<BootNic>::iterator it = llBootNics.begin(); it != llBootNics.end(); ++it)
2560	{
2561	/* A NIC with priority 0 is only used if it's first in the list. */
2562	if (it->mBootPrio == 0 && uBootIdx != 0)
2563	break;
2564
2565	PCFGMNODE pNetBtDevCfg;
2566	achBootIdx[0] = (char)('0' + uBootIdx++); /* Boot device order. */
2567	InsertConfigNode(pNetBootCfg, achBootIdx, &pNetBtDevCfg);
2568	InsertConfigInteger(pNetBtDevCfg, "NIC", it->mInstance);
2569	InsertConfigInteger(pNetBtDevCfg, "PCIBusNo", it->mPCIAddress.miBus);
2570	InsertConfigInteger(pNetBtDevCfg, "PCIDeviceNo", it->mPCIAddress.miDevice);
2571	InsertConfigInteger(pNetBtDevCfg, "PCIFunctionNo", it->mPCIAddress.miFn);
2572	}
2573	}
2574
2575	/*
2576	* Serial (UART) Ports
2577	*/
2578	/* serial enabled mask to be passed to dev ACPI */
2579	uint16_t auSerialIoPortBase[SchemaDefs::SerialPortCount] = {0};
2580	uint8_t auSerialIrq[SchemaDefs::SerialPortCount] = {0};
2581	InsertConfigNode(pDevices, "serial", &pDev);
2582	for (ULONG ulInstance = 0; ulInstance < SchemaDefs::SerialPortCount; ++ulInstance)
2583	{
2584	ComPtr<ISerialPort> serialPort;
2585	hrc = pMachine->GetSerialPort(ulInstance, serialPort.asOutParam()); H();
2586	BOOL fEnabledSerPort = FALSE;
2587	if (serialPort)
2588	{
2589	hrc = serialPort->COMGETTER(Enabled)(&fEnabledSerPort); H();
2590	}
2591	if (!fEnabledSerPort)
2592	{
2593	m_aeSerialPortMode[ulInstance] = PortMode_Disconnected;
2594	continue;
2595	}
2596
2597	InsertConfigNode(pDev, Utf8StrFmt("%u", ulInstance).c_str(), &pInst);
2598	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
2599	InsertConfigNode(pInst, "Config", &pCfg);
2600
2601	ULONG ulIRQ;
2602	hrc = serialPort->COMGETTER(IRQ)(&ulIRQ); H();
2603	InsertConfigInteger(pCfg, "IRQ", ulIRQ);
2604	auSerialIrq[ulInstance] = (uint8_t)ulIRQ;
2605
2606	ULONG ulIOBase;
2607	hrc = serialPort->COMGETTER(IOBase)(&ulIOBase); H();
2608	InsertConfigInteger(pCfg, "IOBase", ulIOBase);
2609	auSerialIoPortBase[ulInstance] = (uint16_t)ulIOBase;
2610
2611	BOOL fServer;
2612	hrc = serialPort->COMGETTER(Server)(&fServer); H();
2613	hrc = serialPort->COMGETTER(Path)(bstr.asOutParam()); H();
2614	UartType_T eUartType;
2615	const char *pszUartType;
2616	hrc = serialPort->COMGETTER(UartType)(&eUartType); H();
2617	switch (eUartType)
2618	{
2619	case UartType_U16450: pszUartType = "16450"; break;
2620	case UartType_U16750: pszUartType = "16750"; break;
2621	default: AssertFailed(); RT_FALL_THRU();
2622	case UartType_U16550A: pszUartType = "16550A"; break;
2623	}
2624	InsertConfigString(pCfg, "UartType", pszUartType);
2625
2626	PortMode_T eHostMode;
2627	hrc = serialPort->COMGETTER(HostMode)(&eHostMode); H();
2628
2629	m_aeSerialPortMode[ulInstance] = eHostMode;
2630	if (eHostMode != PortMode_Disconnected)
2631	{
2632	vrc = i_configSerialPort(pInst, eHostMode, Utf8Str(bstr).c_str(), RT_BOOL(fServer));
2633	if (RT_FAILURE(vrc))
2634	return vrc;
2635	}
2636	}
2637
2638	/*
2639	* Parallel (LPT) Ports
2640	*/
2641	/* parallel enabled mask to be passed to dev ACPI */
2642	uint16_t auParallelIoPortBase[SchemaDefs::ParallelPortCount] = {0};
2643	uint8_t auParallelIrq[SchemaDefs::ParallelPortCount] = {0};
2644	InsertConfigNode(pDevices, "parallel", &pDev);
2645	for (ULONG ulInstance = 0; ulInstance < SchemaDefs::ParallelPortCount; ++ulInstance)
2646	{
2647	ComPtr<IParallelPort> parallelPort;
2648	hrc = pMachine->GetParallelPort(ulInstance, parallelPort.asOutParam()); H();
2649	BOOL fEnabledParPort = FALSE;
2650	if (parallelPort)
2651	{
2652	hrc = parallelPort->COMGETTER(Enabled)(&fEnabledParPort); H();
2653	}
2654	if (!fEnabledParPort)
2655	continue;
2656
2657	InsertConfigNode(pDev, Utf8StrFmt("%u", ulInstance).c_str(), &pInst);
2658	InsertConfigNode(pInst, "Config", &pCfg);
2659
2660	ULONG ulIRQ;
2661	hrc = parallelPort->COMGETTER(IRQ)(&ulIRQ); H();
2662	InsertConfigInteger(pCfg, "IRQ", ulIRQ);
2663	auParallelIrq[ulInstance] = (uint8_t)ulIRQ;
2664	ULONG ulIOBase;
2665	hrc = parallelPort->COMGETTER(IOBase)(&ulIOBase); H();
2666	InsertConfigInteger(pCfg, "IOBase", ulIOBase);
2667	auParallelIoPortBase[ulInstance] = (uint16_t)ulIOBase;
2668
2669	hrc = parallelPort->COMGETTER(Path)(bstr.asOutParam()); H();
2670	if (!bstr.isEmpty())
2671	{
2672	InsertConfigNode(pInst, "LUN#0", &pLunL0);
2673	InsertConfigString(pLunL0, "Driver", "HostParallel");
2674	InsertConfigNode(pLunL0, "Config", &pLunL1);
2675	InsertConfigString(pLunL1, "DevicePath", bstr);
2676	}
2677	}
2678
2679	/*
2680	* VMM Device
2681	*/
2682	InsertConfigNode(pDevices, "VMMDev", &pDev);
2683	InsertConfigNode(pDev, "0", &pInst);
2684	InsertConfigNode(pInst, "Config", &pCfg);
2685	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
2686	hrc = pBusMgr->assignPCIDevice("VMMDev", pInst); H();
2687
2688	Bstr hwVersion;
2689	hrc = pMachine->COMGETTER(HardwareVersion)(hwVersion.asOutParam()); H();
2690	if (hwVersion.compare(Bstr("1").raw()) == 0) /* <= 2.0.x */
2691	InsertConfigInteger(pCfg, "HeapEnabled", 0);
2692	Bstr snapshotFolder;
2693	hrc = pMachine->COMGETTER(SnapshotFolder)(snapshotFolder.asOutParam()); H();
2694	InsertConfigString(pCfg, "GuestCoreDumpDir", snapshotFolder);
2695
2696	/* the VMM device's Main driver */
2697	InsertConfigNode(pInst, "LUN#0", &pLunL0);
2698	InsertConfigString(pLunL0, "Driver", "HGCM");
2699	InsertConfigNode(pLunL0, "Config", &pCfg);
2700
2701	/*
2702	* Attach the status driver.
2703	*/
2704	i_attachStatusDriver(pInst, DeviceType_SharedFolder);
2705
2706	/*
2707	* Audio configuration.
2708	*/
2709
2710	/*
2711	* AC'97 ICH / SoundBlaster16 audio / Intel HD Audio.
2712	*/
2713	ComPtr<IAudioSettings> audioSettings;
2714	hrc = pMachine->COMGETTER(AudioSettings)(audioSettings.asOutParam()); H();
2715
2716	BOOL fAudioEnabled = FALSE;
2717	ComPtr<IAudioAdapter> audioAdapter;
2718	hrc = audioSettings->COMGETTER(Adapter)(audioAdapter.asOutParam()); H();
2719	if (audioAdapter)
2720	{
2721	hrc = audioAdapter->COMGETTER(Enabled)(&fAudioEnabled); H();
2722	}
2723
2724	if (fAudioEnabled)
2725	{
2726	AudioControllerType_T enmAudioController;
2727	hrc = audioAdapter->COMGETTER(AudioController)(&enmAudioController); H();
2728	AudioCodecType_T enmAudioCodec;
2729	hrc = audioAdapter->COMGETTER(AudioCodec)(&enmAudioCodec); H();
2730
2731	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/Audio/Device/TimerHz", &strTmp);
2732	const uint64_t uTimerHz = strTmp.toUInt64();
2733
2734	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/Audio/Device/BufSizeInMs", &strTmp);
2735	const uint64_t uBufSizeInMs = strTmp.toUInt64();
2736
2737	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/Audio/Device/BufSizeOutMs", &strTmp);
2738	const uint64_t uBufSizeOutMs = strTmp.toUInt64();
2739
2740	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/Audio/Debug/Enabled", &strTmp);
2741	const bool fDebugEnabled = strTmp.equalsIgnoreCase("true") \|\| strTmp.equalsIgnoreCase("1");
2742
2743	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/Audio/Debug/Level", &strTmp);
2744	const uint32_t uDebugLevel = strTmp.toUInt32();
2745
2746	Utf8Str strDebugPathOut;
2747	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/Audio/Debug/PathOut", &strDebugPathOut);
2748
2749	#ifdef VBOX_WITH_AUDIO_VALIDATIONKIT
2750	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/Audio/VaKit/Enabled", &strTmp); /* Deprecated; do not use! */
2751	if (strTmp.isEmpty())
2752	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/Audio/ValKit/Enabled", &strTmp);
2753	/* Whether the Validation Kit audio backend runs as the primary backend.
2754	* Can also be used with VBox release builds. */
2755	const bool fValKitEnabled = strTmp.equalsIgnoreCase("true") \|\| strTmp.equalsIgnoreCase("1");
2756	#endif
2757	/** @todo Implement an audio device class, similar to the audio backend class, to construct the common stuff
2758	* without duplicating (more) code. */
2759
2760	const char *pszAudioDevice;
2761	switch (enmAudioController)
2762	{
2763	case AudioControllerType_AC97:
2764	{
2765	/* ICH AC'97. */
2766	pszAudioDevice = "ichac97";
2767
2768	InsertConfigNode(pDevices, pszAudioDevice, &pDev);
2769	InsertConfigNode(pDev, "0", &pInst);
2770	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
2771	hrc = pBusMgr->assignPCIDevice(pszAudioDevice, pInst); H();
2772	InsertConfigNode(pInst, "Config", &pCfg);
2773	switch (enmAudioCodec)
2774	{
2775	case AudioCodecType_STAC9700:
2776	InsertConfigString(pCfg, "Codec", "STAC9700");
2777	break;
2778	case AudioCodecType_AD1980:
2779	InsertConfigString(pCfg, "Codec", "AD1980");
2780	break;
2781	default: AssertFailedBreak();
2782	}
2783	if (uTimerHz)
2784	InsertConfigInteger(pCfg, "TimerHz", uTimerHz);
2785	if (uBufSizeInMs)
2786	InsertConfigInteger(pCfg, "BufSizeInMs", uBufSizeInMs);
2787	if (uBufSizeOutMs)
2788	InsertConfigInteger(pCfg, "BufSizeOutMs", uBufSizeOutMs);
2789	InsertConfigInteger(pCfg, "DebugEnabled", fDebugEnabled);
2790	if (strDebugPathOut.isNotEmpty())
2791	InsertConfigString(pCfg, "DebugPathOut", strDebugPathOut);
2792	break;
2793	}
2794	case AudioControllerType_SB16:
2795	{
2796	/* Legacy SoundBlaster16. */
2797	pszAudioDevice = "sb16";
2798
2799	InsertConfigNode(pDevices, pszAudioDevice, &pDev);
2800	InsertConfigNode(pDev, "0", &pInst);
2801	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
2802	InsertConfigNode(pInst, "Config", &pCfg);
2803	InsertConfigInteger(pCfg, "IRQ", 5);
2804	InsertConfigInteger(pCfg, "DMA", 1);
2805	InsertConfigInteger(pCfg, "DMA16", 5);
2806	InsertConfigInteger(pCfg, "Port", 0x220);
2807	InsertConfigInteger(pCfg, "Version", 0x0405);
2808	if (uTimerHz)
2809	InsertConfigInteger(pCfg, "TimerHz", uTimerHz);
2810	InsertConfigInteger(pCfg, "DebugEnabled", fDebugEnabled);
2811	if (strDebugPathOut.isNotEmpty())
2812	InsertConfigString(pCfg, "DebugPathOut", strDebugPathOut);
2813	break;
2814	}
2815	case AudioControllerType_HDA:
2816	{
2817	/* Intel HD Audio. */
2818	pszAudioDevice = "hda";
2819
2820	InsertConfigNode(pDevices, pszAudioDevice, &pDev);
2821	InsertConfigNode(pDev, "0", &pInst);
2822	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
2823	hrc = pBusMgr->assignPCIDevice(pszAudioDevice, pInst); H();
2824	InsertConfigNode(pInst, "Config", &pCfg);
2825	if (uBufSizeInMs)
2826	InsertConfigInteger(pCfg, "BufSizeInMs", uBufSizeInMs);
2827	if (uBufSizeOutMs)
2828	InsertConfigInteger(pCfg, "BufSizeOutMs", uBufSizeOutMs);
2829	InsertConfigInteger(pCfg, "DebugEnabled", fDebugEnabled);
2830	if (strDebugPathOut.isNotEmpty())
2831	InsertConfigString(pCfg, "DebugPathOut", strDebugPathOut);
2832
2833	/* macOS guests uses a different HDA variant to make 10.14+ (or maybe 10.13?) recognize the device. */
2834	if (fOsXGuest)
2835	InsertConfigString(pCfg, "DeviceName", "Intel Sunrise Point");
2836	break;
2837	}
2838	default:
2839	pszAudioDevice = "oops";
2840	AssertFailedBreak();
2841	}
2842
2843	PCFGMNODE pCfgAudioAdapter = NULL;
2844	InsertConfigNode(pInst, "AudioConfig", &pCfgAudioAdapter);
2845	SafeArray<BSTR> audioProps;
2846	hrc = audioAdapter->COMGETTER(PropertiesList)(ComSafeArrayAsOutParam(audioProps)); H();
2847
2848	std::list<Utf8Str> audioPropertyNamesList;
2849	for (size_t i = 0; i < audioProps.size(); ++i)
2850	{
2851	Bstr bstrValue;
2852	audioPropertyNamesList.push_back(Utf8Str(audioProps[i]));
2853	hrc = audioAdapter->GetProperty(audioProps[i], bstrValue.asOutParam());
2854	Utf8Str strKey(audioProps[i]);
2855	InsertConfigString(pCfgAudioAdapter, strKey.c_str(), bstrValue);
2856	}
2857
2858	/*
2859	* The audio driver.
2860	*/
2861	const char *pszAudioDriver = NULL;
2862	#ifdef VBOX_WITH_AUDIO_VALIDATIONKIT
2863	if (fValKitEnabled)
2864	{
2865	pszAudioDriver = "ValidationKitAudio";
2866	LogRel(("Audio: ValidationKit driver active\n"));
2867	}
2868	#endif
2869	/* If nothing else was selected before, ask the API. */
2870	if (pszAudioDriver == NULL)
2871	{
2872	AudioDriverType_T enmAudioDriver;
2873	hrc = audioAdapter->COMGETTER(AudioDriver)(&enmAudioDriver); H();
2874
2875	/* The "Default" audio driver needs special treatment, as we need to figure out which driver to use
2876	* by default on the current platform. */
2877	bool const fUseDefaultDrv = enmAudioDriver == AudioDriverType_Default;
2878
2879	AudioDriverType_T const enmDefaultAudioDriver = settings::MachineConfigFile::getHostDefaultAudioDriver();
2880
2881	if (fUseDefaultDrv)
2882	{
2883	enmAudioDriver = enmDefaultAudioDriver;
2884	if (enmAudioDriver == AudioDriverType_Null)
2885	LogRel(("Audio: Warning: No default driver detected for current platform -- defaulting to Null audio backend\n"));
2886	}
2887
2888	switch (enmAudioDriver)
2889	{
2890	case AudioDriverType_Default: /* Can't happen, but handle it anyway. */
2891	RT_FALL_THROUGH();
2892	case AudioDriverType_Null:
2893	pszAudioDriver = "NullAudio";
2894	break;
2895	#ifdef RT_OS_WINDOWS
2896	# ifdef VBOX_WITH_WINMM
2897	case AudioDriverType_WinMM:
2898	# error "Port WinMM audio backend!" /** @todo Still needed? */
2899	break;
2900	# endif
2901	case AudioDriverType_DirectSound:
2902	/* Use the Windows Audio Session (WAS) API rather than Direct Sound on Windows
2903	versions we've tested it on (currently W7+). Since Vista, Direct Sound has
2904	been emulated on top of WAS according to the docs, so better use WAS directly.
2905
2906	Set extradata value "VBoxInternal2/Audio/WindowsDrv" "dsound" to no use WasAPI.
2907
2908	Keep this hack for backwards compatibility (introduced < 7.0).
2909	*/
2910	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/Audio/WindowsDrv", &strTmp); H();
2911	if ( enmDefaultAudioDriver == AudioDriverType_WAS
2912	&& ( strTmp.isEmpty()
2913	\|\| strTmp.equalsIgnoreCase("was")
2914	\|\| strTmp.equalsIgnoreCase("wasapi")) )
2915	{
2916	/* Nothing to do here, fall through to WAS driver. */
2917	}
2918	else
2919	{
2920	pszAudioDriver = "DSoundAudio";
2921	break;
2922	}
2923	RT_FALL_THROUGH();
2924	case AudioDriverType_WAS:
2925	if (enmDefaultAudioDriver == AudioDriverType_WAS) /* WAS supported? */
2926	pszAudioDriver = "HostAudioWas";
2927	else if (enmDefaultAudioDriver == AudioDriverType_DirectSound)
2928	{
2929	LogRel(("Audio: Warning: Windows Audio Session (WAS) not supported, defaulting to DirectSound backend\n"));
2930	pszAudioDriver = "DSoundAudio";
2931	}
2932	break;
2933	#endif /* RT_OS_WINDOWS */
2934	#ifdef RT_OS_SOLARIS
2935	case AudioDriverType_SolAudio:
2936	/* Should not happen, as the Solaris Audio backend is not around anymore.
2937	* Remove this sometime later. */
2938	LogRel(("Audio: Warning: Solaris Audio is deprecated, please switch to OSS!\n"));
2939	LogRel(("Audio: Automatically setting host audio backend to OSS\n"));
2940
2941	/* Manually set backend to OSS for now. */
2942	pszAudioDriver = "OSSAudio";
2943	break;
2944	#endif
2945	#ifdef VBOX_WITH_AUDIO_OSS
2946	case AudioDriverType_OSS:
2947	pszAudioDriver = "OSSAudio";
2948	break;
2949	#endif
2950	#ifdef VBOX_WITH_AUDIO_ALSA
2951	case AudioDriverType_ALSA:
2952	pszAudioDriver = "ALSAAudio";
2953	break;
2954	#endif
2955	#ifdef VBOX_WITH_AUDIO_PULSE
2956	case AudioDriverType_Pulse:
2957	pszAudioDriver = "PulseAudio";
2958	break;
2959	#endif
2960	#ifdef RT_OS_DARWIN
2961	case AudioDriverType_CoreAudio:
2962	pszAudioDriver = "CoreAudio";
2963	break;
2964	#endif
2965	default:
2966	pszAudioDriver = "oops";
2967	AssertFailedBreak();
2968	}
2969
2970	if (fUseDefaultDrv)
2971	LogRel(("Audio: Detected default audio driver type is '%s'\n", pszAudioDriver));
2972	}
2973
2974	BOOL fAudioEnabledIn = FALSE;
2975	hrc = audioAdapter->COMGETTER(EnabledIn)(&fAudioEnabledIn); H();
2976	BOOL fAudioEnabledOut = FALSE;
2977	hrc = audioAdapter->COMGETTER(EnabledOut)(&fAudioEnabledOut); H();
2978
2979	unsigned idxAudioLun = 0;
2980
2981	InsertConfigNodeF(pInst, &pLunL0, "LUN#%u", idxAudioLun);
2982	i_configAudioDriver(virtualBox, pMachine, pLunL0, pszAudioDriver, !!fAudioEnabledIn, !!fAudioEnabledOut);
2983	idxAudioLun++;
2984
2985	#ifdef VBOX_WITH_AUDIO_VRDE
2986	/* Insert dummy audio driver to have the LUN configured. */
2987	InsertConfigNodeF(pInst, &pLunL0, "LUN#%u", idxAudioLun);
2988	InsertConfigString(pLunL0, "Driver", "AUDIO");
2989	{
2990	AudioDriverCfg DrvCfgVRDE(pszAudioDevice, 0 /* Instance */, idxAudioLun, "AudioVRDE",
2991	!!fAudioEnabledIn, !!fAudioEnabledOut);
2992	vrc = mAudioVRDE->InitializeConfig(&DrvCfgVRDE);
2993	AssertRCStmt(vrc, throw ConfigError(__FUNCTION__, vrc, "mAudioVRDE->InitializeConfig failed"));
2994	}
2995	idxAudioLun++;
2996	#endif
2997
2998	#ifdef VBOX_WITH_AUDIO_RECORDING
2999	/* Insert dummy audio driver to have the LUN configured. */
3000	InsertConfigNodeF(pInst, &pLunL0, "LUN#%u", idxAudioLun);
3001	InsertConfigString(pLunL0, "Driver", "AUDIO");
3002	{
3003	AudioDriverCfg DrvCfgVideoRec(pszAudioDevice, 0 /* Instance */, idxAudioLun, "AudioVideoRec",
3004	false /a_fEnabledIn/, true /a_fEnabledOut/);
3005	vrc = mRecording.mAudioRec->InitializeConfig(&DrvCfgVideoRec);
3006	AssertRCStmt(vrc, throw ConfigError(__FUNCTION__, vrc, "Recording.mAudioRec->InitializeConfig failed"));
3007	}
3008	idxAudioLun++;
3009	#endif
3010
3011	if (fDebugEnabled)
3012	{
3013	#ifdef VBOX_WITH_AUDIO_DEBUG
3014	# ifdef VBOX_WITH_AUDIO_VALIDATIONKIT
3015	/*
3016	* When both, ValidationKit and Debug mode (for audio) are enabled,
3017	* skip configuring the Debug audio driver, as both modes can
3018	* mess with the audio data and would lead to side effects.
3019	*
3020	* The ValidationKit audio driver has precedence over the Debug audio driver.
3021	*
3022	* This also can (and will) be used in VBox release builds.
3023	*/
3024	if (fValKitEnabled)
3025	{
3026	LogRel(("Audio: Warning: ValidationKit running and Debug mode enabled -- disabling Debug driver\n"));
3027	}
3028	else /* Debug mode active -- run both (nice for catching errors / doing development). */
3029	{
3030	/*
3031	* The ValidationKit backend.
3032	*/
3033	InsertConfigNodeF(pInst, &pLunL0, "LUN#%u", idxAudioLun);
3034	i_configAudioDriver(virtualBox, pMachine, pLunL0, "ValidationKitAudio",
3035	!!fAudioEnabledIn, !!fAudioEnabledOut);
3036	idxAudioLun++;
3037	# endif /* VBOX_WITH_AUDIO_VALIDATIONKIT */
3038	/*
3039	* The Debug audio backend.
3040	*/
3041	InsertConfigNodeF(pInst, &pLunL0, "LUN#%u", idxAudioLun);
3042	i_configAudioDriver(virtualBox, pMachine, pLunL0, "DebugAudio",
3043	!!fAudioEnabledIn, !!fAudioEnabledOut);
3044	idxAudioLun++;
3045	# ifdef VBOX_WITH_AUDIO_VALIDATIONKIT
3046	}
3047	# endif /* VBOX_WITH_AUDIO_VALIDATIONKIT */
3048	#endif /* VBOX_WITH_AUDIO_DEBUG */
3049
3050	/*
3051	* Tweak the logging groups.
3052	*/
3053	Utf8Str strGroups("drv_audio.e.l.l2.l3.f"
3054	" audio_mixer.e.l.l2.l3.f"
3055	" dev_hda_codec.e.l.l2.l3.f"
3056	" dev_hda.e.l.l2.l3.f"
3057	" dev_ac97.e.l.l2.l3.f"
3058	" dev_sb16.e.l.l2.l3.f");
3059
3060	LogRel(("Audio: Debug level set to %RU32\n", uDebugLevel));
3061
3062	switch (uDebugLevel)
3063	{
3064	case 0:
3065	strGroups += " drv_host_audio.e.l.l2.l3.f";
3066	break;
3067	case 1:
3068	RT_FALL_THROUGH();
3069	case 2:
3070	RT_FALL_THROUGH();
3071	case 3:
3072	strGroups += " drv_host_audio.e.l.l2.l3.f+audio_test.e.l.l2.l3.f";
3073	break;
3074	case 4:
3075	RT_FALL_THROUGH();
3076	default:
3077	strGroups += " drv_host_audio.e.l.l2.l3.l4.f+audio_test.e.l.l2.l3.l4.f";
3078	break;
3079	}
3080
3081	vrc = RTLogGroupSettings(RTLogRelGetDefaultInstance(), strGroups.c_str());
3082	if (RT_FAILURE(vrc))
3083	LogRel(("Audio: Setting debug logging failed, vrc=%Rrc\n", vrc));
3084	}
3085	}
3086
3087	#ifdef VBOX_WITH_SHARED_CLIPBOARD
3088	/*
3089	* Shared Clipboard.
3090	*/
3091	{
3092	ClipboardMode_T enmClipboardMode = ClipboardMode_Disabled;
3093	hrc = pMachine->COMGETTER(ClipboardMode)(&enmClipboardMode); H();
3094	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
3095	BOOL fFileTransfersEnabled;
3096	hrc = pMachine->COMGETTER(ClipboardFileTransfersEnabled)(&fFileTransfersEnabled); H();
3097	#endif
3098
3099	/* Load the service */
3100	vrc = pVMMDev->hgcmLoadService("VBoxSharedClipboard", "VBoxSharedClipboard");
3101	if (RT_SUCCESS(vrc))
3102	{
3103	LogRel(("Shared Clipboard: Service loaded\n"));
3104
3105	/* Set initial clipboard mode. */
3106	vrc = i_changeClipboardMode(enmClipboardMode);
3107	AssertLogRelMsg(RT_SUCCESS(vrc), ("Shared Clipboard: Failed to set initial clipboard mode (%d): vrc=%Rrc\n",
3108	enmClipboardMode, vrc));
3109
3110	/* Setup the service. */
3111	VBOXHGCMSVCPARM parm;
3112	HGCMSvcSetU32(&parm, !i_useHostClipboard());
3113	vrc = pVMMDev->hgcmHostCall("VBoxSharedClipboard", VBOX_SHCL_HOST_FN_SET_HEADLESS, 1, &parm);
3114	AssertLogRelMsg(RT_SUCCESS(vrc), ("Shared Clipboard: Failed to set initial headless mode (%RTbool): vrc=%Rrc\n",
3115	!i_useHostClipboard(), vrc));
3116
3117	# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
3118	vrc = i_changeClipboardFileTransferMode(RT_BOOL(fFileTransfersEnabled));
3119	AssertLogRelMsg(RT_SUCCESS(vrc), ("Shared Clipboard: Failed to set initial file transfer mode (%u): vrc=%Rrc\n",
3120	fFileTransfersEnabled, vrc));
3121	# endif
3122	GuestShCl::createInstance(this /* pConsole */);
3123	vrc = HGCMHostRegisterServiceExtension(&m_hHgcmSvcExtShCl, "VBoxSharedClipboard",
3124	&GuestShCl::hgcmDispatcher,
3125	GuestShClInst());
3126	if (RT_FAILURE(vrc))
3127	Log(("Cannot register VBoxSharedClipboard extension, vrc=%Rrc\n", vrc));
3128	}
3129	else
3130	LogRel(("Shared Clipboard: Not available, vrc=%Rrc\n", vrc));
3131	vrc = VINF_SUCCESS; /* None of the potential failures above are fatal. */
3132	}
3133	#endif /* VBOX_WITH_SHARED_CLIPBOARD */
3134
3135	/*
3136	* HGCM HostChannel.
3137	*/
3138	{
3139	Bstr value;
3140	hrc = pMachine->GetExtraData(Bstr("HGCM/HostChannel").raw(),
3141	value.asOutParam());
3142
3143	if ( hrc == S_OK
3144	&& value == "1")
3145	{
3146	vrc = pVMMDev->hgcmLoadService("VBoxHostChannel", "VBoxHostChannel");
3147	if (RT_FAILURE(vrc))
3148	{
3149	LogRel(("VBoxHostChannel is not available, vrc=%Rrc\n", vrc));
3150	/* That is not a fatal failure. */
3151	vrc = VINF_SUCCESS;
3152	}
3153	}
3154	}
3155
3156	#ifdef VBOX_WITH_DRAG_AND_DROP
3157	/*
3158	* Drag and Drop.
3159	*/
3160	{
3161	DnDMode_T enmMode = DnDMode_Disabled;
3162	hrc = pMachine->COMGETTER(DnDMode)(&enmMode); H();
3163
3164	/* Load the service */
3165	vrc = pVMMDev->hgcmLoadService("VBoxDragAndDropSvc", "VBoxDragAndDropSvc");
3166	if (RT_FAILURE(vrc))
3167	{
3168	LogRel(("Drag and drop service is not available, vrc=%Rrc\n", vrc));
3169	/* That is not a fatal failure. */
3170	vrc = VINF_SUCCESS;
3171	}
3172	else
3173	{
3174	vrc = HGCMHostRegisterServiceExtension(&m_hHgcmSvcExtDragAndDrop, "VBoxDragAndDropSvc",
3175	&GuestDnD::notifyDnDDispatcher,
3176	GuestDnDInst());
3177	if (RT_FAILURE(vrc))
3178	Log(("Cannot register VBoxDragAndDropSvc extension, vrc=%Rrc\n", vrc));
3179	else
3180	{
3181	LogRel(("Drag and drop service loaded\n"));
3182	vrc = i_changeDnDMode(enmMode);
3183	}
3184	}
3185	}
3186	#endif /* VBOX_WITH_DRAG_AND_DROP */
3187
3188	#if defined(VBOX_WITH_TPM)
3189	/*
3190	* Configure the Trusted Platform Module.
3191	*/
3192	ComObjPtr<ITrustedPlatformModule> ptrTpm;
3193	TpmType_T enmTpmType = TpmType_None;
3194
3195	hrc = pMachine->COMGETTER(TrustedPlatformModule)(ptrTpm.asOutParam()); H();
3196	hrc = ptrTpm->COMGETTER(Type)(&enmTpmType); H();
3197	if (enmTpmType != TpmType_None)
3198	{
3199	InsertConfigNode(pDevices, "tpm", &pDev);
3200	InsertConfigNode(pDev, "0", &pInst);
3201	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
3202	InsertConfigNode(pInst, "Config", &pCfg);
3203	InsertConfigNode(pInst, "LUN#0", &pLunL0);
3204
3205	switch (enmTpmType)
3206	{
3207	case TpmType_v1_2:
3208	case TpmType_v2_0:
3209	InsertConfigString(pLunL0, "Driver", "TpmEmuTpms");
3210	InsertConfigNode(pLunL0, "Config", &pCfg);
3211	InsertConfigInteger(pCfg, "TpmVersion", enmTpmType == TpmType_v1_2 ? 1 : 2);
3212	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
3213	InsertConfigString(pLunL1, "Driver", "NvramStore");
3214	break;
3215	case TpmType_Host:
3216	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_WINDOWS)
3217	InsertConfigString(pLunL0, "Driver", "TpmHost");
3218	InsertConfigNode(pLunL0, "Config", &pCfg);
3219	#endif
3220	break;
3221	case TpmType_Swtpm:
3222	hrc = ptrTpm->COMGETTER(Location)(bstr.asOutParam()); H();
3223	InsertConfigString(pLunL0, "Driver", "TpmEmu");
3224	InsertConfigNode(pLunL0, "Config", &pCfg);
3225	InsertConfigString(pCfg, "Location", bstr);
3226	break;
3227	default:
3228	AssertFailedBreak();
3229	}
3230	}
3231	#endif
3232
3233	/*
3234	* ACPI
3235	*/
3236	BOOL fACPI;
3237	hrc = biosSettings->COMGETTER(ACPIEnabled)(&fACPI); H();
3238	if (fACPI)
3239	{
3240	/* Always show the CPU leafs when we have multiple VCPUs or when the IO-APIC is enabled.
3241	* The Windows SMP kernel needs a CPU leaf or else its idle loop will burn cpu cycles; the
3242	* intelppm driver refuses to register an idle state handler.
3243	* Always show CPU leafs for OS X guests. */
3244	BOOL fShowCpu = fOsXGuest;
3245	if (cCpus > 1 \|\| fIOAPIC)
3246	fShowCpu = true;
3247
3248	BOOL fCpuHotPlug;
3249	hrc = pMachine->COMGETTER(CPUHotPlugEnabled)(&fCpuHotPlug); H();
3250
3251	InsertConfigNode(pDevices, "acpi", &pDev);
3252	InsertConfigNode(pDev, "0", &pInst);
3253	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
3254	InsertConfigNode(pInst, "Config", &pCfg);
3255	hrc = pBusMgr->assignPCIDevice("acpi", pInst); H();
3256
3257	InsertConfigInteger(pCfg, "NumCPUs", cCpus);
3258
3259	InsertConfigInteger(pCfg, "IOAPIC", fIOAPIC);
3260	InsertConfigInteger(pCfg, "FdcEnabled", fFdcEnabled);
3261	InsertConfigInteger(pCfg, "HpetEnabled", fHPETEnabled);
3262	InsertConfigInteger(pCfg, "SmcEnabled", fSmcEnabled);
3263	InsertConfigInteger(pCfg, "ShowRtc", fShowRtc);
3264	if (fOsXGuest && !llBootNics.empty())
3265	{
3266	BootNic aNic = llBootNics.front();
3267	uint32_t u32NicPCIAddr = (aNic.mPCIAddress.miDevice << 16) \| aNic.mPCIAddress.miFn;
3268	InsertConfigInteger(pCfg, "NicPciAddress", u32NicPCIAddr);
3269	}
3270	if (fOsXGuest && fAudioEnabled)
3271	{
3272	PCIBusAddress Address;
3273	if (pBusMgr->findPCIAddress("hda", 0, Address))
3274	{
3275	uint32_t u32AudioPCIAddr = (Address.miDevice << 16) \| Address.miFn;
3276	InsertConfigInteger(pCfg, "AudioPciAddress", u32AudioPCIAddr);
3277	}
3278	}
3279	if (fOsXGuest)
3280	{
3281	PCIBusAddress Address;
3282	if (pBusMgr->findPCIAddress("nvme", 0, Address))
3283	{
3284	uint32_t u32NvmePCIAddr = (Address.miDevice << 16) \| Address.miFn;
3285	InsertConfigInteger(pCfg, "NvmePciAddress", u32NvmePCIAddr);
3286	}
3287	}
3288	if (enmIommuType == IommuType_AMD)
3289	{
3290	PCIBusAddress Address;
3291	if (pBusMgr->findPCIAddress("iommu-amd", 0, Address))
3292	{
3293	uint32_t u32IommuAddress = (Address.miDevice << 16) \| Address.miFn;
3294	InsertConfigInteger(pCfg, "IommuAmdEnabled", true);
3295	InsertConfigInteger(pCfg, "IommuPciAddress", u32IommuAddress);
3296	if (pBusMgr->findPCIAddress("sb-ioapic", 0, Address))
3297	{
3298	uint32_t const u32SbIoapicAddress = (Address.miDevice << 16) \| Address.miFn;
3299	InsertConfigInteger(pCfg, "SbIoApicPciAddress", u32SbIoapicAddress);
3300	}
3301	else
3302	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
3303	N_("AMD IOMMU is enabled, but the I/O APIC is not assigned a PCI address!"));
3304	}
3305	}
3306	else if (enmIommuType == IommuType_Intel)
3307	{
3308	PCIBusAddress Address;
3309	if (pBusMgr->findPCIAddress("iommu-intel", 0, Address))
3310	{
3311	uint32_t u32IommuAddress = (Address.miDevice << 16) \| Address.miFn;
3312	InsertConfigInteger(pCfg, "IommuIntelEnabled", true);
3313	InsertConfigInteger(pCfg, "IommuPciAddress", u32IommuAddress);
3314	if (pBusMgr->findPCIAddress("sb-ioapic", 0, Address))
3315	{
3316	uint32_t const u32SbIoapicAddress = (Address.miDevice << 16) \| Address.miFn;
3317	InsertConfigInteger(pCfg, "SbIoApicPciAddress", u32SbIoapicAddress);
3318	}
3319	else
3320	return pVMM->pfnVMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
3321	N_("Intel IOMMU is enabled, but the I/O APIC is not assigned a PCI address!"));
3322	}
3323	}
3324
3325	InsertConfigInteger(pCfg, "IocPciAddress", uIocPCIAddress);
3326	if (chipsetType == ChipsetType_ICH9)
3327	{
3328	InsertConfigInteger(pCfg, "McfgBase", uMcfgBase);
3329	InsertConfigInteger(pCfg, "McfgLength", cbMcfgLength);
3330	/* 64-bit prefetch window root resource: Only for ICH9 and if PAE or Long Mode is enabled (@bugref{5454}). */
3331	if (fIsGuest64Bit \|\| fEnablePAE)
3332	InsertConfigInteger(pCfg, "PciPref64Enabled", 1);
3333	}
3334	InsertConfigInteger(pCfg, "HostBusPciAddress", uHbcPCIAddress);
3335	InsertConfigInteger(pCfg, "ShowCpu", fShowCpu);
3336	InsertConfigInteger(pCfg, "CpuHotPlug", fCpuHotPlug);
3337
3338	InsertConfigInteger(pCfg, "Serial0IoPortBase", auSerialIoPortBase[0]);
3339	InsertConfigInteger(pCfg, "Serial0Irq", auSerialIrq[0]);
3340
3341	InsertConfigInteger(pCfg, "Serial1IoPortBase", auSerialIoPortBase[1]);
3342	InsertConfigInteger(pCfg, "Serial1Irq", auSerialIrq[1]);
3343
3344	if (auSerialIoPortBase[2])
3345	{
3346	InsertConfigInteger(pCfg, "Serial2IoPortBase", auSerialIoPortBase[2]);
3347	InsertConfigInteger(pCfg, "Serial2Irq", auSerialIrq[2]);
3348	}
3349
3350	if (auSerialIoPortBase[3])
3351	{
3352	InsertConfigInteger(pCfg, "Serial3IoPortBase", auSerialIoPortBase[3]);
3353	InsertConfigInteger(pCfg, "Serial3Irq", auSerialIrq[3]);
3354	}
3355
3356	InsertConfigInteger(pCfg, "Parallel0IoPortBase", auParallelIoPortBase[0]);
3357	InsertConfigInteger(pCfg, "Parallel0Irq", auParallelIrq[0]);
3358
3359	InsertConfigInteger(pCfg, "Parallel1IoPortBase", auParallelIoPortBase[1]);
3360	InsertConfigInteger(pCfg, "Parallel1Irq", auParallelIrq[1]);
3361
3362	#if defined(VBOX_WITH_TPM)
3363	switch (enmTpmType)
3364	{
3365	case TpmType_v1_2:
3366	InsertConfigString(pCfg, "TpmMode", "tis1.2");
3367	break;
3368	case TpmType_v2_0:
3369	InsertConfigString(pCfg, "TpmMode", "fifo2.0");
3370	break;
3371	/** @todo Host and swtpm. */
3372	default:
3373	break;
3374	}
3375	#endif
3376
3377	InsertConfigNode(pInst, "LUN#0", &pLunL0);
3378	InsertConfigString(pLunL0, "Driver", "ACPIHost");
3379	InsertConfigNode(pLunL0, "Config", &pCfg);
3380
3381	/* Attach the dummy CPU drivers */
3382	for (ULONG iCpuCurr = 1; iCpuCurr < cCpus; iCpuCurr++)
3383	{
3384	BOOL fCpuAttached = true;
3385
3386	if (fCpuHotPlug)
3387	{
3388	hrc = pMachine->GetCPUStatus(iCpuCurr, &fCpuAttached); H();
3389	}
3390
3391	if (fCpuAttached)
3392	{
3393	InsertConfigNode(pInst, Utf8StrFmt("LUN#%u", iCpuCurr).c_str(), &pLunL0);
3394	InsertConfigString(pLunL0, "Driver", "ACPICpu");
3395	InsertConfigNode(pLunL0, "Config", &pCfg);
3396	}
3397	}
3398	}
3399
3400	/*
3401	* Configure DBGF (Debug(ger) Facility) and DBGC (Debugger Console).
3402	*/
3403	{
3404	PCFGMNODE pDbgf;
3405	InsertConfigNode(pRoot, "DBGF", &pDbgf);
3406
3407	/* Paths to search for debug info and such things. */
3408	hrc = pMachine->COMGETTER(SettingsFilePath)(bstr.asOutParam()); H();
3409	Utf8Str strSettingsPath(bstr);
3410	bstr.setNull();
3411	strSettingsPath.stripFilename();
3412	strSettingsPath.append("/");
3413
3414	char szHomeDir[RTPATH_MAX + 1];
3415	int vrc2 = RTPathUserHome(szHomeDir, sizeof(szHomeDir) - 1);
3416	if (RT_FAILURE(vrc2))
3417	szHomeDir[0] = '\0';
3418	RTPathEnsureTrailingSeparator(szHomeDir, sizeof(szHomeDir));
3419
3420
3421	Utf8Str strPath;
3422	strPath.append(strSettingsPath).append("debug/;");
3423	strPath.append(strSettingsPath).append(";");
3424	strPath.append("cache").append(strSettingsPath).append("dbgcache/;"); / handy for symlinking to actual cache */
3425	strPath.append(szHomeDir);
3426
3427	InsertConfigString(pDbgf, "Path", strPath.c_str());
3428
3429	/* Tracing configuration. */
3430	BOOL fTracingEnabled;
3431	hrc = pMachine->COMGETTER(TracingEnabled)(&fTracingEnabled); H();
3432	if (fTracingEnabled)
3433	InsertConfigInteger(pDbgf, "TracingEnabled", 1);
3434
3435	hrc = pMachine->COMGETTER(TracingConfig)(bstr.asOutParam()); H();
3436	if (fTracingEnabled)
3437	InsertConfigString(pDbgf, "TracingConfig", bstr);
3438
3439	BOOL fAllowTracingToAccessVM;
3440	hrc = pMachine->COMGETTER(AllowTracingToAccessVM)(&fAllowTracingToAccessVM); H();
3441	if (fAllowTracingToAccessVM)
3442	InsertConfigInteger(pPDM, "AllowTracingToAccessVM", 1);
3443
3444	/* Debugger console config. */
3445	PCFGMNODE pDbgc;
3446	InsertConfigNode(pRoot, "DBGC", &pDbgc);
3447
3448	hrc = virtualBox->COMGETTER(HomeFolder)(bstr.asOutParam()); H();
3449	Utf8Str strVBoxHome = bstr;
3450	bstr.setNull();
3451	if (strVBoxHome.isNotEmpty())
3452	strVBoxHome.append("/");
3453	else
3454	{
3455	strVBoxHome = szHomeDir;
3456	strVBoxHome.append("/.vbox");
3457	}
3458
3459	Utf8Str strFile(strVBoxHome);
3460	strFile.append("dbgc-history");
3461	InsertConfigString(pDbgc, "HistoryFile", strFile);
3462
3463	strFile = strSettingsPath;
3464	strFile.append("dbgc-init");
3465	InsertConfigString(pDbgc, "LocalInitScript", strFile);
3466
3467	strFile = strVBoxHome;
3468	strFile.append("dbgc-init");
3469	InsertConfigString(pDbgc, "GlobalInitScript", strFile);
3470
3471	/*
3472	* Configure guest debug settings.
3473	*/
3474	ComObjPtr<IGuestDebugControl> ptrGstDbgCtrl;
3475	GuestDebugProvider_T enmGstDbgProvider = GuestDebugProvider_None;
3476
3477	hrc = pMachine->COMGETTER(GuestDebugControl)(ptrGstDbgCtrl.asOutParam()); H();
3478	hrc = ptrGstDbgCtrl->COMGETTER(DebugProvider)(&enmGstDbgProvider); H();
3479	if (enmGstDbgProvider != GuestDebugProvider_None)
3480	{
3481	GuestDebugIoProvider_T enmGstDbgIoProvider = GuestDebugIoProvider_None;
3482	hrc = ptrGstDbgCtrl->COMGETTER(DebugIoProvider)(&enmGstDbgIoProvider); H();
3483	hrc = ptrGstDbgCtrl->COMGETTER(DebugAddress)(bstr.asOutParam()); H();
3484	Utf8Str strAddress = bstr;
3485	bstr.setNull();
3486
3487	ULONG ulPort = 0;
3488	hrc = ptrGstDbgCtrl->COMGETTER(DebugPort)(&ulPort); H();
3489
3490	PCFGMNODE pDbgSettings;
3491	InsertConfigNode(pDbgc, "Dbg", &pDbgSettings);
3492	InsertConfigString(pDbgSettings, "Address", strAddress);
3493	InsertConfigInteger(pDbgSettings, "Port", ulPort);
3494
3495	switch (enmGstDbgProvider)
3496	{
3497	case GuestDebugProvider_Native:
3498	InsertConfigString(pDbgSettings, "StubType", "Native");
3499	break;
3500	case GuestDebugProvider_GDB:
3501	InsertConfigString(pDbgSettings, "StubType", "Gdb");
3502	break;
3503	case GuestDebugProvider_KD:
3504	InsertConfigString(pDbgSettings, "StubType", "Kd");
3505	break;
3506	default:
3507	AssertFailed();
3508	break;
3509	}
3510
3511	switch (enmGstDbgIoProvider)
3512	{
3513	case GuestDebugIoProvider_TCP:
3514	InsertConfigString(pDbgSettings, "Provider", "tcp");
3515	break;
3516	case GuestDebugIoProvider_UDP:
3517	InsertConfigString(pDbgSettings, "Provider", "udp");
3518	break;
3519	case GuestDebugIoProvider_IPC:
3520	InsertConfigString(pDbgSettings, "Provider", "ipc");
3521	break;
3522	default:
3523	AssertFailed();
3524	break;
3525	}
3526	}
3527	}
3528	}
3529	catch (ConfigError &x)
3530	{
3531	// InsertConfig threw something:
3532	pVMM->pfnVMR3SetError(pUVM, x.m_vrc, RT_SRC_POS, "Caught ConfigError: %Rrc - %s", x.m_vrc, x.what());
3533	return x.m_vrc;
3534	}
3535	catch (HRESULT hrcXcpt)
3536	{
3537	AssertLogRelMsgFailedReturn(("hrc=%Rhrc\n", hrcXcpt), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR);
3538	}
3539
3540	#ifdef VBOX_WITH_EXTPACK
3541	/*
3542	* Call the extension pack hooks if everything went well thus far.
3543	*/
3544	if (RT_SUCCESS(vrc))
3545	{
3546	pAlock->release();
3547	vrc = mptrExtPackManager->i_callAllVmConfigureVmmHooks(this, pVM, pVMM);
3548	pAlock->acquire();
3549	}
3550	#endif
3551
3552	/*
3553	* Apply the CFGM overlay.
3554	*/
3555	if (RT_SUCCESS(vrc))
3556	vrc = i_configCfgmOverlay(pRoot, virtualBox, pMachine);
3557
3558	/*
3559	* Dump all extradata API settings tweaks, both global and per VM.
3560	*/
3561	if (RT_SUCCESS(vrc))
3562	vrc = i_configDumpAPISettingsTweaks(virtualBox, pMachine);
3563
3564	#undef H
3565
3566	pAlock->release(); /* Avoid triggering the lock order inversion check. */
3567
3568	/*
3569	* Register VM state change handler.
3570	*/
3571	int vrc2 = pVMM->pfnVMR3AtStateRegister(pUVM, Console::i_vmstateChangeCallback, this);
3572	AssertRC(vrc2);
3573	if (RT_SUCCESS(vrc))
3574	vrc = vrc2;
3575
3576	/*
3577	* Register VM runtime error handler.
3578	*/
3579	vrc2 = pVMM->pfnVMR3AtRuntimeErrorRegister(pUVM, Console::i_atVMRuntimeErrorCallback, this);
3580	AssertRC(vrc2);
3581	if (RT_SUCCESS(vrc))
3582	vrc = vrc2;
3583
3584	pAlock->acquire();
3585
3586	LogFlowFunc(("vrc = %Rrc\n", vrc));
3587	LogFlowFuncLeave();
3588
3589	return vrc;
3590	}
3591
3592
3593	int Console::i_configGraphicsController(PCFGMNODE pDevices,
3594	const GraphicsControllerType_T enmGraphicsController,
3595	BusAssignmentManager *pBusMgr,
3596	const ComPtr<IMachine> &ptrMachine,
3597	const ComPtr<IGraphicsAdapter> &ptrGraphicsAdapter,
3598	const ComPtr<IBIOSSettings> &ptrBiosSettings,
3599	bool fHMEnabled)
3600	{
3601	// InsertConfig* throws
3602	try
3603	{
3604	PCFGMNODE pDev, pInst, pCfg, pLunL0;
3605	HRESULT hrc;
3606	Bstr bstr;
3607	const char *pcszDevice = "vga";
3608
3609	#define H() AssertLogRelMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR)
3610	InsertConfigNode(pDevices, pcszDevice, &pDev);
3611	InsertConfigNode(pDev, "0", &pInst);
3612	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
3613
3614	hrc = pBusMgr->assignPCIDevice(pcszDevice, pInst); H();
3615	InsertConfigNode(pInst, "Config", &pCfg);
3616	ULONG cVRamMBs;
3617	hrc = ptrGraphicsAdapter->COMGETTER(VRAMSize)(&cVRamMBs); H();
3618	InsertConfigInteger(pCfg, "VRamSize", cVRamMBs * _1M);
3619	ULONG cMonitorCount;
3620	hrc = ptrGraphicsAdapter->COMGETTER(MonitorCount)(&cMonitorCount); H();
3621	InsertConfigInteger(pCfg, "MonitorCount", cMonitorCount);
3622	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
3623	InsertConfigInteger(pCfg, "R0Enabled", fHMEnabled);
3624	#else
3625	NOREF(fHMEnabled);
3626	#endif
3627	BOOL f3DEnabled;
3628	hrc = ptrGraphicsAdapter->COMGETTER(Accelerate3DEnabled)(&f3DEnabled); H();
3629	InsertConfigInteger(pCfg, "3DEnabled", f3DEnabled);
3630
3631	i_attachStatusDriver(pInst, DeviceType_Graphics3D);
3632
3633	#ifdef VBOX_WITH_VMSVGA
3634	if ( enmGraphicsController == GraphicsControllerType_VMSVGA
3635	\|\| enmGraphicsController == GraphicsControllerType_VBoxSVGA)
3636	{
3637	InsertConfigInteger(pCfg, "VMSVGAEnabled", true);
3638	if (enmGraphicsController == GraphicsControllerType_VMSVGA)
3639	{
3640	InsertConfigInteger(pCfg, "VMSVGAPciBarLayout", true);
3641	InsertConfigInteger(pCfg, "VMSVGAPciId", true);
3642	}
3643	# ifdef VBOX_WITH_VMSVGA3D
3644	InsertConfigInteger(pCfg, "VMSVGA3dEnabled", f3DEnabled);
3645	# else
3646	LogRel(("VMSVGA3d not available in this build!\n"));
3647	# endif /* VBOX_WITH_VMSVGA3D */
3648	}
3649	#else
3650	RT_NOREF(enmGraphicsController);
3651	#endif /* VBOX_WITH_VMSVGA */
3652
3653	/* Custom VESA mode list */
3654	unsigned cModes = 0;
3655	for (unsigned iMode = 1; iMode <= 16; ++iMode)
3656	{
3657	char szExtraDataKey[sizeof("CustomVideoModeXX")];
3658	RTStrPrintf(szExtraDataKey, sizeof(szExtraDataKey), "CustomVideoMode%u", iMode);
3659	hrc = ptrMachine->GetExtraData(Bstr(szExtraDataKey).raw(), bstr.asOutParam()); H();
3660	if (bstr.isEmpty())
3661	break;
3662	InsertConfigString(pCfg, szExtraDataKey, bstr);
3663	++cModes;
3664	}
3665	InsertConfigInteger(pCfg, "CustomVideoModes", cModes);
3666
3667	/* VESA height reduction */
3668	ULONG ulHeightReduction;
3669	IFramebuffer *pFramebuffer = NULL;
3670	hrc = i_getDisplay()->QueryFramebuffer(0, &pFramebuffer);
3671	if (SUCCEEDED(hrc) && pFramebuffer)
3672	{
3673	hrc = pFramebuffer->COMGETTER(HeightReduction)(&ulHeightReduction); H();
3674	pFramebuffer->Release();
3675	pFramebuffer = NULL;
3676	}
3677	else
3678	{
3679	/* If framebuffer is not available, there is no height reduction. */
3680	ulHeightReduction = 0;
3681	}
3682	InsertConfigInteger(pCfg, "HeightReduction", ulHeightReduction);
3683
3684	/*
3685	* BIOS logo
3686	*/
3687	BOOL fFadeIn;
3688	hrc = ptrBiosSettings->COMGETTER(LogoFadeIn)(&fFadeIn); H();
3689	InsertConfigInteger(pCfg, "FadeIn", fFadeIn ? 1 : 0);
3690	BOOL fFadeOut;
3691	hrc = ptrBiosSettings->COMGETTER(LogoFadeOut)(&fFadeOut); H();
3692	InsertConfigInteger(pCfg, "FadeOut", fFadeOut ? 1: 0);
3693	ULONG logoDisplayTime;
3694	hrc = ptrBiosSettings->COMGETTER(LogoDisplayTime)(&logoDisplayTime); H();
3695	InsertConfigInteger(pCfg, "LogoTime", logoDisplayTime);
3696	Bstr bstrLogoImagePath;
3697	hrc = ptrBiosSettings->COMGETTER(LogoImagePath)(bstrLogoImagePath.asOutParam()); H();
3698	InsertConfigString(pCfg, "LogoFile", bstrLogoImagePath);
3699
3700	/*
3701	* Boot menu
3702	*/
3703	BIOSBootMenuMode_T eBootMenuMode;
3704	int iShowBootMenu;
3705	hrc = ptrBiosSettings->COMGETTER(BootMenuMode)(&eBootMenuMode); H();
3706	switch (eBootMenuMode)
3707	{
3708	case BIOSBootMenuMode_Disabled: iShowBootMenu = 0; break;
3709	case BIOSBootMenuMode_MenuOnly: iShowBootMenu = 1; break;
3710	default: iShowBootMenu = 2; break;
3711	}
3712	InsertConfigInteger(pCfg, "ShowBootMenu", iShowBootMenu);
3713
3714	/* Attach the display. */
3715	InsertConfigNode(pInst, "LUN#0", &pLunL0);
3716	InsertConfigString(pLunL0, "Driver", "MainDisplay");
3717	InsertConfigNode(pLunL0, "Config", &pCfg);
3718	}
3719	catch (ConfigError &x)
3720	{
3721	// InsertConfig threw something:
3722	return x.m_vrc;
3723	}
3724
3725	#undef H
3726
3727	return VINF_SUCCESS;
3728	}

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

source: vbox/trunk/src/VBox/Main/src-client/ConsoleImplConfigX86.cpp@ 100689

Download in other formats: