ConsoleImpl2.cpp@ 56616

Last change on this file since 56616 was 56512, checked in by vboxsync, 9 years ago
Main/AC97: Propagate codec model setting through CFGM.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 239.2 KB

Line
1	/* $Id: ConsoleImpl2.cpp 56512 2015-06-18 12:00:19Z 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-2015 Oracle Corporation
13	*
14	* This file is part of VirtualBox Open Source Edition (OSE), as
15	* available from http://www.virtualbox.org. This file is free software;
16	* you can redistribute it and/or modify it under the terms of the GNU
17	* General Public License (GPL) as published by the Free Software
18	* Foundation, in version 2 as it comes in the "COPYING" file of the
19	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
20	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
21	*/
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	/* For some reason Windows burns in sdk\...\winsock.h if this isn't included first. */
27	#include "VBox/com/ptr.h"
28
29	#include "ConsoleImpl.h"
30	#include "DisplayImpl.h"
31	#ifdef VBOX_WITH_GUEST_CONTROL
32	# include "GuestImpl.h"
33	#endif
34	#ifdef VBOX_WITH_DRAG_AND_DROP
35	# include "GuestDnDPrivate.h"
36	#endif
37	#include "VMMDev.h"
38	#include "Global.h"
39	#ifdef VBOX_WITH_PCI_PASSTHROUGH
40	# include "PCIRawDevImpl.h"
41	#endif
42
43	// generated header
44	#include "SchemaDefs.h"
45
46	#include "AutoCaller.h"
47	#include "Logging.h"
48
49	#include <iprt/base64.h>
50	#include <iprt/buildconfig.h>
51	#include <iprt/ctype.h>
52	#include <iprt/dir.h>
53	#include <iprt/file.h>
54	#include <iprt/param.h>
55	#include <iprt/path.h>
56	#include <iprt/string.h>
57	#include <iprt/system.h>
58	#include <iprt/cpp/exception.h>
59	#if 0 /* enable to play with lots of memory. */
60	# include <iprt/env.h>
61	#endif
62	#include <iprt/stream.h>
63
64	#include <VBox/vmm/vmapi.h>
65	#include <VBox/err.h>
66	#include <VBox/param.h>
67	#include <VBox/vmm/pdmapi.h> /* For PDMR3DriverAttach/PDMR3DriverDetach. */
68	#include <VBox/vmm/pdmusb.h> /* For PDMR3UsbCreateEmulatedDevice. */
69	#include <VBox/version.h>
70	#include <VBox/HostServices/VBoxClipboardSvc.h>
71	#ifdef VBOX_WITH_CROGL
72	# include <VBox/HostServices/VBoxCrOpenGLSvc.h>
73	#include <VBox/VBoxOGL.h>
74	#endif
75	#ifdef VBOX_WITH_GUEST_PROPS
76	# include <VBox/HostServices/GuestPropertySvc.h>
77	# include <VBox/com/defs.h>
78	# include <VBox/com/array.h>
79	# include "HGCM.h" /** @todo It should be possible to register a service
80	* extension using a VMMDev callback. */
81	# include <vector>
82	#endif /* VBOX_WITH_GUEST_PROPS */
83	#include <VBox/intnet.h>
84
85	#include <VBox/com/com.h>
86	#include <VBox/com/string.h>
87	#include <VBox/com/array.h>
88
89	#ifdef VBOX_WITH_NETFLT
90	# if defined(RT_OS_SOLARIS)
91	# include <zone.h>
92	# elif defined(RT_OS_LINUX)
93	# include <unistd.h>
94	# include <sys/ioctl.h>
95	# include <sys/socket.h>
96	# include <linux/types.h>
97	# include <linux/if.h>
98	# include <linux/wireless.h>
99	# elif defined(RT_OS_FREEBSD)
100	# include <unistd.h>
101	# include <sys/types.h>
102	# include <sys/ioctl.h>
103	# include <sys/socket.h>
104	# include <net/if.h>
105	# include <net80211/ieee80211_ioctl.h>
106	# endif
107	# if defined(RT_OS_WINDOWS)
108	# include <VBox/VBoxNetCfg-win.h>
109	# include <Ntddndis.h>
110	# include <devguid.h>
111	# else
112	# include <HostNetworkInterfaceImpl.h>
113	# include <netif.h>
114	# include <stdlib.h>
115	# endif
116	#endif /* VBOX_WITH_NETFLT */
117
118	#include "NetworkServiceRunner.h"
119	#include "BusAssignmentManager.h"
120	#ifdef VBOX_WITH_EXTPACK
121	# include "ExtPackManagerImpl.h"
122	#endif
123
124
125	/*******************************************************************************
126	* Internal Functions *
127	*******************************************************************************/
128	static Utf8Str GetExtraDataBoth(IVirtualBox pVirtualBox, IMachine pMachine, const char pszName, Utf8Str *pStrValue);
129
130
131	/* Darwin compile kludge */
132	#undef PVM
133
134	/* Comment out the following line to remove VMWare compatibility hack. */
135	#define VMWARE_NET_IN_SLOT_11
136
137	/**
138	* Translate IDE StorageControllerType_T to string representation.
139	*/
140	const char* controllerString(StorageControllerType_T enmType)
141	{
142	switch (enmType)
143	{
144	case StorageControllerType_PIIX3:
145	return "PIIX3";
146	case StorageControllerType_PIIX4:
147	return "PIIX4";
148	case StorageControllerType_ICH6:
149	return "ICH6";
150	default:
151	return "Unknown";
152	}
153	}
154
155	/**
156	* Simple class for storing network boot information.
157	*/
158	struct BootNic
159	{
160	ULONG mInstance;
161	PCIBusAddress mPCIAddress;
162
163	ULONG mBootPrio;
164	bool operator < (const BootNic &rhs) const
165	{
166	ULONG lval = mBootPrio - 1; /* 0 will wrap around and get the lowest priority. */
167	ULONG rval = rhs.mBootPrio - 1;
168	return lval < rval; /* Zero compares as highest number (lowest prio). */
169	}
170	};
171
172	static int findEfiRom(IVirtualBox* vbox, FirmwareType_T aFirmwareType, Utf8Str *pEfiRomFile)
173	{
174	Bstr aFilePath, empty;
175	BOOL fPresent = FALSE;
176	HRESULT hrc = vbox->CheckFirmwarePresent(aFirmwareType, empty.raw(),
177	empty.asOutParam(), aFilePath.asOutParam(), &fPresent);
178	AssertComRCReturn(hrc, Global::vboxStatusCodeFromCOM(hrc));
179
180	if (!fPresent)
181	{
182	LogRel(("Failed to find an EFI ROM file.\n"));
183	return VERR_FILE_NOT_FOUND;
184	}
185
186	*pEfiRomFile = Utf8Str(aFilePath);
187
188	return VINF_SUCCESS;
189	}
190
191	/**
192	* @throws HRESULT on extra data retrival error.
193	*/
194	static int getSmcDeviceKey(IVirtualBox pVirtualBox, IMachine pMachine, Utf8Str pStrKey, bool pfGetKeyFromRealSMC)
195	{
196	*pfGetKeyFromRealSMC = false;
197
198	/*
199	* The extra data takes precedence (if non-zero).
200	*/
201	GetExtraDataBoth(pVirtualBox, pMachine, "VBoxInternal2/SmcDeviceKey", pStrKey);
202	if (pStrKey->isNotEmpty())
203	return VINF_SUCCESS;
204
205	#ifdef RT_OS_DARWIN
206
207	/*
208	* Work done in EFI/DevSmc
209	*/
210	*pfGetKeyFromRealSMC = true;
211	int rc = VINF_SUCCESS;
212
213	#else
214	/*
215	* Is it apple hardware in bootcamp?
216	*/
217	/** @todo implement + test RTSYSDMISTR_MANUFACTURER on all hosts.
218	* Currently falling back on the product name. */
219	char szManufacturer[256];
220	szManufacturer[0] = '\0';
221	RTSystemQueryDmiString(RTSYSDMISTR_MANUFACTURER, szManufacturer, sizeof(szManufacturer));
222	if (szManufacturer[0] != '\0')
223	{
224	if ( !strcmp(szManufacturer, "Apple Computer, Inc.")
225	\|\| !strcmp(szManufacturer, "Apple Inc.")
226	)
227	*pfGetKeyFromRealSMC = true;
228	}
229	else
230	{
231	char szProdName[256];
232	szProdName[0] = '\0';
233	RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_NAME, szProdName, sizeof(szProdName));
234	if ( ( !strncmp(szProdName, RT_STR_TUPLE("Mac"))
235	\|\| !strncmp(szProdName, RT_STR_TUPLE("iMac"))
236	\|\| !strncmp(szProdName, RT_STR_TUPLE("iMac"))
237	\|\| !strncmp(szProdName, RT_STR_TUPLE("Xserve"))
238	)
239	&& !strchr(szProdName, ' ') /* no spaces */
240	&& RT_C_IS_DIGIT(szProdName[strlen(szProdName) - 1]) /* version number */
241	)
242	*pfGetKeyFromRealSMC = true;
243	}
244
245	int rc = VINF_SUCCESS;
246	#endif
247
248	return rc;
249	}
250
251
252	/*
253	* VC++ 8 / amd64 has some serious trouble with the next functions.
254	* As a temporary measure, we'll drop global optimizations.
255	*/
256	#if defined(_MSC_VER) && defined(RT_ARCH_AMD64)
257	# pragma optimize("g", off)
258	#endif
259
260	static const char *const g_apszIDEDrives[4] =
261	{ "PrimaryMaster", "PrimarySlave", "SecondaryMaster", "SecondarySlave" };
262
263	class ConfigError : public RTCError
264	{
265	public:
266
267	ConfigError(const char *pcszFunction,
268	int vrc,
269	const char *pcszName)
270	: RTCError(Utf8StrFmt("%s failed: rc=%Rrc, pcszName=%s", pcszFunction, vrc, pcszName)),
271	m_vrc(vrc)
272	{
273	AssertMsgFailed(("%s\n", what())); // in strict mode, hit a breakpoint here
274	}
275
276	int m_vrc;
277	};
278
279
280	/**
281	* Helper that calls CFGMR3InsertString and throws an RTCError if that
282	* fails (C-string variant).
283	* @param pParent See CFGMR3InsertStringN.
284	* @param pcszNodeName See CFGMR3InsertStringN.
285	* @param pcszValue The string value.
286	*/
287	static void InsertConfigString(PCFGMNODE pNode,
288	const char *pcszName,
289	const char *pcszValue)
290	{
291	int vrc = CFGMR3InsertString(pNode,
292	pcszName,
293	pcszValue);
294	if (RT_FAILURE(vrc))
295	throw ConfigError("CFGMR3InsertString", vrc, pcszName);
296	}
297
298	/**
299	* Helper that calls CFGMR3InsertString and throws an RTCError if that
300	* fails (Utf8Str variant).
301	* @param pParent See CFGMR3InsertStringN.
302	* @param pcszNodeName See CFGMR3InsertStringN.
303	* @param rStrValue The string value.
304	*/
305	static void InsertConfigString(PCFGMNODE pNode,
306	const char *pcszName,
307	const Utf8Str &rStrValue)
308	{
309	int vrc = CFGMR3InsertStringN(pNode,
310	pcszName,
311	rStrValue.c_str(),
312	rStrValue.length());
313	if (RT_FAILURE(vrc))
314	throw ConfigError("CFGMR3InsertStringLengthKnown", vrc, pcszName);
315	}
316
317	/**
318	* Helper that calls CFGMR3InsertString and throws an RTCError if that
319	* fails (Bstr variant).
320	*
321	* @param pParent See CFGMR3InsertStringN.
322	* @param pcszNodeName See CFGMR3InsertStringN.
323	* @param rBstrValue The string value.
324	*/
325	static void InsertConfigString(PCFGMNODE pNode,
326	const char *pcszName,
327	const Bstr &rBstrValue)
328	{
329	InsertConfigString(pNode, pcszName, Utf8Str(rBstrValue));
330	}
331
332	/**
333	* Helper that calls CFGMR3InsertBytes and throws an RTCError if that fails.
334	*
335	* @param pNode See CFGMR3InsertBytes.
336	* @param pcszName See CFGMR3InsertBytes.
337	* @param pvBytes See CFGMR3InsertBytes.
338	* @param cbBytes See CFGMR3InsertBytes.
339	*/
340	static void InsertConfigBytes(PCFGMNODE pNode,
341	const char *pcszName,
342	const void *pvBytes,
343	size_t cbBytes)
344	{
345	int vrc = CFGMR3InsertBytes(pNode,
346	pcszName,
347	pvBytes,
348	cbBytes);
349	if (RT_FAILURE(vrc))
350	throw ConfigError("CFGMR3InsertBytes", vrc, pcszName);
351	}
352
353	/**
354	* Helper that calls CFGMR3InsertInteger and throws an RTCError if that
355	* fails.
356	*
357	* @param pNode See CFGMR3InsertInteger.
358	* @param pcszName See CFGMR3InsertInteger.
359	* @param u64Integer See CFGMR3InsertInteger.
360	*/
361	static void InsertConfigInteger(PCFGMNODE pNode,
362	const char *pcszName,
363	uint64_t u64Integer)
364	{
365	int vrc = CFGMR3InsertInteger(pNode,
366	pcszName,
367	u64Integer);
368	if (RT_FAILURE(vrc))
369	throw ConfigError("CFGMR3InsertInteger", vrc, pcszName);
370	}
371
372	/**
373	* Helper that calls CFGMR3InsertNode and throws an RTCError if that fails.
374	*
375	* @param pNode See CFGMR3InsertNode.
376	* @param pcszName See CFGMR3InsertNode.
377	* @param ppChild See CFGMR3InsertNode.
378	*/
379	static void InsertConfigNode(PCFGMNODE pNode,
380	const char *pcszName,
381	PCFGMNODE *ppChild)
382	{
383	int vrc = CFGMR3InsertNode(pNode, pcszName, ppChild);
384	if (RT_FAILURE(vrc))
385	throw ConfigError("CFGMR3InsertNode", vrc, pcszName);
386	}
387
388	/**
389	* Helper that calls CFGMR3RemoveValue and throws an RTCError if that fails.
390	*
391	* @param pNode See CFGMR3RemoveValue.
392	* @param pcszName See CFGMR3RemoveValue.
393	*/
394	static void RemoveConfigValue(PCFGMNODE pNode,
395	const char *pcszName)
396	{
397	int vrc = CFGMR3RemoveValue(pNode, pcszName);
398	if (RT_FAILURE(vrc))
399	throw ConfigError("CFGMR3RemoveValue", vrc, pcszName);
400	}
401
402	/**
403	* Gets an extra data value, consulting both machine and global extra data.
404	*
405	* @throws HRESULT on failure
406	* @returns pStrValue for the callers convenience.
407	* @param pVirtualBox Pointer to the IVirtualBox interface.
408	* @param pMachine Pointer to the IMachine interface.
409	* @param pszName The value to get.
410	* @param pStrValue Where to return it's value (empty string if not
411	* found).
412	*/
413	static Utf8Str GetExtraDataBoth(IVirtualBox pVirtualBox, IMachine pMachine, const char pszName, Utf8Str *pStrValue)
414	{
415	pStrValue->setNull();
416
417	Bstr bstrName(pszName);
418	Bstr bstrValue;
419	HRESULT hrc = pMachine->GetExtraData(bstrName.raw(), bstrValue.asOutParam());
420	if (FAILED(hrc))
421	throw hrc;
422	if (bstrValue.isEmpty())
423	{
424	hrc = pVirtualBox->GetExtraData(bstrName.raw(), bstrValue.asOutParam());
425	if (FAILED(hrc))
426	throw hrc;
427	}
428
429	if (bstrValue.isNotEmpty())
430	*pStrValue = bstrValue;
431	return pStrValue;
432	}
433
434
435	/** Helper that finds out the next HBA port used
436	*/
437	static LONG GetNextUsedPort(LONG aPortUsed[30], LONG lBaseVal, uint32_t u32Size)
438	{
439	LONG lNextPortUsed = 30;
440	for (size_t j = 0; j < u32Size; ++j)
441	{
442	if ( aPortUsed[j] > lBaseVal
443	&& aPortUsed[j] <= lNextPortUsed)
444	lNextPortUsed = aPortUsed[j];
445	}
446	return lNextPortUsed;
447	}
448
449	#define MAX_BIOS_LUN_COUNT 4
450
451	static int SetBiosDiskInfo(ComPtr<IMachine> pMachine, PCFGMNODE pCfg, PCFGMNODE pBiosCfg,
452	Bstr controllerName, const char * const s_apszBiosConfig[4])
453	{
454	HRESULT hrc;
455	#define MAX_DEVICES 30
456	#define H() AssertLogRelMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR)
457
458	LONG lPortLUN[MAX_BIOS_LUN_COUNT];
459	LONG lPortUsed[MAX_DEVICES];
460	uint32_t u32HDCount = 0;
461
462	/* init to max value */
463	lPortLUN[0] = MAX_DEVICES;
464
465	com::SafeIfaceArray<IMediumAttachment> atts;
466	hrc = pMachine->GetMediumAttachmentsOfController(controllerName.raw(),
467	ComSafeArrayAsOutParam(atts)); H();
468	size_t uNumAttachments = atts.size();
469	if (uNumAttachments > MAX_DEVICES)
470	{
471	LogRel(("Number of Attachments > Max=%d.\n", uNumAttachments));
472	uNumAttachments = MAX_DEVICES;
473	}
474
475	/* Find the relevant ports/IDs, i.e the ones to which a HD is attached. */
476	for (size_t j = 0; j < uNumAttachments; ++j)
477	{
478	IMediumAttachment *pMediumAtt = atts[j];
479	LONG lPortNum = 0;
480	hrc = pMediumAtt->COMGETTER(Port)(&lPortNum); H();
481	if (SUCCEEDED(hrc))
482	{
483	DeviceType_T lType;
484	hrc = pMediumAtt->COMGETTER(Type)(&lType); H();
485	if (SUCCEEDED(hrc) && lType == DeviceType_HardDisk)
486	{
487	/* find min port number used for HD */
488	if (lPortNum < lPortLUN[0])
489	lPortLUN[0] = lPortNum;
490	lPortUsed[u32HDCount++] = lPortNum;
491	LogFlowFunc(("HD port Count=%d\n", u32HDCount));
492	}
493
494	/* Configure the hotpluggable flag for the port. */
495	BOOL fHotPluggable = FALSE;
496	hrc = pMediumAtt->COMGETTER(HotPluggable)(&fHotPluggable); H();
497	if (SUCCEEDED(hrc))
498	{
499	PCFGMNODE pPortCfg;
500	char szName[24];
501	RTStrPrintf(szName, sizeof(szName), "Port%d", lPortNum);
502
503	InsertConfigNode(pCfg, szName, &pPortCfg);
504	InsertConfigInteger(pPortCfg, "Hotpluggable", fHotPluggable ? 1 : 0);
505	}
506	}
507	}
508
509
510	/* Pick only the top 4 used HD Ports as CMOS doesn't have space
511	* to save details for all 30 ports
512	*/
513	uint32_t u32MaxPortCount = MAX_BIOS_LUN_COUNT;
514	if (u32HDCount < MAX_BIOS_LUN_COUNT)
515	u32MaxPortCount = u32HDCount;
516	for (size_t j = 1; j < u32MaxPortCount; j++)
517	lPortLUN[j] = GetNextUsedPort(lPortUsed,
518	lPortLUN[j-1],
519	u32HDCount);
520	if (pBiosCfg)
521	{
522	for (size_t j = 0; j < u32MaxPortCount; j++)
523	{
524	InsertConfigInteger(pBiosCfg, s_apszBiosConfig[j], lPortLUN[j]);
525	LogFlowFunc(("Top %d HBA ports = %s, %d\n", j, s_apszBiosConfig[j], lPortLUN[j]));
526	}
527	}
528	return VINF_SUCCESS;
529	}
530
531	#ifdef VBOX_WITH_PCI_PASSTHROUGH
532	HRESULT Console::i_attachRawPCIDevices(PUVM pUVM, BusAssignmentManager *pBusMgr, PCFGMNODE pDevices)
533	{
534	HRESULT hrc = S_OK;
535	PCFGMNODE pInst, pCfg, pLunL0, pLunL1;
536
537	SafeIfaceArray<IPCIDeviceAttachment> assignments;
538	ComPtr<IMachine> aMachine = i_machine();
539
540	hrc = aMachine->COMGETTER(PCIDeviceAssignments)(ComSafeArrayAsOutParam(assignments));
541	if ( hrc != S_OK
542	\|\| assignments.size() < 1)
543	return hrc;
544
545	/*
546	* PCI passthrough is only available if the proper ExtPack is installed.
547	*
548	* Note. Configuring PCI passthrough here and providing messages about
549	* the missing extpack isn't exactly clean, but it is a necessary evil
550	* to patch over legacy compatability issues introduced by the new
551	* distribution model.
552	*/
553	# ifdef VBOX_WITH_EXTPACK
554	static const char *s_pszPCIRawExtPackName = "Oracle VM VirtualBox Extension Pack";
555	if (!mptrExtPackManager->i_isExtPackUsable(s_pszPCIRawExtPackName))
556	/* Always fatal! */
557	return VMR3SetError(pUVM, VERR_NOT_FOUND, RT_SRC_POS,
558	N_("Implementation of the PCI passthrough framework not found!\n"
559	"The VM cannot be started. To fix this problem, either "
560	"install the '%s' or disable PCI passthrough via VBoxManage"),
561	s_pszPCIRawExtPackName);
562	# endif
563
564	PCFGMNODE pBridges = CFGMR3GetChild(pDevices, "ich9pcibridge");
565	Assert(pBridges);
566
567	/* Find required bridges, and add missing ones */
568	for (size_t iDev = 0; iDev < assignments.size(); iDev++)
569	{
570	ComPtr<IPCIDeviceAttachment> assignment = assignments[iDev];
571	LONG guest = 0;
572	PCIBusAddress GuestPCIAddress;
573
574	assignment->COMGETTER(GuestAddress)(&guest);
575	GuestPCIAddress.fromLong(guest);
576	Assert(GuestPCIAddress.valid());
577
578	if (GuestPCIAddress.miBus > 0)
579	{
580	int iBridgesMissed = 0;
581	int iBase = GuestPCIAddress.miBus - 1;
582
583	while (!pBusMgr->hasPCIDevice("ich9pcibridge", iBase) && iBase > 0)
584	{
585	iBridgesMissed++; iBase--;
586	}
587	iBase++;
588
589	for (int iBridge = 0; iBridge < iBridgesMissed; iBridge++)
590	{
591	InsertConfigNode(pBridges, Utf8StrFmt("%d", iBase + iBridge).c_str(), &pInst);
592	InsertConfigInteger(pInst, "Trusted", 1);
593	hrc = pBusMgr->assignPCIDevice("ich9pcibridge", pInst);
594	}
595	}
596	}
597
598	/* Now actually add devices */
599	PCFGMNODE pPCIDevs = NULL;
600
601	if (assignments.size() > 0)
602	{
603	InsertConfigNode(pDevices, "pciraw", &pPCIDevs);
604
605	PCFGMNODE pRoot = CFGMR3GetParent(pDevices); Assert(pRoot);
606
607	/* Tell PGM to tell GPCIRaw about guest mappings. */
608	CFGMR3InsertNode(pRoot, "PGM", NULL);
609	InsertConfigInteger(CFGMR3GetChild(pRoot, "PGM"), "PciPassThrough", 1);
610
611	/*
612	* Currently, using IOMMU needed for PCI passthrough
613	* requires RAM preallocation.
614	*/
615	/** @todo: check if we can lift this requirement */
616	CFGMR3RemoveValue(pRoot, "RamPreAlloc");
617	InsertConfigInteger(pRoot, "RamPreAlloc", 1);
618	}
619
620	for (size_t iDev = 0; iDev < assignments.size(); iDev++)
621	{
622	PCIBusAddress HostPCIAddress, GuestPCIAddress;
623	ComPtr<IPCIDeviceAttachment> assignment = assignments[iDev];
624	LONG host, guest;
625	Bstr aDevName;
626
627	assignment->COMGETTER(HostAddress)(&host);
628	assignment->COMGETTER(GuestAddress)(&guest);
629	assignment->COMGETTER(Name)(aDevName.asOutParam());
630
631	InsertConfigNode(pPCIDevs, Utf8StrFmt("%d", iDev).c_str(), &pInst);
632	InsertConfigInteger(pInst, "Trusted", 1);
633
634	HostPCIAddress.fromLong(host);
635	Assert(HostPCIAddress.valid());
636	InsertConfigNode(pInst, "Config", &pCfg);
637	InsertConfigString(pCfg, "DeviceName", aDevName);
638
639	InsertConfigInteger(pCfg, "DetachHostDriver", 1);
640	InsertConfigInteger(pCfg, "HostPCIBusNo", HostPCIAddress.miBus);
641	InsertConfigInteger(pCfg, "HostPCIDeviceNo", HostPCIAddress.miDevice);
642	InsertConfigInteger(pCfg, "HostPCIFunctionNo", HostPCIAddress.miFn);
643
644	GuestPCIAddress.fromLong(guest);
645	Assert(GuestPCIAddress.valid());
646	hrc = pBusMgr->assignHostPCIDevice("pciraw", pInst, HostPCIAddress, GuestPCIAddress, true);
647	if (hrc != S_OK)
648	return hrc;
649
650	InsertConfigInteger(pCfg, "GuestPCIBusNo", GuestPCIAddress.miBus);
651	InsertConfigInteger(pCfg, "GuestPCIDeviceNo", GuestPCIAddress.miDevice);
652	InsertConfigInteger(pCfg, "GuestPCIFunctionNo", GuestPCIAddress.miFn);
653
654	/* the driver */
655	InsertConfigNode(pInst, "LUN#0", &pLunL0);
656	InsertConfigString(pLunL0, "Driver", "pciraw");
657	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
658
659	/* the Main driver */
660	InsertConfigString(pLunL1, "Driver", "MainPciRaw");
661	InsertConfigNode(pLunL1, "Config", &pCfg);
662	PCIRawDev* pMainDev = new PCIRawDev(this);
663	InsertConfigInteger(pCfg, "Object", (uintptr_t)pMainDev);
664	}
665
666	return hrc;
667	}
668	#endif
669
670
671	void Console::i_attachStatusDriver(PCFGMNODE pCtlInst, PPDMLED *papLeds,
672	uint64_t uFirst, uint64_t uLast,
673	Console::MediumAttachmentMap *pmapMediumAttachments,
674	const char *pcszDevice, unsigned uInstance)
675	{
676	PCFGMNODE pLunL0, pCfg;
677	InsertConfigNode(pCtlInst, "LUN#999", &pLunL0);
678	InsertConfigString(pLunL0, "Driver", "MainStatus");
679	InsertConfigNode(pLunL0, "Config", &pCfg);
680	InsertConfigInteger(pCfg, "papLeds", (uintptr_t)papLeds);
681	if (pmapMediumAttachments)
682	{
683	InsertConfigInteger(pCfg, "pmapMediumAttachments", (uintptr_t)pmapMediumAttachments);
684	InsertConfigInteger(pCfg, "pConsole", (uintptr_t)this);
685	AssertPtr(pcszDevice);
686	Utf8Str deviceInstance = Utf8StrFmt("%s/%u", pcszDevice, uInstance);
687	InsertConfigString(pCfg, "DeviceInstance", deviceInstance.c_str());
688	}
689	InsertConfigInteger(pCfg, "First", uFirst);
690	InsertConfigInteger(pCfg, "Last", uLast);
691	}
692
693
694	/**
695	* Construct the VM configuration tree (CFGM).
696	*
697	* This is a callback for VMR3Create() call. It is called from CFGMR3Init()
698	* in the emulation thread (EMT). Any per thread COM/XPCOM initialization
699	* is done here.
700	*
701	* @param pUVM The user mode VM handle.
702	* @param pVM The cross context VM handle.
703	* @param pvConsole Pointer to the VMPowerUpTask object.
704	* @return VBox status code.
705	*
706	* @note Locks the Console object for writing.
707	*/
708	DECLCALLBACK(int) Console::i_configConstructor(PUVM pUVM, PVM pVM, void *pvConsole)
709	{
710	LogFlowFuncEnter();
711
712	AssertReturn(pvConsole, VERR_INVALID_POINTER);
713	ComObjPtr<Console> pConsole = static_cast<Console *>(pvConsole);
714
715	AutoCaller autoCaller(pConsole);
716	AssertComRCReturn(autoCaller.rc(), VERR_ACCESS_DENIED);
717
718	/* lock the console because we widely use internal fields and methods */
719	AutoWriteLock alock(pConsole COMMA_LOCKVAL_SRC_POS);
720
721	/*
722	* Set the VM handle and do the rest of the job in an worker method so we
723	* can easily reset the VM handle on failure.
724	*/
725	pConsole->mpUVM = pUVM;
726	VMR3RetainUVM(pUVM);
727	int vrc;
728	try
729	{
730	vrc = pConsole->i_configConstructorInner(pUVM, pVM, &alock);
731	}
732	catch (...)
733	{
734	vrc = VERR_UNEXPECTED_EXCEPTION;
735	}
736	if (RT_FAILURE(vrc))
737	{
738	pConsole->mpUVM = NULL;
739	VMR3ReleaseUVM(pUVM);
740	}
741
742	return vrc;
743	}
744
745
746	#ifdef RT_OS_WINDOWS
747	#include <psapi.h>
748
749	/**
750	* Report versions of installed drivers to release log.
751	*/
752	void Console::i_reportDriverVersions()
753	{
754	DWORD err;
755	HRESULT hrc;
756	LPVOID aDrivers[1024];
757	LPVOID *pDrivers = aDrivers;
758	UINT cNeeded = 0;
759	TCHAR szSystemRoot[MAX_PATH];
760	TCHAR *pszSystemRoot = szSystemRoot;
761	LPVOID pVerInfo = NULL;
762	DWORD cbVerInfo = 0;
763
764	do
765	{
766	cNeeded = GetWindowsDirectory(szSystemRoot, RT_ELEMENTS(szSystemRoot));
767	if (cNeeded == 0)
768	{
769	err = GetLastError();
770	hrc = HRESULT_FROM_WIN32(err);
771	AssertLogRelMsgFailed(("GetWindowsDirectory failed, hr=%Rhrc (0x%x) err=%u\n",
772	hrc, hrc, err));
773	break;
774	}
775	else if (cNeeded > RT_ELEMENTS(szSystemRoot))
776	{
777	/* The buffer is too small, allocate big one. */
778	pszSystemRoot = (TCHAR )RTMemTmpAlloc(cNeeded sizeof(_TCHAR));
779	if (!pszSystemRoot)
780	{
781	AssertLogRelMsgFailed(("RTMemTmpAlloc failed to allocate %d bytes\n", cNeeded));
782	break;
783	}
784	if (GetWindowsDirectory(pszSystemRoot, cNeeded) == 0)
785	{
786	err = GetLastError();
787	hrc = HRESULT_FROM_WIN32(err);
788	AssertLogRelMsgFailed(("GetWindowsDirectory failed, hr=%Rhrc (0x%x) err=%u\n",
789	hrc, hrc, err));
790	break;
791	}
792	}
793
794	DWORD cbNeeded = 0;
795	if (!EnumDeviceDrivers(aDrivers, sizeof(aDrivers), &cbNeeded) \|\| cbNeeded > sizeof(aDrivers))
796	{
797	pDrivers = (LPVOID *)RTMemTmpAlloc(cbNeeded);
798	if (!EnumDeviceDrivers(pDrivers, cbNeeded, &cbNeeded))
799	{
800	err = GetLastError();
801	hrc = HRESULT_FROM_WIN32(err);
802	AssertLogRelMsgFailed(("EnumDeviceDrivers failed, hr=%Rhrc (0x%x) err=%u\n",
803	hrc, hrc, err));
804	break;
805	}
806	}
807
808	LogRel(("Installed Drivers:\n"));
809
810	TCHAR szDriver[1024];
811	int cDrivers = cbNeeded / sizeof(pDrivers[0]);
812	for (int i = 0; i < cDrivers; i++)
813	{
814	if (GetDeviceDriverBaseName(pDrivers[i], szDriver, sizeof(szDriver) / sizeof(szDriver[0])))
815	{
816	if (_tcsnicmp(TEXT("vbox"), szDriver, 4))
817	continue;
818	}
819	else
820	continue;
821	if (GetDeviceDriverFileName(pDrivers[i], szDriver, sizeof(szDriver) / sizeof(szDriver[0])))
822	{
823	_TCHAR szTmpDrv[1024];
824	_TCHAR *pszDrv = szDriver;
825	if (!_tcsncmp(TEXT("\\SystemRoot"), szDriver, 11))
826	{
827	_tcscpy_s(szTmpDrv, pszSystemRoot);
828	_tcsncat_s(szTmpDrv, szDriver + 11, sizeof(szTmpDrv) / sizeof(szTmpDrv[0]) - _tclen(pszSystemRoot));
829	pszDrv = szTmpDrv;
830	}
831	else if (!_tcsncmp(TEXT("\\??\\"), szDriver, 4))
832	pszDrv = szDriver + 4;
833
834	/* Allocate a buffer for version info. Reuse if large enough. */
835	DWORD cbNewVerInfo = GetFileVersionInfoSize(pszDrv, NULL);
836	if (cbNewVerInfo > cbVerInfo)
837	{
838	if (pVerInfo)
839	RTMemTmpFree(pVerInfo);
840	cbVerInfo = cbNewVerInfo;
841	pVerInfo = RTMemTmpAlloc(cbVerInfo);
842	if (!pVerInfo)
843	{
844	AssertLogRelMsgFailed(("RTMemTmpAlloc failed to allocate %d bytes\n", cbVerInfo));
845	break;
846	}
847	}
848
849	if (GetFileVersionInfo(pszDrv, NULL, cbVerInfo, pVerInfo))
850	{
851	UINT cbSize = 0;
852	LPBYTE lpBuffer = NULL;
853	if (VerQueryValue(pVerInfo, TEXT("\\"), (VOID FAR* FAR*)&lpBuffer, &cbSize))
854	{
855	if (cbSize)
856	{
857	VS_FIXEDFILEINFO pFileInfo = (VS_FIXEDFILEINFO )lpBuffer;
858	if (pFileInfo->dwSignature == 0xfeef04bd)
859	{
860	LogRel((" %ls (Version: %d.%d.%d.%d)\n", pszDrv,
861	(pFileInfo->dwFileVersionMS >> 16) & 0xffff,
862	(pFileInfo->dwFileVersionMS >> 0) & 0xffff,
863	(pFileInfo->dwFileVersionLS >> 16) & 0xffff,
864	(pFileInfo->dwFileVersionLS >> 0) & 0xffff));
865	}
866	}
867	}
868	}
869	}
870	}
871
872	}
873	while (0);
874
875	if (pVerInfo)
876	RTMemTmpFree(pVerInfo);
877
878	if (pDrivers != aDrivers)
879	RTMemTmpFree(pDrivers);
880
881	if (pszSystemRoot != szSystemRoot)
882	RTMemTmpFree(pszSystemRoot);
883	}
884	#else /* !RT_OS_WINDOWS */
885	void Console::i_reportDriverVersions(void)
886	{
887	}
888	#endif /* !RT_OS_WINDOWS */
889
890
891	/**
892	* Worker for configConstructor.
893	*
894	* @return VBox status code.
895	* @param pUVM The user mode VM handle.
896	* @param pVM The cross context VM handle.
897	* @param pAlock The automatic lock instance. This is for when we have
898	* to leave it in order to avoid deadlocks (ext packs and
899	* more).
900	*/
901	int Console::i_configConstructorInner(PUVM pUVM, PVM pVM, AutoWriteLock *pAlock)
902	{
903	VMMDev *pVMMDev = m_pVMMDev; Assert(pVMMDev);
904	ComPtr<IMachine> pMachine = i_machine();
905
906	int rc;
907	HRESULT hrc;
908	Utf8Str strTmp;
909	Bstr bstr;
910
911	#define H() AssertLogRelMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR)
912
913	/*
914	* Get necessary objects and frequently used parameters.
915	*/
916	ComPtr<IVirtualBox> virtualBox;
917	hrc = pMachine->COMGETTER(Parent)(virtualBox.asOutParam()); H();
918
919	ComPtr<IHost> host;
920	hrc = virtualBox->COMGETTER(Host)(host.asOutParam()); H();
921
922	ComPtr<ISystemProperties> systemProperties;
923	hrc = virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam()); H();
924
925	ComPtr<IBIOSSettings> biosSettings;
926	hrc = pMachine->COMGETTER(BIOSSettings)(biosSettings.asOutParam()); H();
927
928	hrc = pMachine->COMGETTER(HardwareUUID)(bstr.asOutParam()); H();
929	RTUUID HardwareUuid;
930	rc = RTUuidFromUtf16(&HardwareUuid, bstr.raw());
931	AssertRCReturn(rc, rc);
932
933	ULONG cRamMBs;
934	hrc = pMachine->COMGETTER(MemorySize)(&cRamMBs); H();
935	#if 0 /* enable to play with lots of memory. */
936	if (RTEnvExist("VBOX_RAM_SIZE"))
937	cRamMBs = RTStrToUInt64(RTEnvGet("VBOX_RAM_SIZE"));
938	#endif
939	uint64_t const cbRam = cRamMBs * (uint64_t)_1M;
940	uint32_t cbRamHole = MM_RAM_HOLE_SIZE_DEFAULT;
941	uint64_t uMcfgBase = 0;
942	uint32_t cbMcfgLength = 0;
943
944	ParavirtProvider_T paravirtProvider;
945	hrc = pMachine->GetEffectiveParavirtProvider(&paravirtProvider); H();
946
947	ChipsetType_T chipsetType;
948	hrc = pMachine->COMGETTER(ChipsetType)(&chipsetType); H();
949	if (chipsetType == ChipsetType_ICH9)
950	{
951	/* We'd better have 0x10000000 region, to cover 256 buses
952	but this put too much load on hypervisor heap */
953	cbMcfgLength = 0x4000000; //0x10000000;
954	cbRamHole += cbMcfgLength;
955	uMcfgBase = _4G - cbRamHole;
956	}
957
958	BusAssignmentManager *pBusMgr = mBusMgr = BusAssignmentManager::createInstance(chipsetType);
959
960	ULONG cCpus = 1;
961	hrc = pMachine->COMGETTER(CPUCount)(&cCpus); H();
962
963	ULONG ulCpuExecutionCap = 100;
964	hrc = pMachine->COMGETTER(CPUExecutionCap)(&ulCpuExecutionCap); H();
965
966	Bstr osTypeId;
967	hrc = pMachine->COMGETTER(OSTypeId)(osTypeId.asOutParam()); H();
968	LogRel(("Guest OS type: '%s'\n", Utf8Str(osTypeId).c_str()));
969
970	BOOL fIOAPIC;
971	hrc = biosSettings->COMGETTER(IOAPICEnabled)(&fIOAPIC); H();
972
973	ComPtr<IGuestOSType> guestOSType;
974	hrc = virtualBox->GetGuestOSType(osTypeId.raw(), guestOSType.asOutParam()); H();
975
976	Bstr guestTypeFamilyId;
977	hrc = guestOSType->COMGETTER(FamilyId)(guestTypeFamilyId.asOutParam()); H();
978	BOOL fOsXGuest = guestTypeFamilyId == Bstr("MacOS");
979
980	ULONG maxNetworkAdapters;
981	hrc = systemProperties->GetMaxNetworkAdapters(chipsetType, &maxNetworkAdapters); H();
982
983	i_reportDriverVersions();
984	/*
985	* Get root node first.
986	* This is the only node in the tree.
987	*/
988	PCFGMNODE pRoot = CFGMR3GetRootU(pUVM);
989	Assert(pRoot);
990
991	// InsertConfigString throws
992	try
993	{
994
995	/*
996	* Set the root (and VMM) level values.
997	*/
998	hrc = pMachine->COMGETTER(Name)(bstr.asOutParam()); H();
999	InsertConfigString(pRoot, "Name", bstr);
1000	InsertConfigBytes(pRoot, "UUID", &HardwareUuid, sizeof(HardwareUuid));
1001	InsertConfigInteger(pRoot, "RamSize", cbRam);
1002	InsertConfigInteger(pRoot, "RamHoleSize", cbRamHole);
1003	InsertConfigInteger(pRoot, "NumCPUs", cCpus);
1004	InsertConfigInteger(pRoot, "CpuExecutionCap", ulCpuExecutionCap);
1005	InsertConfigInteger(pRoot, "TimerMillies", 10);
1006	#ifdef VBOX_WITH_RAW_MODE
1007	InsertConfigInteger(pRoot, "RawR3Enabled", 1); /* boolean */
1008	InsertConfigInteger(pRoot, "RawR0Enabled", 1); /* boolean */
1009	/** @todo Config: RawR0, PATMEnabled and CSAMEnabled needs attention later. */
1010	InsertConfigInteger(pRoot, "PATMEnabled", 1); /* boolean */
1011	InsertConfigInteger(pRoot, "CSAMEnabled", 1); /* boolean */
1012	#endif
1013
1014	#ifdef VBOX_WITH_RAW_RING1
1015	if (osTypeId == "QNX")
1016	{
1017	/* QNX needs special treatment in raw mode due to its use of ring-1. */
1018	InsertConfigInteger(pRoot, "RawR1Enabled", 1); /* boolean */
1019	}
1020	#endif
1021
1022	BOOL fPageFusion = FALSE;
1023	hrc = pMachine->COMGETTER(PageFusionEnabled)(&fPageFusion); H();
1024	InsertConfigInteger(pRoot, "PageFusionAllowed", fPageFusion); /* boolean */
1025
1026	/* Not necessary, but makes sure this setting ends up in the release log. */
1027	ULONG ulBalloonSize = 0;
1028	hrc = pMachine->COMGETTER(MemoryBalloonSize)(&ulBalloonSize); H();
1029	InsertConfigInteger(pRoot, "MemBalloonSize", ulBalloonSize);
1030
1031	/*
1032	* CPUM values.
1033	*/
1034	PCFGMNODE pCPUM;
1035	InsertConfigNode(pRoot, "CPUM", &pCPUM);
1036
1037	/* cpuid leaf overrides. */
1038	static uint32_t const s_auCpuIdRanges[] =
1039	{
1040	UINT32_C(0x00000000), UINT32_C(0x0000000a),
1041	UINT32_C(0x80000000), UINT32_C(0x8000000a)
1042	};
1043	for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
1044	for (uint32_t uLeaf = s_auCpuIdRanges[i]; uLeaf < s_auCpuIdRanges[i + 1]; uLeaf++)
1045	{
1046	ULONG ulEax, ulEbx, ulEcx, ulEdx;
1047	hrc = pMachine->GetCPUIDLeaf(uLeaf, &ulEax, &ulEbx, &ulEcx, &ulEdx);
1048	if (SUCCEEDED(hrc))
1049	{
1050	PCFGMNODE pLeaf;
1051	InsertConfigNode(pCPUM, Utf8StrFmt("HostCPUID/%RX32", uLeaf).c_str(), &pLeaf);
1052
1053	InsertConfigInteger(pLeaf, "eax", ulEax);
1054	InsertConfigInteger(pLeaf, "ebx", ulEbx);
1055	InsertConfigInteger(pLeaf, "ecx", ulEcx);
1056	InsertConfigInteger(pLeaf, "edx", ulEdx);
1057	}
1058	else if (hrc != E_INVALIDARG) H();
1059	}
1060
1061	/* We must limit CPUID count for Windows NT 4, as otherwise it stops
1062	with error 0x3e (MULTIPROCESSOR_CONFIGURATION_NOT_SUPPORTED). */
1063	if (osTypeId == "WindowsNT4")
1064	{
1065	LogRel(("Limiting CPUID leaf count for NT4 guests\n"));
1066	InsertConfigInteger(pCPUM, "NT4LeafLimit", true);
1067	}
1068
1069	/* Expose CMPXCHG16B. Currently a hack. */
1070	if ( osTypeId == "Windows81_64"
1071	\|\| osTypeId == "Windows2012_64"
1072	\|\| osTypeId == "Windows10_64")
1073	{
1074	LogRel(("Enabling CMPXCHG16B for Windows 8.1 / 2k12 or newer guests\n"));
1075	InsertConfigInteger(pCPUM, "CMPXCHG16B", true);
1076	}
1077
1078	if (fOsXGuest)
1079	{
1080	/* Expose extended MWAIT features to Mac OS X guests. */
1081	LogRel(("Using MWAIT extensions\n"));
1082	InsertConfigInteger(pCPUM, "MWaitExtensions", true);
1083
1084	/* Fake the CPU family/model so the guest works. This is partly
1085	because older mac releases really doesn't work on newer cpus,
1086	and partly because mac os x expects more from systems with newer
1087	cpus (MSRs, power features, whatever). */
1088	uint32_t uMaxIntelFamilyModelStep = UINT32_MAX;
1089	if ( osTypeId == "MacOS"
1090	\|\| osTypeId == "MacOS_64")
1091	uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 7); /* Penryn / X5482. */
1092	else if ( osTypeId == "MacOS106"
1093	\|\| osTypeId == "MacOS106_64")
1094	uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 7); /* Penryn / X5482 */
1095	else if ( osTypeId == "MacOS107"
1096	\|\| osTypeId == "MacOS107_64")
1097	uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 7); /* Penryn / X5482 / /* @todo figure out
1098	what is required here. */
1099	else if ( osTypeId == "MacOS108"
1100	\|\| osTypeId == "MacOS108_64")
1101	uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 7); /* Penryn / X5482 / /* @todo figure out
1102	what is required here. */
1103	else if ( osTypeId == "MacOS109"
1104	\|\| osTypeId == "MacOS109_64")
1105	uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 7); /* Penryn / X5482 / /* @todo figure
1106	out what is required here. */
1107	if (uMaxIntelFamilyModelStep != UINT32_MAX)
1108	InsertConfigInteger(pCPUM, "MaxIntelFamilyModelStep", uMaxIntelFamilyModelStep);
1109	}
1110
1111	/* CPU Portability level, */
1112	ULONG uCpuIdPortabilityLevel = 0;
1113	hrc = pMachine->COMGETTER(CPUIDPortabilityLevel)(&uCpuIdPortabilityLevel); H();
1114	InsertConfigInteger(pCPUM, "PortableCpuIdLevel", uCpuIdPortabilityLevel);
1115
1116	/* Physical Address Extension (PAE) */
1117	BOOL fEnablePAE = false;
1118	hrc = pMachine->GetCPUProperty(CPUPropertyType_PAE, &fEnablePAE); H();
1119	InsertConfigInteger(pRoot, "EnablePAE", fEnablePAE);
1120
1121	/*
1122	* Hardware virtualization extensions.
1123	*/
1124	BOOL fSupportsHwVirtEx;
1125	hrc = host->GetProcessorFeature(ProcessorFeature_HWVirtEx, &fSupportsHwVirtEx); H();
1126
1127	BOOL fIsGuest64Bit;
1128	hrc = pMachine->GetCPUProperty(CPUPropertyType_LongMode, &fIsGuest64Bit); H();
1129	if (fIsGuest64Bit)
1130	{
1131	BOOL fSupportsLongMode;
1132	hrc = host->GetProcessorFeature(ProcessorFeature_LongMode, &fSupportsLongMode); H();
1133	if (!fSupportsLongMode)
1134	{
1135	LogRel(("WARNING! 64-bit guest type selected but the host CPU does NOT support 64-bit.\n"));
1136	fIsGuest64Bit = FALSE;
1137	}
1138	if (!fSupportsHwVirtEx)
1139	{
1140	LogRel(("WARNING! 64-bit guest type selected but the host CPU does NOT support HW virtualization.\n"));
1141	fIsGuest64Bit = FALSE;
1142	}
1143	}
1144
1145	BOOL fHMEnabled;
1146	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_Enabled, &fHMEnabled); H();
1147	if (cCpus > 1 && !fHMEnabled)
1148	{
1149	LogRel(("Forced fHMEnabled to TRUE by SMP guest.\n"));
1150	fHMEnabled = TRUE;
1151	}
1152
1153	BOOL fHMForced;
1154	#ifdef VBOX_WITH_RAW_MODE
1155	/* - With more than 4GB PGM will use different RAMRANGE sizes for raw
1156	mode and hv mode to optimize lookup times.
1157	- With more than one virtual CPU, raw-mode isn't a fallback option.
1158	- With a 64-bit guest, raw-mode isn't a fallback option either. */
1159	fHMForced = fHMEnabled
1160	&& ( cbRam + cbRamHole > _4G
1161	\|\| cCpus > 1
1162	\|\| fIsGuest64Bit);
1163	# ifdef RT_OS_DARWIN
1164	fHMForced = fHMEnabled;
1165	# endif
1166	if (fHMForced)
1167	{
1168	if (cbRam + cbRamHole > _4G)
1169	LogRel(("fHMForced=true - Lots of RAM\n"));
1170	if (cCpus > 1)
1171	LogRel(("fHMForced=true - SMP\n"));
1172	if (fIsGuest64Bit)
1173	LogRel(("fHMForced=true - 64-bit guest\n"));
1174	# ifdef RT_OS_DARWIN
1175	LogRel(("fHMForced=true - Darwin host\n"));
1176	# endif
1177	}
1178	#else /* !VBOX_WITH_RAW_MODE */
1179	fHMEnabled = fHMForced = TRUE;
1180	LogRel(("fHMForced=true - No raw-mode support in this build!\n"));
1181	#endif /* !VBOX_WITH_RAW_MODE */
1182	if (!fHMForced) /* No need to query if already forced above. */
1183	{
1184	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_Force, &fHMForced); H();
1185	if (fHMForced)
1186	LogRel(("fHMForced=true - HWVirtExPropertyType_Force\n"));
1187	}
1188	InsertConfigInteger(pRoot, "HMEnabled", fHMEnabled);
1189
1190	/* /EM/xzy */
1191	PCFGMNODE pEM;
1192	InsertConfigNode(pRoot, "EM", &pEM);
1193
1194	/* Triple fault behavior. */
1195	BOOL fTripleFaultReset = false;
1196	hrc = pMachine->GetCPUProperty(CPUPropertyType_TripleFaultReset, &fTripleFaultReset); H();
1197	InsertConfigInteger(pEM, "TripleFaultReset", fTripleFaultReset);
1198
1199	/* /HM/xzy */
1200	PCFGMNODE pHM;
1201	InsertConfigNode(pRoot, "HM", &pHM);
1202	InsertConfigInteger(pHM, "HMForced", fHMForced);
1203	if (fHMEnabled)
1204	{
1205	/* Indicate whether 64-bit guests are supported or not. */
1206	InsertConfigInteger(pHM, "64bitEnabled", fIsGuest64Bit);
1207	#if ARCH_BITS == 32 /* The recompiler must use VBoxREM64 (32-bit host only). */
1208	PCFGMNODE pREM;
1209	InsertConfigNode(pRoot, "REM", &pREM);
1210	InsertConfigInteger(pREM, "64bitEnabled", 1);
1211	#endif
1212
1213	/** @todo Not exactly pretty to check strings; VBOXOSTYPE would be better,
1214	but that requires quite a bit of API change in Main. */
1215	if ( fIOAPIC
1216	&& ( osTypeId == "WindowsNT4"
1217	\|\| osTypeId == "Windows2000"
1218	\|\| osTypeId == "WindowsXP"
1219	\|\| osTypeId == "Windows2003"))
1220	{
1221	/* Only allow TPR patching for NT, Win2k, XP and Windows Server 2003. (32 bits mode)
1222	* We may want to consider adding more guest OSes (Solaris) later on.
1223	*/
1224	InsertConfigInteger(pHM, "TPRPatchingEnabled", 1);
1225	}
1226	}
1227
1228	/* HWVirtEx exclusive mode */
1229	BOOL fHMExclusive = true;
1230	hrc = systemProperties->COMGETTER(ExclusiveHwVirt)(&fHMExclusive); H();
1231	InsertConfigInteger(pHM, "Exclusive", fHMExclusive);
1232
1233	/* Nested paging (VT-x/AMD-V) */
1234	BOOL fEnableNestedPaging = false;
1235	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &fEnableNestedPaging); H();
1236	InsertConfigInteger(pHM, "EnableNestedPaging", fEnableNestedPaging);
1237
1238	/* Large pages; requires nested paging */
1239	BOOL fEnableLargePages = false;
1240	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &fEnableLargePages); H();
1241	InsertConfigInteger(pHM, "EnableLargePages", fEnableLargePages);
1242
1243	/* VPID (VT-x) */
1244	BOOL fEnableVPID = false;
1245	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_VPID, &fEnableVPID); H();
1246	InsertConfigInteger(pHM, "EnableVPID", fEnableVPID);
1247
1248	/* Unrestricted execution aka UX (VT-x) */
1249	BOOL fEnableUX = false;
1250	hrc = pMachine->GetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, &fEnableUX); H();
1251	InsertConfigInteger(pHM, "EnableUX", fEnableUX);
1252
1253	/* Reset overwrite. */
1254	if (i_isResetTurnedIntoPowerOff())
1255	InsertConfigInteger(pRoot, "PowerOffInsteadOfReset", 1);
1256
1257	/*
1258	* Paravirt. provider.
1259	*/
1260	PCFGMNODE pParavirtNode;
1261	InsertConfigNode(pRoot, "GIM", &pParavirtNode);
1262	const char *pcszParavirtProvider;
1263	bool fGimDeviceNeeded = true;
1264	switch (paravirtProvider)
1265	{
1266	case ParavirtProvider_None:
1267	pcszParavirtProvider = "None";
1268	fGimDeviceNeeded = false;
1269	break;
1270
1271	case ParavirtProvider_Minimal:
1272	pcszParavirtProvider = "Minimal";
1273	break;
1274
1275	case ParavirtProvider_HyperV:
1276	pcszParavirtProvider = "HyperV";
1277	break;
1278
1279	case ParavirtProvider_KVM:
1280	pcszParavirtProvider = "KVM";
1281	break;
1282
1283	default:
1284	AssertMsgFailed(("Invalid paravirtProvider=%d\n", paravirtProvider));
1285	return VMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS, N_("Invalid paravirt. provider '%d'"),
1286	paravirtProvider);
1287	}
1288	InsertConfigString(pParavirtNode, "Provider", pcszParavirtProvider);
1289
1290	/*
1291	* MM values.
1292	*/
1293	PCFGMNODE pMM;
1294	InsertConfigNode(pRoot, "MM", &pMM);
1295	InsertConfigInteger(pMM, "CanUseLargerHeap", chipsetType == ChipsetType_ICH9);
1296
1297	/*
1298	* PDM config.
1299	* Load drivers in VBoxC.[so\|dll]
1300	*/
1301	PCFGMNODE pPDM;
1302	PCFGMNODE pNode;
1303	PCFGMNODE pMod;
1304	InsertConfigNode(pRoot, "PDM", &pPDM);
1305	InsertConfigNode(pPDM, "Devices", &pNode);
1306	InsertConfigNode(pPDM, "Drivers", &pNode);
1307	InsertConfigNode(pNode, "VBoxC", &pMod);
1308	#ifdef VBOX_WITH_XPCOM
1309	// VBoxC is located in the components subdirectory
1310	char szPathVBoxC[RTPATH_MAX];
1311	rc = RTPathAppPrivateArch(szPathVBoxC, RTPATH_MAX - sizeof("/components/VBoxC")); AssertRC(rc);
1312	strcat(szPathVBoxC, "/components/VBoxC");
1313	InsertConfigString(pMod, "Path", szPathVBoxC);
1314	#else
1315	InsertConfigString(pMod, "Path", "VBoxC");
1316	#endif
1317
1318
1319	/*
1320	* Block cache settings.
1321	*/
1322	PCFGMNODE pPDMBlkCache;
1323	InsertConfigNode(pPDM, "BlkCache", &pPDMBlkCache);
1324
1325	/* I/O cache size */
1326	ULONG ioCacheSize = 5;
1327	hrc = pMachine->COMGETTER(IOCacheSize)(&ioCacheSize); H();
1328	InsertConfigInteger(pPDMBlkCache, "CacheSize", ioCacheSize * _1M);
1329
1330	/*
1331	* Bandwidth groups.
1332	*/
1333	PCFGMNODE pAc;
1334	PCFGMNODE pAcFile;
1335	PCFGMNODE pAcFileBwGroups;
1336	ComPtr<IBandwidthControl> bwCtrl;
1337	com::SafeIfaceArray<IBandwidthGroup> bwGroups;
1338
1339	hrc = pMachine->COMGETTER(BandwidthControl)(bwCtrl.asOutParam()); H();
1340
1341	hrc = bwCtrl->GetAllBandwidthGroups(ComSafeArrayAsOutParam(bwGroups)); H();
1342
1343	InsertConfigNode(pPDM, "AsyncCompletion", &pAc);
1344	InsertConfigNode(pAc, "File", &pAcFile);
1345	InsertConfigNode(pAcFile, "BwGroups", &pAcFileBwGroups);
1346	#ifdef VBOX_WITH_NETSHAPER
1347	PCFGMNODE pNetworkShaper;
1348	PCFGMNODE pNetworkBwGroups;
1349
1350	InsertConfigNode(pPDM, "NetworkShaper", &pNetworkShaper);
1351	InsertConfigNode(pNetworkShaper, "BwGroups", &pNetworkBwGroups);
1352	#endif /* VBOX_WITH_NETSHAPER */
1353
1354	for (size_t i = 0; i < bwGroups.size(); i++)
1355	{
1356	Bstr strName;
1357	LONG64 cMaxBytesPerSec;
1358	BandwidthGroupType_T enmType;
1359
1360	hrc = bwGroups[i]->COMGETTER(Name)(strName.asOutParam()); H();
1361	hrc = bwGroups[i]->COMGETTER(Type)(&enmType); H();
1362	hrc = bwGroups[i]->COMGETTER(MaxBytesPerSec)(&cMaxBytesPerSec); H();
1363
1364	if (strName.isEmpty())
1365	return VMR3SetError(pUVM, VERR_CFGM_NO_NODE, RT_SRC_POS,
1366	N_("No bandwidth group name specified"));
1367
1368	if (enmType == BandwidthGroupType_Disk)
1369	{
1370	PCFGMNODE pBwGroup;
1371	InsertConfigNode(pAcFileBwGroups, Utf8Str(strName).c_str(), &pBwGroup);
1372	InsertConfigInteger(pBwGroup, "Max", cMaxBytesPerSec);
1373	InsertConfigInteger(pBwGroup, "Start", cMaxBytesPerSec);
1374	InsertConfigInteger(pBwGroup, "Step", 0);
1375	}
1376	#ifdef VBOX_WITH_NETSHAPER
1377	else if (enmType == BandwidthGroupType_Network)
1378	{
1379	/* Network bandwidth groups. */
1380	PCFGMNODE pBwGroup;
1381	InsertConfigNode(pNetworkBwGroups, Utf8Str(strName).c_str(), &pBwGroup);
1382	InsertConfigInteger(pBwGroup, "Max", cMaxBytesPerSec);
1383	}
1384	#endif /* VBOX_WITH_NETSHAPER */
1385	}
1386
1387	/*
1388	* Devices
1389	*/
1390	PCFGMNODE pDevices = NULL; /* /Devices */
1391	PCFGMNODE pDev = NULL; /* /Devices/Dev/ */
1392	PCFGMNODE pInst = NULL; /* /Devices/Dev/0/ */
1393	PCFGMNODE pCfg = NULL; /* /Devices/Dev/.../Config/ */
1394	PCFGMNODE pLunL0 = NULL; /* /Devices/Dev/0/LUN#0/ */
1395	PCFGMNODE pLunL1 = NULL; /* /Devices/Dev/0/LUN#0/AttachedDriver/ */
1396	PCFGMNODE pLunL2 = NULL; /* /Devices/Dev/0/LUN#0/AttachedDriver/Config/ */
1397	PCFGMNODE pBiosCfg = NULL; /* /Devices/pcbios/0/Config/ */
1398	PCFGMNODE pNetBootCfg = NULL; /* /Devices/pcbios/0/Config/NetBoot/ */
1399
1400	InsertConfigNode(pRoot, "Devices", &pDevices);
1401
1402	/*
1403	* GIM Device
1404	*/
1405	if (fGimDeviceNeeded)
1406	{
1407	InsertConfigNode(pDevices, "GIMDev", &pDev);
1408	InsertConfigNode(pDev, "0", &pInst);
1409	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1410	//InsertConfigNode(pInst, "Config", &pCfg);
1411	}
1412
1413	/*
1414	* PC Arch.
1415	*/
1416	InsertConfigNode(pDevices, "pcarch", &pDev);
1417	InsertConfigNode(pDev, "0", &pInst);
1418	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1419	InsertConfigNode(pInst, "Config", &pCfg);
1420
1421	/*
1422	* The time offset
1423	*/
1424	LONG64 timeOffset;
1425	hrc = biosSettings->COMGETTER(TimeOffset)(&timeOffset); H();
1426	PCFGMNODE pTMNode;
1427	InsertConfigNode(pRoot, "TM", &pTMNode);
1428	InsertConfigInteger(pTMNode, "UTCOffset", timeOffset * 1000000);
1429
1430	/*
1431	* DMA
1432	*/
1433	InsertConfigNode(pDevices, "8237A", &pDev);
1434	InsertConfigNode(pDev, "0", &pInst);
1435	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1436
1437	/*
1438	* PCI buses.
1439	*/
1440	uint32_t uIocPCIAddress, uHbcPCIAddress;
1441	switch (chipsetType)
1442	{
1443	default:
1444	Assert(false);
1445	case ChipsetType_PIIX3:
1446	InsertConfigNode(pDevices, "pci", &pDev);
1447	uHbcPCIAddress = (0x0 << 16) \| 0;
1448	uIocPCIAddress = (0x1 << 16) \| 0; // ISA controller
1449	break;
1450	case ChipsetType_ICH9:
1451	InsertConfigNode(pDevices, "ich9pci", &pDev);
1452	uHbcPCIAddress = (0x1e << 16) \| 0;
1453	uIocPCIAddress = (0x1f << 16) \| 0; // LPC controller
1454	break;
1455	}
1456	InsertConfigNode(pDev, "0", &pInst);
1457	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1458	InsertConfigNode(pInst, "Config", &pCfg);
1459	InsertConfigInteger(pCfg, "IOAPIC", fIOAPIC);
1460	if (chipsetType == ChipsetType_ICH9)
1461	{
1462	/* Provide MCFG info */
1463	InsertConfigInteger(pCfg, "McfgBase", uMcfgBase);
1464	InsertConfigInteger(pCfg, "McfgLength", cbMcfgLength);
1465
1466
1467	/* And register 2 bridges */
1468	InsertConfigNode(pDevices, "ich9pcibridge", &pDev);
1469	InsertConfigNode(pDev, "0", &pInst);
1470	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1471	hrc = pBusMgr->assignPCIDevice("ich9pcibridge", pInst); H();
1472
1473	InsertConfigNode(pDev, "1", &pInst);
1474	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1475	hrc = pBusMgr->assignPCIDevice("ich9pcibridge", pInst); H();
1476
1477	#ifdef VBOX_WITH_PCI_PASSTHROUGH
1478	/* Add PCI passthrough devices */
1479	hrc = i_attachRawPCIDevices(pUVM, pBusMgr, pDevices); H();
1480	#endif
1481	}
1482
1483	/*
1484	* Enable the following devices: HPET, SMC and LPC on MacOS X guests or on ICH9 chipset
1485	*/
1486
1487	/*
1488	* High Precision Event Timer (HPET)
1489	*/
1490	BOOL fHPETEnabled;
1491	/* Other guests may wish to use HPET too, but MacOS X not functional without it */
1492	hrc = pMachine->COMGETTER(HPETEnabled)(&fHPETEnabled); H();
1493	/* so always enable HPET in extended profile */
1494	fHPETEnabled \|= fOsXGuest;
1495	/* HPET is always present on ICH9 */
1496	fHPETEnabled \|= (chipsetType == ChipsetType_ICH9);
1497	if (fHPETEnabled)
1498	{
1499	InsertConfigNode(pDevices, "hpet", &pDev);
1500	InsertConfigNode(pDev, "0", &pInst);
1501	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1502	InsertConfigNode(pInst, "Config", &pCfg);
1503	InsertConfigInteger(pCfg, "ICH9", (chipsetType == ChipsetType_ICH9) ? 1 : 0); /* boolean */
1504	}
1505
1506	/*
1507	* System Management Controller (SMC)
1508	*/
1509	BOOL fSmcEnabled;
1510	fSmcEnabled = fOsXGuest;
1511	if (fSmcEnabled)
1512	{
1513	InsertConfigNode(pDevices, "smc", &pDev);
1514	InsertConfigNode(pDev, "0", &pInst);
1515	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1516	InsertConfigNode(pInst, "Config", &pCfg);
1517
1518	bool fGetKeyFromRealSMC;
1519	Utf8Str strKey;
1520	rc = getSmcDeviceKey(virtualBox, pMachine, &strKey, &fGetKeyFromRealSMC);
1521	AssertRCReturn(rc, rc);
1522
1523	if (!fGetKeyFromRealSMC)
1524	InsertConfigString(pCfg, "DeviceKey", strKey);
1525	InsertConfigInteger(pCfg, "GetKeyFromRealSMC", fGetKeyFromRealSMC);
1526	}
1527
1528	/*
1529	* Low Pin Count (LPC) bus
1530	*/
1531	BOOL fLpcEnabled;
1532	/** @todo: implement appropriate getter */
1533	fLpcEnabled = fOsXGuest \|\| (chipsetType == ChipsetType_ICH9);
1534	if (fLpcEnabled)
1535	{
1536	InsertConfigNode(pDevices, "lpc", &pDev);
1537	InsertConfigNode(pDev, "0", &pInst);
1538	hrc = pBusMgr->assignPCIDevice("lpc", pInst); H();
1539	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1540	}
1541
1542	BOOL fShowRtc;
1543	fShowRtc = fOsXGuest \|\| (chipsetType == ChipsetType_ICH9);
1544
1545	/*
1546	* PS/2 keyboard & mouse.
1547	*/
1548	InsertConfigNode(pDevices, "pckbd", &pDev);
1549	InsertConfigNode(pDev, "0", &pInst);
1550	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1551	InsertConfigNode(pInst, "Config", &pCfg);
1552
1553	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1554	InsertConfigString(pLunL0, "Driver", "KeyboardQueue");
1555	InsertConfigNode(pLunL0, "Config", &pCfg);
1556	InsertConfigInteger(pCfg, "QueueSize", 64);
1557
1558	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
1559	InsertConfigString(pLunL1, "Driver", "MainKeyboard");
1560	InsertConfigNode(pLunL1, "Config", &pCfg);
1561	Keyboard *pKeyboard = mKeyboard;
1562	InsertConfigInteger(pCfg, "Object", (uintptr_t)pKeyboard);
1563
1564	Mouse *pMouse = mMouse;
1565	PointingHIDType_T aPointingHID;
1566	hrc = pMachine->COMGETTER(PointingHIDType)(&aPointingHID); H();
1567	InsertConfigNode(pInst, "LUN#1", &pLunL0);
1568	InsertConfigString(pLunL0, "Driver", "MouseQueue");
1569	InsertConfigNode(pLunL0, "Config", &pCfg);
1570	InsertConfigInteger(pCfg, "QueueSize", 128);
1571
1572	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
1573	InsertConfigString(pLunL1, "Driver", "MainMouse");
1574	InsertConfigNode(pLunL1, "Config", &pCfg);
1575	InsertConfigInteger(pCfg, "Object", (uintptr_t)pMouse);
1576
1577	/*
1578	* i8254 Programmable Interval Timer And Dummy Speaker
1579	*/
1580	InsertConfigNode(pDevices, "i8254", &pDev);
1581	InsertConfigNode(pDev, "0", &pInst);
1582	InsertConfigNode(pInst, "Config", &pCfg);
1583	#ifdef DEBUG
1584	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1585	#endif
1586
1587	/*
1588	* i8259 Programmable Interrupt Controller.
1589	*/
1590	InsertConfigNode(pDevices, "i8259", &pDev);
1591	InsertConfigNode(pDev, "0", &pInst);
1592	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1593	InsertConfigNode(pInst, "Config", &pCfg);
1594
1595	/*
1596	* Advanced Programmable Interrupt Controller.
1597	* SMP: Each CPU has a LAPIC, but we have a single device representing all LAPICs states,
1598	* thus only single insert
1599	*/
1600	InsertConfigNode(pDevices, "apic", &pDev);
1601	InsertConfigNode(pDev, "0", &pInst);
1602	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1603	InsertConfigNode(pInst, "Config", &pCfg);
1604	InsertConfigInteger(pCfg, "IOAPIC", fIOAPIC);
1605	InsertConfigInteger(pCfg, "NumCPUs", cCpus);
1606
1607	if (fIOAPIC)
1608	{
1609	/*
1610	* I/O Advanced Programmable Interrupt Controller.
1611	*/
1612	InsertConfigNode(pDevices, "ioapic", &pDev);
1613	InsertConfigNode(pDev, "0", &pInst);
1614	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1615	InsertConfigNode(pInst, "Config", &pCfg);
1616	InsertConfigInteger(pCfg, "NumCPUs", cCpus);
1617	}
1618
1619	/*
1620	* RTC MC146818.
1621	*/
1622	InsertConfigNode(pDevices, "mc146818", &pDev);
1623	InsertConfigNode(pDev, "0", &pInst);
1624	InsertConfigNode(pInst, "Config", &pCfg);
1625	BOOL fRTCUseUTC;
1626	hrc = pMachine->COMGETTER(RTCUseUTC)(&fRTCUseUTC); H();
1627	InsertConfigInteger(pCfg, "UseUTC", fRTCUseUTC ? 1 : 0);
1628
1629	/*
1630	* VGA.
1631	*/
1632	GraphicsControllerType_T enmGraphicsController;
1633	hrc = pMachine->COMGETTER(GraphicsControllerType)(&enmGraphicsController); H();
1634	switch (enmGraphicsController)
1635	{
1636	case GraphicsControllerType_Null:
1637	break;
1638	case GraphicsControllerType_VBoxVGA:
1639	#ifdef VBOX_WITH_VMSVGA
1640	case GraphicsControllerType_VMSVGA:
1641	#endif
1642	rc = i_configGraphicsController(pDevices, enmGraphicsController, pBusMgr, pMachine, biosSettings,
1643	RT_BOOL(fHMEnabled));
1644	if (FAILED(rc))
1645	return rc;
1646	break;
1647	default:
1648	AssertMsgFailed(("Invalid graphicsController=%d\n", enmGraphicsController));
1649	return VMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
1650	N_("Invalid graphics controller type '%d'"), enmGraphicsController);
1651	}
1652
1653	/*
1654	* Firmware.
1655	*/
1656	FirmwareType_T eFwType = FirmwareType_BIOS;
1657	hrc = pMachine->COMGETTER(FirmwareType)(&eFwType); H();
1658
1659	#ifdef VBOX_WITH_EFI
1660	BOOL fEfiEnabled = (eFwType >= FirmwareType_EFI) && (eFwType <= FirmwareType_EFIDUAL);
1661	#else
1662	BOOL fEfiEnabled = false;
1663	#endif
1664	if (!fEfiEnabled)
1665	{
1666	/*
1667	* PC Bios.
1668	*/
1669	InsertConfigNode(pDevices, "pcbios", &pDev);
1670	InsertConfigNode(pDev, "0", &pInst);
1671	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1672	InsertConfigNode(pInst, "Config", &pBiosCfg);
1673	InsertConfigInteger(pBiosCfg, "RamSize", cbRam);
1674	InsertConfigInteger(pBiosCfg, "RamHoleSize", cbRamHole);
1675	InsertConfigInteger(pBiosCfg, "NumCPUs", cCpus);
1676	InsertConfigString(pBiosCfg, "HardDiskDevice", "piix3ide");
1677	InsertConfigString(pBiosCfg, "FloppyDevice", "i82078");
1678	InsertConfigInteger(pBiosCfg, "IOAPIC", fIOAPIC);
1679	BOOL fPXEDebug;
1680	hrc = biosSettings->COMGETTER(PXEDebugEnabled)(&fPXEDebug); H();
1681	InsertConfigInteger(pBiosCfg, "PXEDebug", fPXEDebug);
1682	InsertConfigBytes(pBiosCfg, "UUID", &HardwareUuid,sizeof(HardwareUuid));
1683	InsertConfigNode(pBiosCfg, "NetBoot", &pNetBootCfg);
1684	InsertConfigInteger(pBiosCfg, "McfgBase", uMcfgBase);
1685	InsertConfigInteger(pBiosCfg, "McfgLength", cbMcfgLength);
1686
1687	DeviceType_T bootDevice;
1688	AssertMsgReturn(SchemaDefs::MaxBootPosition <= 9, ("Too many boot devices %d\n", SchemaDefs::MaxBootPosition),
1689	VERR_INVALID_PARAMETER);
1690
1691	for (ULONG pos = 1; pos <= SchemaDefs::MaxBootPosition; ++pos)
1692	{
1693	hrc = pMachine->GetBootOrder(pos, &bootDevice); H();
1694
1695	char szParamName[] = "BootDeviceX";
1696	szParamName[sizeof(szParamName) - 2] = ((char (pos - 1)) + '0');
1697
1698	const char *pszBootDevice;
1699	switch (bootDevice)
1700	{
1701	case DeviceType_Null:
1702	pszBootDevice = "NONE";
1703	break;
1704	case DeviceType_HardDisk:
1705	pszBootDevice = "IDE";
1706	break;
1707	case DeviceType_DVD:
1708	pszBootDevice = "DVD";
1709	break;
1710	case DeviceType_Floppy:
1711	pszBootDevice = "FLOPPY";
1712	break;
1713	case DeviceType_Network:
1714	pszBootDevice = "LAN";
1715	break;
1716	default:
1717	AssertMsgFailed(("Invalid bootDevice=%d\n", bootDevice));
1718	return VMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
1719	N_("Invalid boot device '%d'"), bootDevice);
1720	}
1721	InsertConfigString(pBiosCfg, szParamName, pszBootDevice);
1722	}
1723
1724	/** @todo @bugref{7145}: We might want to enable this by default for new VMs. For now,
1725	* this is required for Windows 2012 guests. */
1726	if (osTypeId == "Windows2012_64")
1727	InsertConfigInteger(pBiosCfg, "DmiExposeMemoryTable", 1); /* boolean */
1728	}
1729	else
1730	{
1731	/* Autodetect firmware type, basing on guest type */
1732	if (eFwType == FirmwareType_EFI)
1733	{
1734	eFwType = fIsGuest64Bit
1735	? (FirmwareType_T)FirmwareType_EFI64
1736	: (FirmwareType_T)FirmwareType_EFI32;
1737	}
1738	bool const f64BitEntry = eFwType == FirmwareType_EFI64;
1739
1740	Utf8Str efiRomFile;
1741	rc = findEfiRom(virtualBox, eFwType, &efiRomFile);
1742	AssertRCReturn(rc, rc);
1743
1744	/* Get boot args */
1745	Utf8Str bootArgs;
1746	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiBootArgs", &bootArgs);
1747
1748	/* Get device props */
1749	Utf8Str deviceProps;
1750	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiDeviceProps", &deviceProps);
1751
1752	/* Get GOP mode settings */
1753	uint32_t u32GopMode = UINT32_MAX;
1754	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiGopMode", &strTmp);
1755	if (!strTmp.isEmpty())
1756	u32GopMode = strTmp.toUInt32();
1757
1758	/* UGA mode settings */
1759	uint32_t u32UgaHorizontal = 0;
1760	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiUgaHorizontalResolution", &strTmp);
1761	if (!strTmp.isEmpty())
1762	u32UgaHorizontal = strTmp.toUInt32();
1763
1764	uint32_t u32UgaVertical = 0;
1765	GetExtraDataBoth(virtualBox, pMachine, "VBoxInternal2/EfiUgaVerticalResolution", &strTmp);
1766	if (!strTmp.isEmpty())
1767	u32UgaVertical = strTmp.toUInt32();
1768
1769	/*
1770	* EFI subtree.
1771	*/
1772	InsertConfigNode(pDevices, "efi", &pDev);
1773	InsertConfigNode(pDev, "0", &pInst);
1774	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1775	InsertConfigNode(pInst, "Config", &pCfg);
1776	InsertConfigInteger(pCfg, "RamSize", cbRam);
1777	InsertConfigInteger(pCfg, "RamHoleSize", cbRamHole);
1778	InsertConfigInteger(pCfg, "NumCPUs", cCpus);
1779	InsertConfigString(pCfg, "EfiRom", efiRomFile);
1780	InsertConfigString(pCfg, "BootArgs", bootArgs);
1781	InsertConfigString(pCfg, "DeviceProps", deviceProps);
1782	InsertConfigInteger(pCfg, "IOAPIC", fIOAPIC);
1783	InsertConfigBytes(pCfg, "UUID", &HardwareUuid,sizeof(HardwareUuid));
1784	InsertConfigInteger(pCfg, "64BitEntry", f64BitEntry); /* boolean */
1785	InsertConfigInteger(pCfg, "GopMode", u32GopMode);
1786	InsertConfigInteger(pCfg, "UgaHorizontalResolution", u32UgaHorizontal);
1787	InsertConfigInteger(pCfg, "UgaVerticalResolution", u32UgaVertical);
1788
1789	/* For OS X guests we'll force passing host's DMI info to the guest */
1790	if (fOsXGuest)
1791	{
1792	InsertConfigInteger(pCfg, "DmiUseHostInfo", 1);
1793	InsertConfigInteger(pCfg, "DmiExposeMemoryTable", 1);
1794	}
1795	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1796	InsertConfigString(pLunL0, "Driver", "NvramStorage");
1797	InsertConfigNode(pLunL0, "Config", &pCfg);
1798	InsertConfigInteger(pCfg, "Object", (uintptr_t)mNvram);
1799	#ifdef DEBUG_vvl
1800	InsertConfigInteger(pCfg, "PermanentSave", 1);
1801	#endif
1802	}
1803
1804	/*
1805	* The USB Controllers.
1806	*/
1807	com::SafeIfaceArray<IUSBController> usbCtrls;
1808	hrc = pMachine->COMGETTER(USBControllers)(ComSafeArrayAsOutParam(usbCtrls)); H();
1809	bool fOhciPresent = false; /*< Flag whether at least one OHCI controller is present. /
1810	bool fXhciPresent = false; /*< Flag whether at least one XHCI controller is present. /
1811
1812	for (size_t i = 0; i < usbCtrls.size(); ++i)
1813	{
1814	USBControllerType_T enmCtrlType;
1815	rc = usbCtrls[i]->COMGETTER(Type)(&enmCtrlType); H();
1816	if (enmCtrlType == USBControllerType_OHCI)
1817	{
1818	fOhciPresent = true;
1819	break;
1820	}
1821	else if (enmCtrlType == USBControllerType_XHCI)
1822	{
1823	fXhciPresent = true;
1824	break;
1825	}
1826	}
1827
1828	/*
1829	* Currently EHCI is only enabled when an OHCI or XHCI controller is present as well.
1830	*/
1831	if (fOhciPresent \|\| fXhciPresent)
1832	mfVMHasUsbController = true;
1833
1834	PCFGMNODE pUsbDevices = NULL; /*< Required for USB storage controller later. /
1835	if (mfVMHasUsbController)
1836	{
1837	for (size_t i = 0; i < usbCtrls.size(); ++i)
1838	{
1839	USBControllerType_T enmCtrlType;
1840	rc = usbCtrls[i]->COMGETTER(Type)(&enmCtrlType); H();
1841
1842	if (enmCtrlType == USBControllerType_OHCI)
1843	{
1844	InsertConfigNode(pDevices, "usb-ohci", &pDev);
1845	InsertConfigNode(pDev, "0", &pInst);
1846	InsertConfigNode(pInst, "Config", &pCfg);
1847	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1848	hrc = pBusMgr->assignPCIDevice("usb-ohci", pInst); H();
1849	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1850	InsertConfigString(pLunL0, "Driver", "VUSBRootHub");
1851	InsertConfigNode(pLunL0, "Config", &pCfg);
1852
1853	/*
1854	* Attach the status driver.
1855	*/
1856	i_attachStatusDriver(pInst, &mapUSBLed[0], 0, 0, NULL, NULL, 0);
1857	}
1858	#ifdef VBOX_WITH_EHCI
1859	else if (enmCtrlType == USBControllerType_EHCI)
1860	{
1861	/*
1862	* USB 2.0 is only available if the proper ExtPack is installed.
1863	*
1864	* Note. Configuring EHCI here and providing messages about
1865	* the missing extpack isn't exactly clean, but it is a
1866	* necessary evil to patch over legacy compatability issues
1867	* introduced by the new distribution model.
1868	*/
1869	static const char *s_pszUsbExtPackName = "Oracle VM VirtualBox Extension Pack";
1870	# ifdef VBOX_WITH_EXTPACK
1871	if (mptrExtPackManager->i_isExtPackUsable(s_pszUsbExtPackName))
1872	# endif
1873	{
1874	InsertConfigNode(pDevices, "usb-ehci", &pDev);
1875	InsertConfigNode(pDev, "0", &pInst);
1876	InsertConfigNode(pInst, "Config", &pCfg);
1877	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1878	hrc = pBusMgr->assignPCIDevice("usb-ehci", pInst); H();
1879
1880	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1881	InsertConfigString(pLunL0, "Driver", "VUSBRootHub");
1882	InsertConfigNode(pLunL0, "Config", &pCfg);
1883
1884	/*
1885	* Attach the status driver.
1886	*/
1887	i_attachStatusDriver(pInst, &mapUSBLed[1], 0, 0, NULL, NULL, 0);
1888	}
1889	# ifdef VBOX_WITH_EXTPACK
1890	else
1891	{
1892	/* Always fatal! Up to VBox 4.0.4 we allowed to start the VM anyway
1893	* but this induced problems when the user saved + restored the VM! */
1894	return VMR3SetError(pUVM, VERR_NOT_FOUND, RT_SRC_POS,
1895	N_("Implementation of the USB 2.0 controller not found!\n"
1896	"Because the USB 2.0 controller state is part of the saved "
1897	"VM state, the VM cannot be started. To fix "
1898	"this problem, either install the '%s' or disable USB 2.0 "
1899	"support in the VM settings"),
1900	s_pszUsbExtPackName);
1901	}
1902	# endif
1903	}
1904	#endif
1905	else if (enmCtrlType == USBControllerType_XHCI)
1906	{
1907	/*
1908	* USB 3.0 is only available if the proper ExtPack is installed.
1909	*
1910	* Note. Configuring EHCI here and providing messages about
1911	* the missing extpack isn't exactly clean, but it is a
1912	* necessary evil to patch over legacy compatability issues
1913	* introduced by the new distribution model.
1914	*/
1915	static const char *s_pszUsbExtPackName = "Oracle VM VirtualBox Extension Pack";
1916	# ifdef VBOX_WITH_EXTPACK
1917	if (mptrExtPackManager->i_isExtPackUsable(s_pszUsbExtPackName))
1918	# endif
1919	{
1920	InsertConfigNode(pDevices, "usb-xhci", &pDev);
1921	InsertConfigNode(pDev, "0", &pInst);
1922	InsertConfigNode(pInst, "Config", &pCfg);
1923	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
1924	hrc = pBusMgr->assignPCIDevice("usb-xhci", pInst); H();
1925
1926	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1927	InsertConfigString(pLunL0, "Driver", "VUSBRootHub");
1928	InsertConfigNode(pLunL0, "Config", &pCfg);
1929
1930	InsertConfigNode(pInst, "LUN#1", &pLunL1);
1931	InsertConfigString(pLunL1, "Driver", "VUSBRootHub");
1932	InsertConfigNode(pLunL1, "Config", &pCfg);
1933
1934	/*
1935	* Attach the status driver.
1936	*/
1937	i_attachStatusDriver(pInst, &mapUSBLed[0], 0, 1, NULL, NULL, 0);
1938	}
1939	# ifdef VBOX_WITH_EXTPACK
1940	else
1941	{
1942	/* Always fatal. */
1943	return VMR3SetError(pUVM, VERR_NOT_FOUND, RT_SRC_POS,
1944	N_("Implementation of the USB 3.0 controller not found!\n"
1945	"Because the USB 3.0 controller state is part of the saved "
1946	"VM state, the VM cannot be started. To fix "
1947	"this problem, either install the '%s' or disable USB 3.0 "
1948	"support in the VM settings"),
1949	s_pszUsbExtPackName);
1950	}
1951	# endif
1952	}
1953	} /* for every USB controller. */
1954
1955
1956	/*
1957	* Virtual USB Devices.
1958	*/
1959	InsertConfigNode(pRoot, "USB", &pUsbDevices);
1960
1961	#ifdef VBOX_WITH_USB
1962	{
1963	/*
1964	* Global USB options, currently unused as we'll apply the 2.0 -> 1.1 morphing
1965	* on a per device level now.
1966	*/
1967	InsertConfigNode(pUsbDevices, "USBProxy", &pCfg);
1968	InsertConfigNode(pCfg, "GlobalConfig", &pCfg);
1969	// This globally enables the 2.0 -> 1.1 device morphing of proxied devices to keep windows quiet.
1970	//InsertConfigInteger(pCfg, "Force11Device", true);
1971	// The following breaks stuff, but it makes MSDs work in vista. (I include it here so
1972	// that it's documented somewhere.) Users needing it can use:
1973	// VBoxManage setextradata "myvm" "VBoxInternal/USB/USBProxy/GlobalConfig/Force11PacketSize" 1
1974	//InsertConfigInteger(pCfg, "Force11PacketSize", true);
1975	}
1976	#endif
1977
1978	#ifdef VBOX_WITH_USB_CARDREADER
1979	BOOL aEmulatedUSBCardReaderEnabled = FALSE;
1980	hrc = pMachine->COMGETTER(EmulatedUSBCardReaderEnabled)(&aEmulatedUSBCardReaderEnabled); H();
1981	if (aEmulatedUSBCardReaderEnabled)
1982	{
1983	InsertConfigNode(pUsbDevices, "CardReader", &pDev);
1984	InsertConfigNode(pDev, "0", &pInst);
1985	InsertConfigNode(pInst, "Config", &pCfg);
1986
1987	InsertConfigNode(pInst, "LUN#0", &pLunL0);
1988	# ifdef VBOX_WITH_USB_CARDREADER_TEST
1989	InsertConfigString(pLunL0, "Driver", "DrvDirectCardReader");
1990	InsertConfigNode(pLunL0, "Config", &pCfg);
1991	# else
1992	InsertConfigString(pLunL0, "Driver", "UsbCardReader");
1993	InsertConfigNode(pLunL0, "Config", &pCfg);
1994	InsertConfigInteger(pCfg, "Object", (uintptr_t)mUsbCardReader);
1995	# endif
1996	}
1997	#endif
1998
1999	/* Virtual USB Mouse/Tablet */
2000	if ( aPointingHID == PointingHIDType_USBMouse
2001	\|\| aPointingHID == PointingHIDType_USBTablet
2002	\|\| aPointingHID == PointingHIDType_USBMultiTouch)
2003	{
2004	InsertConfigNode(pUsbDevices, "HidMouse", &pDev);
2005	InsertConfigNode(pDev, "0", &pInst);
2006	InsertConfigNode(pInst, "Config", &pCfg);
2007
2008	if (aPointingHID == PointingHIDType_USBMouse)
2009	InsertConfigString(pCfg, "Mode", "relative");
2010	else
2011	InsertConfigString(pCfg, "Mode", "absolute");
2012	InsertConfigNode(pInst, "LUN#0", &pLunL0);
2013	InsertConfigString(pLunL0, "Driver", "MouseQueue");
2014	InsertConfigNode(pLunL0, "Config", &pCfg);
2015	InsertConfigInteger(pCfg, "QueueSize", 128);
2016
2017	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
2018	InsertConfigString(pLunL1, "Driver", "MainMouse");
2019	InsertConfigNode(pLunL1, "Config", &pCfg);
2020	InsertConfigInteger(pCfg, "Object", (uintptr_t)pMouse);
2021	}
2022	if (aPointingHID == PointingHIDType_USBMultiTouch)
2023	{
2024	InsertConfigNode(pDev, "1", &pInst);
2025	InsertConfigNode(pInst, "Config", &pCfg);
2026
2027	InsertConfigString(pCfg, "Mode", "multitouch");
2028	InsertConfigNode(pInst, "LUN#0", &pLunL0);
2029	InsertConfigString(pLunL0, "Driver", "MouseQueue");
2030	InsertConfigNode(pLunL0, "Config", &pCfg);
2031	InsertConfigInteger(pCfg, "QueueSize", 128);
2032
2033	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
2034	InsertConfigString(pLunL1, "Driver", "MainMouse");
2035	InsertConfigNode(pLunL1, "Config", &pCfg);
2036	InsertConfigInteger(pCfg, "Object", (uintptr_t)pMouse);
2037	}
2038
2039	/* Virtual USB Keyboard */
2040	KeyboardHIDType_T aKbdHID;
2041	hrc = pMachine->COMGETTER(KeyboardHIDType)(&aKbdHID); H();
2042	if (aKbdHID == KeyboardHIDType_USBKeyboard)
2043	{
2044	InsertConfigNode(pUsbDevices, "HidKeyboard", &pDev);
2045	InsertConfigNode(pDev, "0", &pInst);
2046	InsertConfigNode(pInst, "Config", &pCfg);
2047
2048	InsertConfigNode(pInst, "LUN#0", &pLunL0);
2049	InsertConfigString(pLunL0, "Driver", "KeyboardQueue");
2050	InsertConfigNode(pLunL0, "Config", &pCfg);
2051	InsertConfigInteger(pCfg, "QueueSize", 64);
2052
2053	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
2054	InsertConfigString(pLunL1, "Driver", "MainKeyboard");
2055	InsertConfigNode(pLunL1, "Config", &pCfg);
2056	pKeyboard = mKeyboard;
2057	InsertConfigInteger(pCfg, "Object", (uintptr_t)pKeyboard);
2058	}
2059	}
2060
2061	/*
2062	* Storage controllers.
2063	*/
2064	com::SafeIfaceArray<IStorageController> ctrls;
2065	PCFGMNODE aCtrlNodes[StorageControllerType_LsiLogicSas + 1] = {};
2066	hrc = pMachine->COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(ctrls)); H();
2067
2068	bool fFdcEnabled = false;
2069	for (size_t i = 0; i < ctrls.size(); ++i)
2070	{
2071	DeviceType_T *paLedDevType = NULL;
2072
2073	StorageControllerType_T enmCtrlType;
2074	rc = ctrls[i]->COMGETTER(ControllerType)(&enmCtrlType); H();
2075	AssertRelease((unsigned)enmCtrlType < RT_ELEMENTS(aCtrlNodes)
2076	\|\| enmCtrlType == StorageControllerType_USB);
2077
2078	StorageBus_T enmBus;
2079	rc = ctrls[i]->COMGETTER(Bus)(&enmBus); H();
2080
2081	Bstr controllerName;
2082	rc = ctrls[i]->COMGETTER(Name)(controllerName.asOutParam()); H();
2083
2084	ULONG ulInstance = 999;
2085	rc = ctrls[i]->COMGETTER(Instance)(&ulInstance); H();
2086
2087	BOOL fUseHostIOCache;
2088	rc = ctrls[i]->COMGETTER(UseHostIOCache)(&fUseHostIOCache); H();
2089
2090	BOOL fBootable;
2091	rc = ctrls[i]->COMGETTER(Bootable)(&fBootable); H();
2092
2093	PCFGMNODE pCtlInst = NULL;
2094	const char *pszCtrlDev = i_convertControllerTypeToDev(enmCtrlType);
2095	if (enmCtrlType != StorageControllerType_USB)
2096	{
2097	/* /Devices/<ctrldev>/ */
2098	pDev = aCtrlNodes[enmCtrlType];
2099	if (!pDev)
2100	{
2101	InsertConfigNode(pDevices, pszCtrlDev, &pDev);
2102	aCtrlNodes[enmCtrlType] = pDev; /* IDE variants are handled in the switch */
2103	}
2104
2105	/* /Devices/<ctrldev>/<instance>/ */
2106	InsertConfigNode(pDev, Utf8StrFmt("%u", ulInstance).c_str(), &pCtlInst);
2107
2108	/* Device config: /Devices/<ctrldev>/<instance>/<values> & /ditto/Config/<values> */
2109	InsertConfigInteger(pCtlInst, "Trusted", 1);
2110	InsertConfigNode(pCtlInst, "Config", &pCfg);
2111	}
2112
2113	static const char * const apszBiosConfigScsi[MAX_BIOS_LUN_COUNT] =
2114	{ "ScsiLUN1", "ScsiLUN2", "ScsiLUN3", "ScsiLUN4" };
2115
2116	static const char * const apszBiosConfigSata[MAX_BIOS_LUN_COUNT] =
2117	{ "SataLUN1", "SataLUN2", "SataLUN3", "SataLUN4" };
2118
2119	switch (enmCtrlType)
2120	{
2121	case StorageControllerType_LsiLogic:
2122	{
2123	hrc = pBusMgr->assignPCIDevice("lsilogic", pCtlInst); H();
2124
2125	InsertConfigInteger(pCfg, "Bootable", fBootable);
2126
2127	/* BIOS configuration values, first SCSI controller only. */
2128	if ( !pBusMgr->hasPCIDevice("lsilogic", 1)
2129	&& !pBusMgr->hasPCIDevice("buslogic", 0)
2130	&& !pBusMgr->hasPCIDevice("lsilogicsas", 0)
2131	&& pBiosCfg)
2132	{
2133	InsertConfigString(pBiosCfg, "ScsiHardDiskDevice", "lsilogicscsi");
2134	hrc = SetBiosDiskInfo(pMachine, pCfg, pBiosCfg, controllerName, apszBiosConfigScsi); H();
2135	}
2136
2137	/* Attach the status driver */
2138	Assert(cLedScsi >= 16);
2139	i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedScsi], 0, 15,
2140	&mapMediumAttachments, pszCtrlDev, ulInstance);
2141	paLedDevType = &maStorageDevType[iLedScsi];
2142	break;
2143	}
2144
2145	case StorageControllerType_BusLogic:
2146	{
2147	hrc = pBusMgr->assignPCIDevice("buslogic", pCtlInst); H();
2148
2149	InsertConfigInteger(pCfg, "Bootable", fBootable);
2150
2151	/* BIOS configuration values, first SCSI controller only. */
2152	if ( !pBusMgr->hasPCIDevice("lsilogic", 0)
2153	&& !pBusMgr->hasPCIDevice("buslogic", 1)
2154	&& !pBusMgr->hasPCIDevice("lsilogicsas", 0)
2155	&& pBiosCfg)
2156	{
2157	InsertConfigString(pBiosCfg, "ScsiHardDiskDevice", "buslogic");
2158	hrc = SetBiosDiskInfo(pMachine, pCfg, pBiosCfg, controllerName, apszBiosConfigScsi); H();
2159	}
2160
2161	/* Attach the status driver */
2162	Assert(cLedScsi >= 16);
2163	i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedScsi], 0, 15,
2164	&mapMediumAttachments, pszCtrlDev, ulInstance);
2165	paLedDevType = &maStorageDevType[iLedScsi];
2166	break;
2167	}
2168
2169	case StorageControllerType_IntelAhci:
2170	{
2171	hrc = pBusMgr->assignPCIDevice("ahci", pCtlInst); H();
2172
2173	ULONG cPorts = 0;
2174	hrc = ctrls[i]->COMGETTER(PortCount)(&cPorts); H();
2175	InsertConfigInteger(pCfg, "PortCount", cPorts);
2176	InsertConfigInteger(pCfg, "Bootable", fBootable);
2177
2178	/* BIOS configuration values, first AHCI controller only. */
2179	if ( !pBusMgr->hasPCIDevice("ahci", 1)
2180	&& pBiosCfg)
2181	{
2182	InsertConfigString(pBiosCfg, "SataHardDiskDevice", "ahci");
2183	hrc = SetBiosDiskInfo(pMachine, pCfg, pBiosCfg, controllerName, apszBiosConfigSata); H();
2184	}
2185
2186	/* Attach the status driver */
2187	AssertRelease(cPorts <= cLedSata);
2188	i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedSata], 0, cPorts - 1,
2189	&mapMediumAttachments, pszCtrlDev, ulInstance);
2190	paLedDevType = &maStorageDevType[iLedSata];
2191	break;
2192	}
2193
2194	case StorageControllerType_PIIX3:
2195	case StorageControllerType_PIIX4:
2196	case StorageControllerType_ICH6:
2197	{
2198	/*
2199	* IDE (update this when the main interface changes)
2200	*/
2201	hrc = pBusMgr->assignPCIDevice("piix3ide", pCtlInst); H();
2202	InsertConfigString(pCfg, "Type", controllerString(enmCtrlType));
2203	/* Attach the status driver */
2204	Assert(cLedIde >= 4);
2205	i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedIde], 0, 3,
2206	&mapMediumAttachments, pszCtrlDev, ulInstance);
2207	paLedDevType = &maStorageDevType[iLedIde];
2208
2209	/* IDE flavors */
2210	aCtrlNodes[StorageControllerType_PIIX3] = pDev;
2211	aCtrlNodes[StorageControllerType_PIIX4] = pDev;
2212	aCtrlNodes[StorageControllerType_ICH6] = pDev;
2213	break;
2214	}
2215
2216	case StorageControllerType_I82078:
2217	{
2218	/*
2219	* i82078 Floppy drive controller
2220	*/
2221	fFdcEnabled = true;
2222	InsertConfigInteger(pCfg, "IRQ", 6);
2223	InsertConfigInteger(pCfg, "DMA", 2);
2224	InsertConfigInteger(pCfg, "MemMapped", 0 );
2225	InsertConfigInteger(pCfg, "IOBase", 0x3f0);
2226
2227	/* Attach the status driver */
2228	Assert(cLedFloppy >= 2);
2229	i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedFloppy], 0, 1,
2230	&mapMediumAttachments, pszCtrlDev, ulInstance);
2231	paLedDevType = &maStorageDevType[iLedFloppy];
2232	break;
2233	}
2234
2235	case StorageControllerType_LsiLogicSas:
2236	{
2237	hrc = pBusMgr->assignPCIDevice("lsilogicsas", pCtlInst); H();
2238
2239	InsertConfigString(pCfg, "ControllerType", "SAS1068");
2240	InsertConfigInteger(pCfg, "Bootable", fBootable);
2241
2242	/* BIOS configuration values, first SCSI controller only. */
2243	if ( !pBusMgr->hasPCIDevice("lsilogic", 0)
2244	&& !pBusMgr->hasPCIDevice("buslogic", 0)
2245	&& !pBusMgr->hasPCIDevice("lsilogicsas", 1)
2246	&& pBiosCfg)
2247	{
2248	InsertConfigString(pBiosCfg, "ScsiHardDiskDevice", "lsilogicsas");
2249	hrc = SetBiosDiskInfo(pMachine, pCfg, pBiosCfg, controllerName, apszBiosConfigScsi); H();
2250	}
2251
2252	ULONG cPorts = 0;
2253	hrc = ctrls[i]->COMGETTER(PortCount)(&cPorts); H();
2254	InsertConfigInteger(pCfg, "NumPorts", cPorts);
2255
2256	/* Attach the status driver */
2257	Assert(cLedSas >= 8);
2258	i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedSas], 0, 7,
2259	&mapMediumAttachments, pszCtrlDev, ulInstance);
2260	paLedDevType = &maStorageDevType[iLedSas];
2261	break;
2262	}
2263
2264	case StorageControllerType_USB:
2265	{
2266	if (pUsbDevices)
2267	{
2268	/*
2269	* USB MSDs are handled a bit different as the device instance
2270	* doesn't match the storage controller instance but the port.
2271	*/
2272	InsertConfigNode(pUsbDevices, "Msd", &pDev);
2273	pCtlInst = pDev;
2274	}
2275	else
2276	return VMR3SetError(pUVM, VERR_NOT_FOUND, RT_SRC_POS,
2277	N_("There is no USB controller enabled but there\n"
2278	"is at least one USB storage device configured for this VM.\n"
2279	"To fix this problem either enable the USB controller or remove\n"
2280	"the storage device from the VM"));
2281	break;
2282	}
2283
2284	default:
2285	AssertLogRelMsgFailedReturn(("invalid storage controller type: %d\n", enmCtrlType), VERR_MAIN_CONFIG_CONSTRUCTOR_IPE);
2286	}
2287
2288	/* Attach the media to the storage controllers. */
2289	com::SafeIfaceArray<IMediumAttachment> atts;
2290	hrc = pMachine->GetMediumAttachmentsOfController(controllerName.raw(),
2291	ComSafeArrayAsOutParam(atts)); H();
2292
2293	/* Builtin I/O cache - per device setting. */
2294	BOOL fBuiltinIOCache = true;
2295	hrc = pMachine->COMGETTER(IOCacheEnabled)(&fBuiltinIOCache); H();
2296
2297
2298	for (size_t j = 0; j < atts.size(); ++j)
2299	{
2300	IMediumAttachment *pMediumAtt = atts[j];
2301	rc = i_configMediumAttachment(pszCtrlDev,
2302	ulInstance,
2303	enmBus,
2304	!!fUseHostIOCache,
2305	!!fBuiltinIOCache,
2306	false /* fSetupMerge */,
2307	0 /* uMergeSource */,
2308	0 /* uMergeTarget */,
2309	pMediumAtt,
2310	mMachineState,
2311	NULL /* phrc */,
2312	false /* fAttachDetach */,
2313	false /* fForceUnmount */,
2314	false /* fHotplug */,
2315	pUVM,
2316	paLedDevType,
2317	NULL /* ppLunL0 */);
2318	if (RT_FAILURE(rc))
2319	return rc;
2320	}
2321	H();
2322	}
2323	H();
2324
2325	/*
2326	* Network adapters
2327	*/
2328	#ifdef VMWARE_NET_IN_SLOT_11
2329	bool fSwapSlots3and11 = false;
2330	#endif
2331	PCFGMNODE pDevPCNet = NULL; /* PCNet-type devices */
2332	InsertConfigNode(pDevices, "pcnet", &pDevPCNet);
2333	#ifdef VBOX_WITH_E1000
2334	PCFGMNODE pDevE1000 = NULL; /* E1000-type devices */
2335	InsertConfigNode(pDevices, "e1000", &pDevE1000);
2336	#endif
2337	#ifdef VBOX_WITH_VIRTIO
2338	PCFGMNODE pDevVirtioNet = NULL; /* Virtio network devices */
2339	InsertConfigNode(pDevices, "virtio-net", &pDevVirtioNet);
2340	#endif /* VBOX_WITH_VIRTIO */
2341	std::list<BootNic> llBootNics;
2342	for (ULONG ulInstance = 0; ulInstance < maxNetworkAdapters; ++ulInstance)
2343	{
2344	ComPtr<INetworkAdapter> networkAdapter;
2345	hrc = pMachine->GetNetworkAdapter(ulInstance, networkAdapter.asOutParam()); H();
2346	BOOL fEnabledNetAdapter = FALSE;
2347	hrc = networkAdapter->COMGETTER(Enabled)(&fEnabledNetAdapter); H();
2348	if (!fEnabledNetAdapter)
2349	continue;
2350
2351	/*
2352	* The virtual hardware type. Create appropriate device first.
2353	*/
2354	const char *pszAdapterName = "pcnet";
2355	NetworkAdapterType_T adapterType;
2356	hrc = networkAdapter->COMGETTER(AdapterType)(&adapterType); H();
2357	switch (adapterType)
2358	{
2359	case NetworkAdapterType_Am79C970A:
2360	case NetworkAdapterType_Am79C973:
2361	pDev = pDevPCNet;
2362	break;
2363	#ifdef VBOX_WITH_E1000
2364	case NetworkAdapterType_I82540EM:
2365	case NetworkAdapterType_I82543GC:
2366	case NetworkAdapterType_I82545EM:
2367	pDev = pDevE1000;
2368	pszAdapterName = "e1000";
2369	break;
2370	#endif
2371	#ifdef VBOX_WITH_VIRTIO
2372	case NetworkAdapterType_Virtio:
2373	pDev = pDevVirtioNet;
2374	pszAdapterName = "virtio-net";
2375	break;
2376	#endif /* VBOX_WITH_VIRTIO */
2377	default:
2378	AssertMsgFailed(("Invalid network adapter type '%d' for slot '%d'",
2379	adapterType, ulInstance));
2380	return VMR3SetError(pUVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
2381	N_("Invalid network adapter type '%d' for slot '%d'"),
2382	adapterType, ulInstance);
2383	}
2384
2385	InsertConfigNode(pDev, Utf8StrFmt("%u", ulInstance).c_str(), &pInst);
2386	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
2387	/* the first network card gets the PCI ID 3, the next 3 gets 8..10,
2388	* next 4 get 16..19. */
2389	int iPCIDeviceNo;
2390	switch (ulInstance)
2391	{
2392	case 0:
2393	iPCIDeviceNo = 3;
2394	break;
2395	case 1: case 2: case 3:
2396	iPCIDeviceNo = ulInstance - 1 + 8;
2397	break;
2398	case 4: case 5: case 6: case 7:
2399	iPCIDeviceNo = ulInstance - 4 + 16;
2400	break;
2401	default:
2402	/* auto assignment */
2403	iPCIDeviceNo = -1;
2404	break;
2405	}
2406	#ifdef VMWARE_NET_IN_SLOT_11
2407	/*
2408	* Dirty hack for PCI slot compatibility with VMWare,
2409	* it assigns slot 0x11 to the first network controller.
2410	*/
2411	if (iPCIDeviceNo == 3 && adapterType == NetworkAdapterType_I82545EM)
2412	{
2413	iPCIDeviceNo = 0x11;
2414	fSwapSlots3and11 = true;
2415	}
2416	else if (iPCIDeviceNo == 0x11 && fSwapSlots3and11)
2417	iPCIDeviceNo = 3;
2418	#endif
2419	PCIBusAddress PCIAddr = PCIBusAddress(0, iPCIDeviceNo, 0);
2420	hrc = pBusMgr->assignPCIDevice(pszAdapterName, pInst, PCIAddr); H();
2421
2422	InsertConfigNode(pInst, "Config", &pCfg);
2423	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE /* not safe here yet. / /* @todo Make PCNet ring-0 safe on 32-bit mac kernels! */
2424	if (pDev == pDevPCNet)
2425	{
2426	InsertConfigInteger(pCfg, "R0Enabled", false);
2427	}
2428	#endif
2429	/*
2430	* Collect information needed for network booting and add it to the list.
2431	*/
2432	BootNic nic;
2433
2434	nic.mInstance = ulInstance;
2435	/* Could be updated by reference, if auto assigned */
2436	nic.mPCIAddress = PCIAddr;
2437
2438	hrc = networkAdapter->COMGETTER(BootPriority)(&nic.mBootPrio); H();
2439
2440	llBootNics.push_back(nic);
2441
2442	/*
2443	* The virtual hardware type. PCNet supports two types.
2444	*/
2445	switch (adapterType)
2446	{
2447	case NetworkAdapterType_Am79C970A:
2448	InsertConfigInteger(pCfg, "Am79C973", 0);
2449	break;
2450	case NetworkAdapterType_Am79C973:
2451	InsertConfigInteger(pCfg, "Am79C973", 1);
2452	break;
2453	case NetworkAdapterType_I82540EM:
2454	InsertConfigInteger(pCfg, "AdapterType", 0);
2455	break;
2456	case NetworkAdapterType_I82543GC:
2457	InsertConfigInteger(pCfg, "AdapterType", 1);
2458	break;
2459	case NetworkAdapterType_I82545EM:
2460	InsertConfigInteger(pCfg, "AdapterType", 2);
2461	break;
2462	}
2463
2464	/*
2465	* Get the MAC address and convert it to binary representation
2466	*/
2467	Bstr macAddr;
2468	hrc = networkAdapter->COMGETTER(MACAddress)(macAddr.asOutParam()); H();
2469	Assert(!macAddr.isEmpty());
2470	Utf8Str macAddrUtf8 = macAddr;
2471	char macStr = (char)macAddrUtf8.c_str();
2472	Assert(strlen(macStr) == 12);
2473	RTMAC Mac;
2474	RT_ZERO(Mac);
2475	char pMac = (char)&Mac;
2476	for (uint32_t i = 0; i < 6; ++i)
2477	{
2478	char c1 = *macStr++ - '0';
2479	if (c1 > 9)
2480	c1 -= 7;
2481	char c2 = *macStr++ - '0';
2482	if (c2 > 9)
2483	c2 -= 7;
2484	*pMac++ = ((c1 & 0x0f) << 4) \| (c2 & 0x0f);
2485	}
2486	InsertConfigBytes(pCfg, "MAC", &Mac, sizeof(Mac));
2487
2488	/*
2489	* Check if the cable is supposed to be unplugged
2490	*/
2491	BOOL fCableConnected;
2492	hrc = networkAdapter->COMGETTER(CableConnected)(&fCableConnected); H();
2493	InsertConfigInteger(pCfg, "CableConnected", fCableConnected ? 1 : 0);
2494
2495	/*
2496	* Line speed to report from custom drivers
2497	*/
2498	ULONG ulLineSpeed;
2499	hrc = networkAdapter->COMGETTER(LineSpeed)(&ulLineSpeed); H();
2500	InsertConfigInteger(pCfg, "LineSpeed", ulLineSpeed);
2501
2502	/*
2503	* Attach the status driver.
2504	*/
2505	i_attachStatusDriver(pInst, &mapNetworkLeds[ulInstance], 0, 0, NULL, NULL, 0);
2506
2507	/*
2508	* Configure the network card now
2509	*/
2510	bool fIgnoreConnectFailure = mMachineState == MachineState_Restoring;
2511	rc = i_configNetwork(pszAdapterName,
2512	ulInstance,
2513	0,
2514	networkAdapter,
2515	pCfg,
2516	pLunL0,
2517	pInst,
2518	false /fAttachDetach/,
2519	fIgnoreConnectFailure);
2520	if (RT_FAILURE(rc))
2521	return rc;
2522	}
2523
2524	/*
2525	* Build network boot information and transfer it to the BIOS.
2526	*/
2527	if (pNetBootCfg && !llBootNics.empty()) /* NetBoot node doesn't exist for EFI! */
2528	{
2529	llBootNics.sort(); /* Sort the list by boot priority. */
2530
2531	char achBootIdx[] = "0";
2532	unsigned uBootIdx = 0;
2533
2534	for (std::list<BootNic>::iterator it = llBootNics.begin(); it != llBootNics.end(); ++it)
2535	{
2536	/* A NIC with priority 0 is only used if it's first in the list. */
2537	if (it->mBootPrio == 0 && uBootIdx != 0)
2538	break;
2539
2540	PCFGMNODE pNetBtDevCfg;
2541	achBootIdx[0] = '0' + uBootIdx++; /* Boot device order. */
2542	InsertConfigNode(pNetBootCfg, achBootIdx, &pNetBtDevCfg);
2543	InsertConfigInteger(pNetBtDevCfg, "NIC", it->mInstance);
2544	InsertConfigInteger(pNetBtDevCfg, "PCIBusNo", it->mPCIAddress.miBus);
2545	InsertConfigInteger(pNetBtDevCfg, "PCIDeviceNo", it->mPCIAddress.miDevice);
2546	InsertConfigInteger(pNetBtDevCfg, "PCIFunctionNo", it->mPCIAddress.miFn);
2547	}
2548	}
2549
2550	/*
2551	* Serial (UART) Ports
2552	*/
2553	/* serial enabled mask to be passed to dev ACPI */
2554	uint16_t auSerialIoPortBase[SchemaDefs::SerialPortCount] = {0};
2555	uint8_t auSerialIrq[SchemaDefs::SerialPortCount] = {0};
2556	InsertConfigNode(pDevices, "serial", &pDev);
2557	for (ULONG ulInstance = 0; ulInstance < SchemaDefs::SerialPortCount; ++ulInstance)
2558	{
2559	ComPtr<ISerialPort> serialPort;
2560	hrc = pMachine->GetSerialPort(ulInstance, serialPort.asOutParam()); H();
2561	BOOL fEnabledSerPort = FALSE;
2562	if (serialPort)
2563	hrc = serialPort->COMGETTER(Enabled)(&fEnabledSerPort); H();
2564	if (!fEnabledSerPort)
2565	continue;
2566
2567	InsertConfigNode(pDev, Utf8StrFmt("%u", ulInstance).c_str(), &pInst);
2568	InsertConfigNode(pInst, "Config", &pCfg);
2569
2570	ULONG ulIRQ;
2571	hrc = serialPort->COMGETTER(IRQ)(&ulIRQ); H();
2572	InsertConfigInteger(pCfg, "IRQ", ulIRQ);
2573	auSerialIrq[ulInstance] = (uint8_t)ulIRQ;
2574
2575	ULONG ulIOBase;
2576	hrc = serialPort->COMGETTER(IOBase)(&ulIOBase); H();
2577	InsertConfigInteger(pCfg, "IOBase", ulIOBase);
2578	auSerialIoPortBase[ulInstance] = (uint16_t)ulIOBase;
2579
2580	BOOL fServer;
2581	hrc = serialPort->COMGETTER(Server)(&fServer); H();
2582	hrc = serialPort->COMGETTER(Path)(bstr.asOutParam()); H();
2583	PortMode_T eHostMode;
2584	hrc = serialPort->COMGETTER(HostMode)(&eHostMode); H();
2585	if (eHostMode != PortMode_Disconnected)
2586	{
2587	InsertConfigNode(pInst, "LUN#0", &pLunL0);
2588	if (eHostMode == PortMode_HostPipe)
2589	{
2590	InsertConfigString(pLunL0, "Driver", "Char");
2591	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
2592	InsertConfigString(pLunL1, "Driver", "NamedPipe");
2593	InsertConfigNode(pLunL1, "Config", &pLunL2);
2594	InsertConfigString(pLunL2, "Location", bstr);
2595	InsertConfigInteger(pLunL2, "IsServer", fServer);
2596	}
2597	else if (eHostMode == PortMode_HostDevice)
2598	{
2599	InsertConfigString(pLunL0, "Driver", "Host Serial");
2600	InsertConfigNode(pLunL0, "Config", &pLunL1);
2601	InsertConfigString(pLunL1, "DevicePath", bstr);
2602	}
2603	else if (eHostMode == PortMode_TCP)
2604	{
2605	InsertConfigString(pLunL0, "Driver", "Char");
2606	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
2607	InsertConfigString(pLunL1, "Driver", "TCP");
2608	InsertConfigNode(pLunL1, "Config", &pLunL2);
2609	InsertConfigString(pLunL2, "Location", bstr);
2610	InsertConfigInteger(pLunL2, "IsServer", fServer);
2611	}
2612	else if (eHostMode == PortMode_RawFile)
2613	{
2614	InsertConfigString(pLunL0, "Driver", "Char");
2615	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
2616	InsertConfigString(pLunL1, "Driver", "RawFile");
2617	InsertConfigNode(pLunL1, "Config", &pLunL2);
2618	InsertConfigString(pLunL2, "Location", bstr);
2619	}
2620	}
2621	}
2622
2623	/*
2624	* Parallel (LPT) Ports
2625	*/
2626	InsertConfigNode(pDevices, "parallel", &pDev);
2627	for (ULONG ulInstance = 0; ulInstance < SchemaDefs::ParallelPortCount; ++ulInstance)
2628	{
2629	ComPtr<IParallelPort> parallelPort;
2630	hrc = pMachine->GetParallelPort(ulInstance, parallelPort.asOutParam()); H();
2631	BOOL fEnabledParPort = FALSE;
2632	if (parallelPort)
2633	{
2634	hrc = parallelPort->COMGETTER(Enabled)(&fEnabledParPort); H();
2635	}
2636	if (!fEnabledParPort)
2637	continue;
2638
2639	InsertConfigNode(pDev, Utf8StrFmt("%u", ulInstance).c_str(), &pInst);
2640	InsertConfigNode(pInst, "Config", &pCfg);
2641
2642	ULONG ulIRQ;
2643	hrc = parallelPort->COMGETTER(IRQ)(&ulIRQ); H();
2644	InsertConfigInteger(pCfg, "IRQ", ulIRQ);
2645	ULONG ulIOBase;
2646	hrc = parallelPort->COMGETTER(IOBase)(&ulIOBase); H();
2647	InsertConfigInteger(pCfg, "IOBase", ulIOBase);
2648	InsertConfigNode(pInst, "LUN#0", &pLunL0);
2649	InsertConfigString(pLunL0, "Driver", "HostParallel");
2650	InsertConfigNode(pLunL0, "Config", &pLunL1);
2651	hrc = parallelPort->COMGETTER(Path)(bstr.asOutParam()); H();
2652	InsertConfigString(pLunL1, "DevicePath", bstr);
2653	}
2654
2655	/*
2656	* VMM Device
2657	*/
2658	InsertConfigNode(pDevices, "VMMDev", &pDev);
2659	InsertConfigNode(pDev, "0", &pInst);
2660	InsertConfigNode(pInst, "Config", &pCfg);
2661	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
2662	hrc = pBusMgr->assignPCIDevice("VMMDev", pInst); H();
2663
2664	Bstr hwVersion;
2665	hrc = pMachine->COMGETTER(HardwareVersion)(hwVersion.asOutParam()); H();
2666	InsertConfigInteger(pCfg, "RamSize", cbRam);
2667	if (hwVersion.compare(Bstr("1").raw()) == 0) /* <= 2.0.x */
2668	InsertConfigInteger(pCfg, "HeapEnabled", 0);
2669	Bstr snapshotFolder;
2670	hrc = pMachine->COMGETTER(SnapshotFolder)(snapshotFolder.asOutParam()); H();
2671	InsertConfigString(pCfg, "GuestCoreDumpDir", snapshotFolder);
2672
2673	/* the VMM device's Main driver */
2674	InsertConfigNode(pInst, "LUN#0", &pLunL0);
2675	InsertConfigString(pLunL0, "Driver", "HGCM");
2676	InsertConfigNode(pLunL0, "Config", &pCfg);
2677	InsertConfigInteger(pCfg, "Object", (uintptr_t)pVMMDev);
2678
2679	/*
2680	* Attach the status driver.
2681	*/
2682	i_attachStatusDriver(pInst, &mapSharedFolderLed, 0, 0, NULL, NULL, 0);
2683
2684	/*
2685	* AC'97 ICH / SoundBlaster16 audio / Intel HD Audio.
2686	*/
2687	BOOL fAudioEnabled = FALSE;
2688	ComPtr<IAudioAdapter> audioAdapter;
2689	hrc = pMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam()); H();
2690	if (audioAdapter)
2691	hrc = audioAdapter->COMGETTER(Enabled)(&fAudioEnabled); H();
2692
2693	if (fAudioEnabled)
2694	{
2695	AudioControllerType_T audioController;
2696	hrc = audioAdapter->COMGETTER(AudioController)(&audioController); H();
2697	AudioCodecType_T audioCodec;
2698	hrc = audioAdapter->COMGETTER(AudioCodec)(&audioCodec); H();
2699	switch (audioController)
2700	{
2701	case AudioControllerType_AC97:
2702	{
2703	/* Default: ICH AC97. */
2704	InsertConfigNode(pDevices, "ichac97", &pDev);
2705	InsertConfigNode(pDev, "0", &pInst);
2706	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
2707	hrc = pBusMgr->assignPCIDevice("ichac97", pInst); H();
2708	InsertConfigNode(pInst, "Config", &pCfg);
2709	switch (audioCodec)
2710	{
2711	case AudioCodecType_STAC9700:
2712	InsertConfigString(pCfg, "Codec", "STAC9700");
2713	break;
2714	case AudioCodecType_AD1980:
2715	InsertConfigString(pCfg, "Codec", "AD1980");
2716	break;
2717	}
2718	break;
2719	}
2720	case AudioControllerType_SB16:
2721	{
2722	/* Legacy SoundBlaster16. */
2723	InsertConfigNode(pDevices, "sb16", &pDev);
2724	InsertConfigNode(pDev, "0", &pInst);
2725	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
2726	InsertConfigNode(pInst, "Config", &pCfg);
2727	InsertConfigInteger(pCfg, "IRQ", 5);
2728	InsertConfigInteger(pCfg, "DMA", 1);
2729	InsertConfigInteger(pCfg, "DMA16", 5);
2730	InsertConfigInteger(pCfg, "Port", 0x220);
2731	InsertConfigInteger(pCfg, "Version", 0x0405);
2732	break;
2733	}
2734	case AudioControllerType_HDA:
2735	{
2736	/* Intel HD Audio. */
2737	InsertConfigNode(pDevices, "hda", &pDev);
2738	InsertConfigNode(pDev, "0", &pInst);
2739	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
2740	hrc = pBusMgr->assignPCIDevice("hda", pInst); H();
2741	InsertConfigNode(pInst, "Config", &pCfg);
2742	}
2743	}
2744
2745	PCFGMNODE pCfgAudioSettings = NULL;
2746	InsertConfigNode(pInst, "AudioConfig", &pCfgAudioSettings);
2747	SafeArray<BSTR> audioProps;
2748	hrc = audioAdapter->COMGETTER(PropertiesList)(ComSafeArrayAsOutParam(audioProps)); H();
2749
2750	std::list<Utf8Str> audioPropertyNamesList;
2751	for (size_t i = 0; i < audioProps.size(); ++i)
2752	{
2753	Bstr bstrValue;
2754	audioPropertyNamesList.push_back(Utf8Str(audioProps[i]));
2755	hrc = audioAdapter->GetProperty(audioProps[i], bstrValue.asOutParam());
2756	Utf8Str strKey(audioProps[i]);
2757	InsertConfigString(pCfgAudioSettings, strKey.c_str(), bstrValue);
2758	}
2759
2760	/* The audio driver. */
2761	InsertConfigNode(pInst, "LUN#0", &pLunL0);
2762	InsertConfigString(pLunL0, "Driver", "AUDIO");
2763	InsertConfigNode(pLunL0, "Config", &pCfg);
2764
2765	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
2766	InsertConfigNode(pLunL1, "Config", &pCfg);
2767
2768	hrc = pMachine->COMGETTER(Name)(bstr.asOutParam()); H();
2769	InsertConfigString(pCfg, "StreamName", bstr);
2770
2771	AudioDriverType_T audioDriver;
2772	hrc = audioAdapter->COMGETTER(AudioDriver)(&audioDriver); H();
2773	switch (audioDriver)
2774	{
2775	case AudioDriverType_Null:
2776	{
2777	InsertConfigString(pLunL1, "Driver", "NullAudio");
2778	break;
2779	}
2780	#ifdef RT_OS_WINDOWS
2781	# ifdef VBOX_WITH_WINMM
2782	case AudioDriverType_WinMM:
2783	{
2784	#error "Port WinMM audio backend!" /** @todo Still needed? */
2785	break;
2786	}
2787	# endif
2788	case AudioDriverType_DirectSound:
2789	{
2790	InsertConfigString(pLunL1, "Driver", "DSoundAudio");
2791	break;
2792	}
2793	#endif /* RT_OS_WINDOWS */
2794	#ifdef RT_OS_SOLARIS
2795	case AudioDriverType_SolAudio:
2796	{
2797	/** @todo Hack alert: Find a better solution. */
2798	LogRel(("Audio: WARNING: Solaris Audio is deprecated, please switch to OSS!\n"));
2799	LogRel(("Audio: Automatically setting host audio backend to OSS\n"));
2800	/* Manually set backend to OSS for now. */
2801	InsertConfigString(pLunL1, "Driver", "OSSAudio");
2802	break;
2803	}
2804	#endif
2805	#ifdef VBOX_WITH_ALSA
2806	case AudioDriverType_ALSA:
2807	{
2808	InsertConfigString(pLunL1, "Driver", "ALSAAudio");
2809	break;
2810	}
2811	#endif
2812	#ifdef VBOX_WITH_PULSE
2813	case AudioDriverType_Pulse:
2814	{
2815	InsertConfigString(pLunL1, "Driver", "PulseAudio");
2816	break;
2817	}
2818	#endif
2819	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD) \|\| defined(VBOX_WITH_SOLARIS_OSS)
2820	case AudioDriverType_OSS:
2821	{
2822	InsertConfigString(pLunL1, "Driver", "OSSAudio");
2823	break;
2824	}
2825	#endif
2826	#ifdef RT_OS_DARWIN
2827	case AudioDriverType_CoreAudio:
2828	{
2829	InsertConfigString(pLunL1, "Driver", "CoreAudio");
2830	break;
2831	}
2832	#endif
2833	}
2834
2835	/*
2836	* The VRDE audio backend driver. This one always is there
2837	* and therefore is hardcoded here.
2838	*/
2839	InsertConfigNode(pInst, "LUN#1", &pLunL1);
2840	InsertConfigString(pLunL1, "Driver", "AUDIO");
2841
2842	InsertConfigNode(pLunL1, "AttachedDriver", &pLunL1);
2843	InsertConfigString(pLunL1, "Driver", "AudioVRDE");
2844
2845	InsertConfigNode(pLunL1, "Config", &pCfg);
2846	InsertConfigString(pCfg, "AudioDriver", "AudioVRDE");
2847	InsertConfigString(pCfg, "StreamName", bstr);
2848	InsertConfigInteger(pCfg, "Object", (uintptr_t)mAudioVRDE);
2849	InsertConfigInteger(pCfg, "ObjectVRDPServer", (uintptr_t)mConsoleVRDPServer);
2850
2851	/** @todo Add audio video recording driver here. */
2852	}
2853
2854	/*
2855	* Shared Clipboard.
2856	*/
2857	{
2858	ClipboardMode_T mode = ClipboardMode_Disabled;
2859	hrc = pMachine->COMGETTER(ClipboardMode)(&mode); H();
2860
2861	if (/* mode != ClipboardMode_Disabled */ true)
2862	{
2863	/* Load the service */
2864	rc = pVMMDev->hgcmLoadService("VBoxSharedClipboard", "VBoxSharedClipboard");
2865	if (RT_FAILURE(rc))
2866	{
2867	LogRel(("Shared clipboard is not available, rc=%Rrc\n", rc));
2868	/* That is not a fatal failure. */
2869	rc = VINF_SUCCESS;
2870	}
2871	else
2872	{
2873	LogRel(("Shared clipboard service loaded\n"));
2874
2875	i_changeClipboardMode(mode);
2876
2877	/* Setup the service. */
2878	VBOXHGCMSVCPARM parm;
2879	parm.type = VBOX_HGCM_SVC_PARM_32BIT;
2880	parm.setUInt32(!i_useHostClipboard());
2881	pVMMDev->hgcmHostCall("VBoxSharedClipboard",
2882	VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS, 1, &parm);
2883	}
2884	}
2885	}
2886
2887	/*
2888	* HGCM HostChannel.
2889	*/
2890	{
2891	Bstr value;
2892	hrc = pMachine->GetExtraData(Bstr("HGCM/HostChannel").raw(),
2893	value.asOutParam());
2894
2895	if ( hrc == S_OK
2896	&& value == "1")
2897	{
2898	rc = pVMMDev->hgcmLoadService("VBoxHostChannel", "VBoxHostChannel");
2899	if (RT_FAILURE(rc))
2900	{
2901	LogRel(("VBoxHostChannel is not available, rc=%Rrc\n", rc));
2902	/* That is not a fatal failure. */
2903	rc = VINF_SUCCESS;
2904	}
2905	}
2906	}
2907
2908	#ifdef VBOX_WITH_DRAG_AND_DROP
2909	/*
2910	* Drag and Drop.
2911	*/
2912	{
2913	DnDMode_T enmMode = DnDMode_Disabled;
2914	hrc = pMachine->COMGETTER(DnDMode)(&enmMode); H();
2915
2916	/* Load the service */
2917	rc = pVMMDev->hgcmLoadService("VBoxDragAndDropSvc", "VBoxDragAndDropSvc");
2918	if (RT_FAILURE(rc))
2919	{
2920	LogRel(("Drag and drop service is not available, rc=%Rrc\n", rc));
2921	/* That is not a fatal failure. */
2922	rc = VINF_SUCCESS;
2923	}
2924	else
2925	{
2926	HGCMSVCEXTHANDLE hDummy;
2927	rc = HGCMHostRegisterServiceExtension(&hDummy, "VBoxDragAndDropSvc",
2928	&GuestDnD::notifyDnDDispatcher,
2929	GuestDnDInst());
2930	if (RT_FAILURE(rc))
2931	Log(("Cannot register VBoxDragAndDropSvc extension, rc=%Rrc\n", rc));
2932	else
2933	{
2934	LogRel(("Drag and drop service loaded\n"));
2935	rc = i_changeDnDMode(enmMode);
2936	}
2937	}
2938	}
2939	#endif /* VBOX_WITH_DRAG_AND_DROP */
2940
2941	#ifdef VBOX_WITH_CROGL
2942	/*
2943	* crOpenGL.
2944	*/
2945	{
2946	BOOL fEnabled3D = false;
2947	hrc = pMachine->COMGETTER(Accelerate3DEnabled)(&fEnabled3D); H();
2948
2949	if ( fEnabled3D
2950	# ifdef VBOX_WITH_VMSVGA3D
2951	&& enmGraphicsController == GraphicsControllerType_VBoxVGA
2952	# endif
2953	)
2954	{
2955	BOOL fSupports3D = VBoxOglIs3DAccelerationSupported();
2956	if (!fSupports3D)
2957	return VMR3SetError(pUVM, VERR_NOT_AVAILABLE, RT_SRC_POS,
2958	N_("This VM was configured to use 3D acceleration. However, the "
2959	"3D support of the host is not working properly and the "
2960	"VM cannot be started. To fix this problem, either "
2961	"fix the host 3D support (update the host graphics driver?) "
2962	"or disable 3D acceleration in the VM settings"));
2963
2964	/* Load the service. */
2965	rc = pVMMDev->hgcmLoadService("VBoxSharedCrOpenGL", "VBoxSharedCrOpenGL");
2966	if (RT_FAILURE(rc))
2967	{
2968	LogRel(("Failed to load Shared OpenGL service, rc=%Rrc\n", rc));
2969	/* That is not a fatal failure. */
2970	rc = VINF_SUCCESS;
2971	}
2972	else
2973	{
2974	LogRel(("Shared crOpenGL service loaded\n"));
2975
2976	/* Setup the service. */
2977	VBOXHGCMSVCPARM parm;
2978	parm.type = VBOX_HGCM_SVC_PARM_PTR;
2979
2980	parm.u.pointer.addr = (IConsole )(Console )this;
2981	parm.u.pointer.size = sizeof(IConsole *);
2982
2983	rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SET_CONSOLE,
2984	SHCRGL_CPARMS_SET_CONSOLE, &parm);
2985	if (!RT_SUCCESS(rc))
2986	AssertMsgFailed(("SHCRGL_HOST_FN_SET_CONSOLE failed with %Rrc\n", rc));
2987
2988	parm.u.pointer.addr = pVM;
2989	parm.u.pointer.size = sizeof(pVM);
2990	rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL",
2991	SHCRGL_HOST_FN_SET_VM, SHCRGL_CPARMS_SET_VM, &parm);
2992	if (!RT_SUCCESS(rc))
2993	AssertMsgFailed(("SHCRGL_HOST_FN_SET_VM failed with %Rrc\n", rc));
2994	}
2995	}
2996	}
2997	#endif
2998
2999	#ifdef VBOX_WITH_GUEST_PROPS
3000	/*
3001	* Guest property service.
3002	*/
3003	rc = i_configGuestProperties(this, pUVM);
3004	#endif /* VBOX_WITH_GUEST_PROPS defined */
3005
3006	#ifdef VBOX_WITH_GUEST_CONTROL
3007	/*
3008	* Guest control service.
3009	*/
3010	rc = i_configGuestControl(this);
3011	#endif /* VBOX_WITH_GUEST_CONTROL defined */
3012
3013	/*
3014	* ACPI
3015	*/
3016	BOOL fACPI;
3017	hrc = biosSettings->COMGETTER(ACPIEnabled)(&fACPI); H();
3018	if (fACPI)
3019	{
3020	/* Always show the CPU leafs when we have multiple VCPUs or when the IO-APIC is enabled.
3021	* The Windows SMP kernel needs a CPU leaf or else its idle loop will burn cpu cycles; the
3022	* intelppm driver refuses to register an idle state handler.
3023	* Always show CPU leafs for OS X guests. */
3024	BOOL fShowCpu = fOsXGuest;
3025	if (cCpus > 1 \|\| fIOAPIC)
3026	fShowCpu = true;
3027
3028	BOOL fCpuHotPlug;
3029	hrc = pMachine->COMGETTER(CPUHotPlugEnabled)(&fCpuHotPlug); H();
3030
3031	InsertConfigNode(pDevices, "acpi", &pDev);
3032	InsertConfigNode(pDev, "0", &pInst);
3033	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
3034	InsertConfigNode(pInst, "Config", &pCfg);
3035	hrc = pBusMgr->assignPCIDevice("acpi", pInst); H();
3036
3037	InsertConfigInteger(pCfg, "RamSize", cbRam);
3038	InsertConfigInteger(pCfg, "RamHoleSize", cbRamHole);
3039	InsertConfigInteger(pCfg, "NumCPUs", cCpus);
3040
3041	InsertConfigInteger(pCfg, "IOAPIC", fIOAPIC);
3042	InsertConfigInteger(pCfg, "FdcEnabled", fFdcEnabled);
3043	InsertConfigInteger(pCfg, "HpetEnabled", fHPETEnabled);
3044	InsertConfigInteger(pCfg, "SmcEnabled", fSmcEnabled);
3045	InsertConfigInteger(pCfg, "ShowRtc", fShowRtc);
3046	if (fOsXGuest && !llBootNics.empty())
3047	{
3048	BootNic aNic = llBootNics.front();
3049	uint32_t u32NicPCIAddr = (aNic.mPCIAddress.miDevice << 16) \| aNic.mPCIAddress.miFn;
3050	InsertConfigInteger(pCfg, "NicPciAddress", u32NicPCIAddr);
3051	}
3052	if (fOsXGuest && fAudioEnabled)
3053	{
3054	PCIBusAddress Address;
3055	if (pBusMgr->findPCIAddress("hda", 0, Address))
3056	{
3057	uint32_t u32AudioPCIAddr = (Address.miDevice << 16) \| Address.miFn;
3058	InsertConfigInteger(pCfg, "AudioPciAddress", u32AudioPCIAddr);
3059	}
3060	}
3061	InsertConfigInteger(pCfg, "IocPciAddress", uIocPCIAddress);
3062	if (chipsetType == ChipsetType_ICH9)
3063	{
3064	InsertConfigInteger(pCfg, "McfgBase", uMcfgBase);
3065	InsertConfigInteger(pCfg, "McfgLength", cbMcfgLength);
3066	}
3067	InsertConfigInteger(pCfg, "HostBusPciAddress", uHbcPCIAddress);
3068	InsertConfigInteger(pCfg, "ShowCpu", fShowCpu);
3069	InsertConfigInteger(pCfg, "CpuHotPlug", fCpuHotPlug);
3070
3071	InsertConfigInteger(pCfg, "Serial0IoPortBase", auSerialIoPortBase[0]);
3072	InsertConfigInteger(pCfg, "Serial0Irq", auSerialIrq[0]);
3073
3074	InsertConfigInteger(pCfg, "Serial1IoPortBase", auSerialIoPortBase[1]);
3075	InsertConfigInteger(pCfg, "Serial1Irq", auSerialIrq[1]);
3076
3077	InsertConfigNode(pInst, "LUN#0", &pLunL0);
3078	InsertConfigString(pLunL0, "Driver", "ACPIHost");
3079	InsertConfigNode(pLunL0, "Config", &pCfg);
3080
3081	/* Attach the dummy CPU drivers */
3082	for (ULONG iCpuCurr = 1; iCpuCurr < cCpus; iCpuCurr++)
3083	{
3084	BOOL fCpuAttached = true;
3085
3086	if (fCpuHotPlug)
3087	{
3088	hrc = pMachine->GetCPUStatus(iCpuCurr, &fCpuAttached); H();
3089	}
3090
3091	if (fCpuAttached)
3092	{
3093	InsertConfigNode(pInst, Utf8StrFmt("LUN#%u", iCpuCurr).c_str(), &pLunL0);
3094	InsertConfigString(pLunL0, "Driver", "ACPICpu");
3095	InsertConfigNode(pLunL0, "Config", &pCfg);
3096	}
3097	}
3098	}
3099
3100	/*
3101	* Configure DBGF (Debug(ger) Facility).
3102	*/
3103	{
3104	PCFGMNODE pDbgf;
3105	InsertConfigNode(pRoot, "DBGF", &pDbgf);
3106
3107	/* Paths to search for debug info and such things. */
3108	hrc = pMachine->COMGETTER(SettingsFilePath)(bstr.asOutParam()); H();
3109	Utf8Str strSettingsPath(bstr);
3110	bstr.setNull();
3111	strSettingsPath.stripFilename();
3112
3113	char szHomeDir[RTPATH_MAX];
3114	rc = RTPathUserHome(szHomeDir, sizeof(szHomeDir));
3115	if (RT_FAILURE(rc))
3116	szHomeDir[0] = '\0';
3117
3118	Utf8Str strPath;
3119	strPath.append(strSettingsPath).append("/debug/;");
3120	strPath.append(strSettingsPath).append("/;");
3121	strPath.append(szHomeDir).append("/");
3122
3123	InsertConfigString(pDbgf, "Path", strPath.c_str());
3124
3125	/* Tracing configuration. */
3126	BOOL fTracingEnabled;
3127	hrc = pMachine->COMGETTER(TracingEnabled)(&fTracingEnabled); H();
3128	if (fTracingEnabled)
3129	InsertConfigInteger(pDbgf, "TracingEnabled", 1);
3130
3131	hrc = pMachine->COMGETTER(TracingConfig)(bstr.asOutParam()); H();
3132	if (fTracingEnabled)
3133	InsertConfigString(pDbgf, "TracingConfig", bstr);
3134
3135	BOOL fAllowTracingToAccessVM;
3136	hrc = pMachine->COMGETTER(AllowTracingToAccessVM)(&fAllowTracingToAccessVM); H();
3137	if (fAllowTracingToAccessVM)
3138	InsertConfigInteger(pPDM, "AllowTracingToAccessVM", 1);
3139	}
3140	}
3141	catch (ConfigError &x)
3142	{
3143	// InsertConfig threw something:
3144	return x.m_vrc;
3145	}
3146	catch (HRESULT hrcXcpt)
3147	{
3148	AssertLogRelMsgFailedReturn(("hrc=%Rhrc\n", hrcXcpt), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR);
3149	}
3150
3151	#ifdef VBOX_WITH_EXTPACK
3152	/*
3153	* Call the extension pack hooks if everything went well thus far.
3154	*/
3155	if (RT_SUCCESS(rc))
3156	{
3157	pAlock->release();
3158	rc = mptrExtPackManager->i_callAllVmConfigureVmmHooks(this, pVM);
3159	pAlock->acquire();
3160	}
3161	#endif
3162
3163	/*
3164	* Apply the CFGM overlay.
3165	*/
3166	if (RT_SUCCESS(rc))
3167	rc = i_configCfgmOverlay(pRoot, virtualBox, pMachine);
3168
3169	/*
3170	* Dump all extradata API settings tweaks, both global and per VM.
3171	*/
3172	if (RT_SUCCESS(rc))
3173	rc = i_configDumpAPISettingsTweaks(virtualBox, pMachine);
3174
3175	#undef H
3176
3177	pAlock->release(); /* Avoid triggering the lock order inversion check. */
3178
3179	/*
3180	* Register VM state change handler.
3181	*/
3182	int rc2 = VMR3AtStateRegister(pUVM, Console::i_vmstateChangeCallback, this);
3183	AssertRC(rc2);
3184	if (RT_SUCCESS(rc))
3185	rc = rc2;
3186
3187	/*
3188	* Register VM runtime error handler.
3189	*/
3190	rc2 = VMR3AtRuntimeErrorRegister(pUVM, Console::i_setVMRuntimeErrorCallback, this);
3191	AssertRC(rc2);
3192	if (RT_SUCCESS(rc))
3193	rc = rc2;
3194
3195	pAlock->acquire();
3196
3197	LogFlowFunc(("vrc = %Rrc\n", rc));
3198	LogFlowFuncLeave();
3199
3200	return rc;
3201	}
3202
3203	/**
3204	* Applies the CFGM overlay as specified by VBoxInternal/XXX extra data
3205	* values.
3206	*
3207	* @returns VBox status code.
3208	* @param pRoot The root of the configuration tree.
3209	* @param pVirtualBox Pointer to the IVirtualBox interface.
3210	* @param pMachine Pointer to the IMachine interface.
3211	*/
3212	/* static */
3213	int Console::i_configCfgmOverlay(PCFGMNODE pRoot, IVirtualBox pVirtualBox, IMachine pMachine)
3214	{
3215	/*
3216	* CFGM overlay handling.
3217	*
3218	* Here we check the extra data entries for CFGM values
3219	* and create the nodes and insert the values on the fly. Existing
3220	* values will be removed and reinserted. CFGM is typed, so by default
3221	* we will guess whether it's a string or an integer (byte arrays are
3222	* not currently supported). It's possible to override this autodetection
3223	* by adding "string:", "integer:" or "bytes:" (future).
3224	*
3225	* We first perform a run on global extra data, then on the machine
3226	* extra data to support global settings with local overrides.
3227	*/
3228	int rc = VINF_SUCCESS;
3229	try
3230	{
3231	/** @todo add support for removing nodes and byte blobs. */
3232	/*
3233	* Get the next key
3234	*/
3235	SafeArray<BSTR> aGlobalExtraDataKeys;
3236	SafeArray<BSTR> aMachineExtraDataKeys;
3237	HRESULT hrc = pVirtualBox->GetExtraDataKeys(ComSafeArrayAsOutParam(aGlobalExtraDataKeys));
3238	AssertMsg(SUCCEEDED(hrc), ("VirtualBox::GetExtraDataKeys failed with %Rhrc\n", hrc));
3239
3240	// remember the no. of global values so we can call the correct method below
3241	size_t cGlobalValues = aGlobalExtraDataKeys.size();
3242
3243	hrc = pMachine->GetExtraDataKeys(ComSafeArrayAsOutParam(aMachineExtraDataKeys));
3244	AssertMsg(SUCCEEDED(hrc), ("Machine::GetExtraDataKeys failed with %Rhrc\n", hrc));
3245
3246	// build a combined list from global keys...
3247	std::list<Utf8Str> llExtraDataKeys;
3248
3249	for (size_t i = 0; i < aGlobalExtraDataKeys.size(); ++i)
3250	llExtraDataKeys.push_back(Utf8Str(aGlobalExtraDataKeys[i]));
3251	// ... and machine keys
3252	for (size_t i = 0; i < aMachineExtraDataKeys.size(); ++i)
3253	llExtraDataKeys.push_back(Utf8Str(aMachineExtraDataKeys[i]));
3254
3255	size_t i2 = 0;
3256	for (std::list<Utf8Str>::const_iterator it = llExtraDataKeys.begin();
3257	it != llExtraDataKeys.end();
3258	++it, ++i2)
3259	{
3260	const Utf8Str &strKey = *it;
3261
3262	/*
3263	* We only care about keys starting with "VBoxInternal/" (skip "G:" or "M:")
3264	*/
3265	if (!strKey.startsWith("VBoxInternal/"))
3266	continue;
3267
3268	const char *pszExtraDataKey = strKey.c_str() + sizeof("VBoxInternal/") - 1;
3269
3270	// get the value
3271	Bstr bstrExtraDataValue;
3272	if (i2 < cGlobalValues)
3273	// this is still one of the global values:
3274	hrc = pVirtualBox->GetExtraData(Bstr(strKey).raw(),
3275	bstrExtraDataValue.asOutParam());
3276	else
3277	hrc = pMachine->GetExtraData(Bstr(strKey).raw(),
3278	bstrExtraDataValue.asOutParam());
3279	if (FAILED(hrc))
3280	LogRel(("Warning: Cannot get extra data key %s, rc = %Rhrc\n", strKey.c_str(), hrc));
3281
3282	/*
3283	* The key will be in the format "Node1/Node2/Value" or simply "Value".
3284	* Split the two and get the node, delete the value and create the node
3285	* if necessary.
3286	*/
3287	PCFGMNODE pNode;
3288	const char *pszCFGMValueName = strrchr(pszExtraDataKey, '/');
3289	if (pszCFGMValueName)
3290	{
3291	/* terminate the node and advance to the value (Utf8Str might not
3292	offically like this but wtf) */
3293	(char)pszCFGMValueName = '\0';
3294	++pszCFGMValueName;
3295
3296	/* does the node already exist? */
3297	pNode = CFGMR3GetChild(pRoot, pszExtraDataKey);
3298	if (pNode)
3299	CFGMR3RemoveValue(pNode, pszCFGMValueName);
3300	else
3301	{
3302	/* create the node */
3303	rc = CFGMR3InsertNode(pRoot, pszExtraDataKey, &pNode);
3304	if (RT_FAILURE(rc))
3305	{
3306	AssertLogRelMsgRC(rc, ("failed to insert node '%s'\n", pszExtraDataKey));
3307	continue;
3308	}
3309	Assert(pNode);
3310	}
3311	}
3312	else
3313	{
3314	/* root value (no node path). */
3315	pNode = pRoot;
3316	pszCFGMValueName = pszExtraDataKey;
3317	pszExtraDataKey--;
3318	CFGMR3RemoveValue(pNode, pszCFGMValueName);
3319	}
3320
3321	/*
3322	* Now let's have a look at the value.
3323	* Empty strings means that we should remove the value, which we've
3324	* already done above.
3325	*/
3326	Utf8Str strCFGMValueUtf8(bstrExtraDataValue);
3327	if (!strCFGMValueUtf8.isEmpty())
3328	{
3329	uint64_t u64Value;
3330
3331	/* check for type prefix first. */
3332	if (!strncmp(strCFGMValueUtf8.c_str(), RT_STR_TUPLE("string:")))
3333	InsertConfigString(pNode, pszCFGMValueName, strCFGMValueUtf8.c_str() + sizeof("string:") - 1);
3334	else if (!strncmp(strCFGMValueUtf8.c_str(), RT_STR_TUPLE("integer:")))
3335	{
3336	rc = RTStrToUInt64Full(strCFGMValueUtf8.c_str() + sizeof("integer:") - 1, 0, &u64Value);
3337	if (RT_SUCCESS(rc))
3338	rc = CFGMR3InsertInteger(pNode, pszCFGMValueName, u64Value);
3339	}
3340	else if (!strncmp(strCFGMValueUtf8.c_str(), RT_STR_TUPLE("bytes:")))
3341	{
3342	char const *pszBase64 = strCFGMValueUtf8.c_str() + sizeof("bytes:") - 1;
3343	ssize_t cbValue = RTBase64DecodedSize(pszBase64, NULL);
3344	if (cbValue > 0)
3345	{
3346	void *pvBytes = RTMemTmpAlloc(cbValue);
3347	if (pvBytes)
3348	{
3349	rc = RTBase64Decode(pszBase64, pvBytes, cbValue, NULL, NULL);
3350	if (RT_SUCCESS(rc))
3351	rc = CFGMR3InsertBytes(pNode, pszCFGMValueName, pvBytes, cbValue);
3352	RTMemTmpFree(pvBytes);
3353	}
3354	else
3355	rc = VERR_NO_TMP_MEMORY;
3356	}
3357	else if (cbValue == 0)
3358	rc = CFGMR3InsertBytes(pNode, pszCFGMValueName, NULL, 0);
3359	else
3360	rc = VERR_INVALID_BASE64_ENCODING;
3361	}
3362	/* auto detect type. */
3363	else if (RT_SUCCESS(RTStrToUInt64Full(strCFGMValueUtf8.c_str(), 0, &u64Value)))
3364	rc = CFGMR3InsertInteger(pNode, pszCFGMValueName, u64Value);
3365	else
3366	InsertConfigString(pNode, pszCFGMValueName, strCFGMValueUtf8);
3367	AssertLogRelMsgRCBreak(rc, ("failed to insert CFGM value '%s' to key '%s'\n",
3368	strCFGMValueUtf8.c_str(), pszExtraDataKey));
3369	}
3370	}
3371	}
3372	catch (ConfigError &x)
3373	{
3374	// InsertConfig threw something:
3375	return x.m_vrc;
3376	}
3377	return rc;
3378	}
3379
3380	/**
3381	* Dumps the API settings tweaks as specified by VBoxInternal2/XXX extra data
3382	* values.
3383	*
3384	* @returns VBox status code.
3385	* @param pVirtualBox Pointer to the IVirtualBox interface.
3386	* @param pMachine Pointer to the IMachine interface.
3387	*/
3388	/* static */
3389	int Console::i_configDumpAPISettingsTweaks(IVirtualBox pVirtualBox, IMachine pMachine)
3390	{
3391	{
3392	SafeArray<BSTR> aGlobalExtraDataKeys;
3393	HRESULT hrc = pVirtualBox->GetExtraDataKeys(ComSafeArrayAsOutParam(aGlobalExtraDataKeys));
3394	AssertMsg(SUCCEEDED(hrc), ("VirtualBox::GetExtraDataKeys failed with %Rhrc\n", hrc));
3395	bool hasKey = false;
3396	for (size_t i = 0; i < aGlobalExtraDataKeys.size(); i++)
3397	{
3398	Utf8Str strKey(aGlobalExtraDataKeys[i]);
3399	if (!strKey.startsWith("VBoxInternal2/"))
3400	continue;
3401
3402	Bstr bstrValue;
3403	hrc = pVirtualBox->GetExtraData(Bstr(strKey).raw(),
3404	bstrValue.asOutParam());
3405	if (FAILED(hrc))
3406	continue;
3407	if (!hasKey)
3408	LogRel(("Global extradata API settings:\n"));
3409	LogRel((" %s=\"%ls\"\n", strKey.c_str(), bstrValue.raw()));
3410	hasKey = true;
3411	}
3412	}
3413
3414	{
3415	SafeArray<BSTR> aMachineExtraDataKeys;
3416	HRESULT hrc = pMachine->GetExtraDataKeys(ComSafeArrayAsOutParam(aMachineExtraDataKeys));
3417	AssertMsg(SUCCEEDED(hrc), ("Machine::GetExtraDataKeys failed with %Rhrc\n", hrc));
3418	bool hasKey = false;
3419	for (size_t i = 0; i < aMachineExtraDataKeys.size(); i++)
3420	{
3421	Utf8Str strKey(aMachineExtraDataKeys[i]);
3422	if (!strKey.startsWith("VBoxInternal2/"))
3423	continue;
3424
3425	Bstr bstrValue;
3426	hrc = pMachine->GetExtraData(Bstr(strKey).raw(),
3427	bstrValue.asOutParam());
3428	if (FAILED(hrc))
3429	continue;
3430	if (!hasKey)
3431	LogRel(("Per-VM extradata API settings:\n"));
3432	LogRel((" %s=\"%ls\"\n", strKey.c_str(), bstrValue.raw()));
3433	hasKey = true;
3434	}
3435	}
3436
3437	return VINF_SUCCESS;
3438	}
3439
3440	int Console::i_configGraphicsController(PCFGMNODE pDevices,
3441	const GraphicsControllerType_T enmGraphicsController,
3442	BusAssignmentManager *pBusMgr,
3443	const ComPtr<IMachine> &ptrMachine,
3444	const ComPtr<IBIOSSettings> &ptrBiosSettings,
3445	bool fHMEnabled)
3446	{
3447	// InsertConfig* throws
3448	try
3449	{
3450	PCFGMNODE pDev, pInst, pCfg, pLunL0;
3451	HRESULT hrc;
3452	Bstr bstr;
3453	const char *pcszDevice = "vga";
3454
3455	#define H() AssertLogRelMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR)
3456	InsertConfigNode(pDevices, pcszDevice, &pDev);
3457	InsertConfigNode(pDev, "0", &pInst);
3458	InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
3459
3460	hrc = pBusMgr->assignPCIDevice(pcszDevice, pInst); H();
3461	InsertConfigNode(pInst, "Config", &pCfg);
3462	ULONG cVRamMBs;
3463	hrc = ptrMachine->COMGETTER(VRAMSize)(&cVRamMBs); H();
3464	InsertConfigInteger(pCfg, "VRamSize", cVRamMBs * _1M);
3465	ULONG cMonitorCount;
3466	hrc = ptrMachine->COMGETTER(MonitorCount)(&cMonitorCount); H();
3467	InsertConfigInteger(pCfg, "MonitorCount", cMonitorCount);
3468	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
3469	InsertConfigInteger(pCfg, "R0Enabled", fHMEnabled);
3470	#else
3471	NOREF(fHMEnabled);
3472	#endif
3473
3474	i_attachStatusDriver(pInst, &mapCrOglLed, 0, 0, NULL, NULL, 0);
3475
3476	#ifdef VBOX_WITH_VMSVGA
3477	if (enmGraphicsController == GraphicsControllerType_VMSVGA)
3478	{
3479	InsertConfigInteger(pCfg, "VMSVGAEnabled", true);
3480	#ifdef VBOX_WITH_VMSVGA3D
3481	IFramebuffer *pFramebuffer = NULL;
3482	hrc = i_getDisplay()->QueryFramebuffer(0, &pFramebuffer);
3483	if (SUCCEEDED(hrc) && pFramebuffer)
3484	{
3485	LONG64 winId = 0;
3486	/* @todo deal with multimonitor setup */
3487	Assert(cMonitorCount == 1);
3488	hrc = pFramebuffer->COMGETTER(WinId)(&winId);
3489	InsertConfigInteger(pCfg, "HostWindowId", winId);
3490	pFramebuffer->Release();
3491	}
3492	BOOL f3DEnabled;
3493	hrc = ptrMachine->COMGETTER(Accelerate3DEnabled)(&f3DEnabled); H();
3494	InsertConfigInteger(pCfg, "VMSVGA3dEnabled", f3DEnabled);
3495	#endif
3496	}
3497	#endif
3498
3499	/* Custom VESA mode list */
3500	unsigned cModes = 0;
3501	for (unsigned iMode = 1; iMode <= 16; ++iMode)
3502	{
3503	char szExtraDataKey[sizeof("CustomVideoModeXX")];
3504	RTStrPrintf(szExtraDataKey, sizeof(szExtraDataKey), "CustomVideoMode%u", iMode);
3505	hrc = ptrMachine->GetExtraData(Bstr(szExtraDataKey).raw(), bstr.asOutParam()); H();
3506	if (bstr.isEmpty())
3507	break;
3508	InsertConfigString(pCfg, szExtraDataKey, bstr);
3509	++cModes;
3510	}
3511	InsertConfigInteger(pCfg, "CustomVideoModes", cModes);
3512
3513	/* VESA height reduction */
3514	ULONG ulHeightReduction;
3515	IFramebuffer *pFramebuffer = NULL;
3516	hrc = i_getDisplay()->QueryFramebuffer(0, &pFramebuffer);
3517	if (SUCCEEDED(hrc) && pFramebuffer)
3518	{
3519	hrc = pFramebuffer->COMGETTER(HeightReduction)(&ulHeightReduction); H();
3520	pFramebuffer->Release();
3521	pFramebuffer = NULL;
3522	}
3523	else
3524	{
3525	/* If framebuffer is not available, there is no height reduction. */
3526	ulHeightReduction = 0;
3527	}
3528	InsertConfigInteger(pCfg, "HeightReduction", ulHeightReduction);
3529
3530	/*
3531	* BIOS logo
3532	*/
3533	BOOL fFadeIn;
3534	hrc = ptrBiosSettings->COMGETTER(LogoFadeIn)(&fFadeIn); H();
3535	InsertConfigInteger(pCfg, "FadeIn", fFadeIn ? 1 : 0);
3536	BOOL fFadeOut;
3537	hrc = ptrBiosSettings->COMGETTER(LogoFadeOut)(&fFadeOut); H();
3538	InsertConfigInteger(pCfg, "FadeOut", fFadeOut ? 1: 0);
3539	ULONG logoDisplayTime;
3540	hrc = ptrBiosSettings->COMGETTER(LogoDisplayTime)(&logoDisplayTime); H();
3541	InsertConfigInteger(pCfg, "LogoTime", logoDisplayTime);
3542	Bstr logoImagePath;
3543	hrc = ptrBiosSettings->COMGETTER(LogoImagePath)(logoImagePath.asOutParam()); H();
3544	InsertConfigString(pCfg, "LogoFile", Utf8Str(!logoImagePath.isEmpty() ? logoImagePath : "") );
3545
3546	/*
3547	* Boot menu
3548	*/
3549	BIOSBootMenuMode_T eBootMenuMode;
3550	int iShowBootMenu;
3551	hrc = ptrBiosSettings->COMGETTER(BootMenuMode)(&eBootMenuMode); H();
3552	switch (eBootMenuMode)
3553	{
3554	case BIOSBootMenuMode_Disabled: iShowBootMenu = 0; break;
3555	case BIOSBootMenuMode_MenuOnly: iShowBootMenu = 1; break;
3556	default: iShowBootMenu = 2; break;
3557	}
3558	InsertConfigInteger(pCfg, "ShowBootMenu", iShowBootMenu);
3559
3560	/* Attach the display. */
3561	InsertConfigNode(pInst, "LUN#0", &pLunL0);
3562	InsertConfigString(pLunL0, "Driver", "MainDisplay");
3563	InsertConfigNode(pLunL0, "Config", &pCfg);
3564	Display *pDisplay = mDisplay;
3565	InsertConfigInteger(pCfg, "Object", (uintptr_t)pDisplay);
3566	}
3567	catch (ConfigError &x)
3568	{
3569	// InsertConfig threw something:
3570	return x.m_vrc;
3571	}
3572
3573	#undef H
3574
3575	return VINF_SUCCESS;
3576	}
3577
3578
3579	/**
3580	* Ellipsis to va_list wrapper for calling setVMRuntimeErrorCallback.
3581	*/
3582	void Console::i_setVMRuntimeErrorCallbackF(uint32_t fFlags, const char pszErrorId, const char pszFormat, ...)
3583	{
3584	va_list va;
3585	va_start(va, pszFormat);
3586	i_setVMRuntimeErrorCallback(NULL, this, fFlags, pszErrorId, pszFormat, va);
3587	va_end(va);
3588	}
3589
3590	/* XXX introduce RT format specifier */
3591	static uint64_t formatDiskSize(uint64_t u64Size, const char **pszUnit)
3592	{
3593	if (u64Size > INT64_C(5000)*_1G)
3594	{
3595	*pszUnit = "TB";
3596	return u64Size / _1T;
3597	}
3598	else if (u64Size > INT64_C(5000)*_1M)
3599	{
3600	*pszUnit = "GB";
3601	return u64Size / _1G;
3602	}
3603	else
3604	{
3605	*pszUnit = "MB";
3606	return u64Size / _1M;
3607	}
3608	}
3609
3610	int Console::i_configMediumAttachment(const char *pcszDevice,
3611	unsigned uInstance,
3612	StorageBus_T enmBus,
3613	bool fUseHostIOCache,
3614	bool fBuiltinIOCache,
3615	bool fSetupMerge,
3616	unsigned uMergeSource,
3617	unsigned uMergeTarget,
3618	IMediumAttachment *pMediumAtt,
3619	MachineState_T aMachineState,
3620	HRESULT *phrc,
3621	bool fAttachDetach,
3622	bool fForceUnmount,
3623	bool fHotplug,
3624	PUVM pUVM,
3625	DeviceType_T *paLedDevType,
3626	PCFGMNODE *ppLunL0)
3627	{
3628	// InsertConfig* throws
3629	try
3630	{
3631	int rc = VINF_SUCCESS;
3632	HRESULT hrc;
3633	Bstr bstr;
3634	PCFGMNODE pCtlInst = NULL;
3635
3636	// #define RC_CHECK() AssertMsgReturn(RT_SUCCESS(rc), ("rc=%Rrc\n", rc), rc)
3637	#define H() AssertLogRelMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR)
3638
3639	LONG lDev;
3640	hrc = pMediumAtt->COMGETTER(Device)(&lDev); H();
3641	LONG lPort;
3642	hrc = pMediumAtt->COMGETTER(Port)(&lPort); H();
3643	DeviceType_T lType;
3644	hrc = pMediumAtt->COMGETTER(Type)(&lType); H();
3645	BOOL fNonRotational;
3646	hrc = pMediumAtt->COMGETTER(NonRotational)(&fNonRotational); H();
3647	BOOL fDiscard;
3648	hrc = pMediumAtt->COMGETTER(Discard)(&fDiscard); H();
3649
3650	unsigned uLUN;
3651	PCFGMNODE pLunL0 = NULL;
3652	hrc = Console::i_convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN); H();
3653
3654	/* Determine the base path for the device instance. */
3655	if (enmBus != StorageBus_USB)
3656	pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%u/", pcszDevice, uInstance);
3657	else
3658	{
3659	/* If we hotplug a USB device create a new CFGM tree. */
3660	if (!fHotplug)
3661	pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "USB/%s/", pcszDevice, uInstance);
3662	else
3663	pCtlInst = CFGMR3CreateTree(pUVM);
3664	}
3665	AssertReturn(pCtlInst, VERR_INTERNAL_ERROR);
3666
3667	if (enmBus == StorageBus_USB)
3668	{
3669	PCFGMNODE pCfg = NULL;
3670
3671	/* Create correct instance. */
3672	if (!fHotplug)
3673	{
3674	if (!fAttachDetach)
3675	InsertConfigNode(pCtlInst, Utf8StrFmt("%d", lPort).c_str(), &pCtlInst);
3676	else
3677	pCtlInst = CFGMR3GetChildF(pCtlInst, "%d/", lPort);
3678	}
3679
3680	if (!fAttachDetach)
3681	InsertConfigNode(pCtlInst, "Config", &pCfg);
3682
3683	uInstance = lPort; /* Overwrite uInstance with the correct one. */
3684
3685	if (!fHotplug && !fAttachDetach)
3686	{
3687	char aszUuid[RTUUID_STR_LENGTH + 1];
3688	USBStorageDevice UsbMsd = USBStorageDevice();
3689
3690	memset(aszUuid, 0, sizeof(aszUuid));
3691	rc = RTUuidCreate(&UsbMsd.mUuid);
3692	AssertRCReturn(rc, rc);
3693	rc = RTUuidToStr(&UsbMsd.mUuid, aszUuid, sizeof(aszUuid));
3694	AssertRCReturn(rc, rc);
3695
3696	UsbMsd.iPort = uInstance;
3697
3698	InsertConfigString(pCtlInst, "UUID", aszUuid);
3699	mUSBStorageDevices.push_back(UsbMsd);
3700
3701	/** @todo: No LED after hotplugging. */
3702	/* Attach the status driver */
3703	Assert(cLedUsb >= 8);
3704	i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedUsb], 0, 7,
3705	&mapMediumAttachments, pcszDevice, 0);
3706	paLedDevType = &maStorageDevType[iLedUsb];
3707	}
3708	}
3709
3710	/* First check if the LUN already exists. */
3711	pLunL0 = CFGMR3GetChildF(pCtlInst, "LUN#%u", uLUN);
3712	if (pLunL0)
3713	{
3714	if (fAttachDetach)
3715	{
3716	if (lType != DeviceType_HardDisk)
3717	{
3718	/* Unmount existing media only for floppy and DVD drives. */
3719	PPDMIBASE pBase;
3720	if (enmBus == StorageBus_USB)
3721	rc = PDMR3UsbQueryLun(pUVM, pcszDevice, uInstance, uLUN, &pBase);
3722	else
3723	rc = PDMR3QueryLun(pUVM, pcszDevice, uInstance, uLUN, &pBase);
3724	if (RT_FAILURE(rc))
3725	{
3726	if (rc == VERR_PDM_LUN_NOT_FOUND \|\| rc == VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN)
3727	rc = VINF_SUCCESS;
3728	AssertRC(rc);
3729	}
3730	else
3731	{
3732	PPDMIMOUNT pIMount = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMOUNT);
3733	AssertReturn(pIMount, VERR_INVALID_POINTER);
3734
3735	/* Unmount the media (but do not eject the medium!) */
3736	rc = pIMount->pfnUnmount(pIMount, fForceUnmount, false /=fEject/);
3737	if (rc == VERR_PDM_MEDIA_NOT_MOUNTED)
3738	rc = VINF_SUCCESS;
3739	/* for example if the medium is locked */
3740	else if (RT_FAILURE(rc))
3741	return rc;
3742	}
3743	}
3744
3745	if (enmBus == StorageBus_USB)
3746	rc = PDMR3UsbDriverDetach(pUVM, pcszDevice, uInstance, uLUN, NULL, 0,
3747	fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG);
3748	else
3749	rc = PDMR3DeviceDetach(pUVM, pcszDevice, uInstance, uLUN, fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG);
3750	if (rc == VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN)
3751	rc = VINF_SUCCESS;
3752	AssertRCReturn(rc, rc);
3753
3754	CFGMR3RemoveNode(pLunL0);
3755	}
3756	else
3757	AssertFailedReturn(VERR_INTERNAL_ERROR);
3758	}
3759
3760	InsertConfigNode(pCtlInst, Utf8StrFmt("LUN#%u", uLUN).c_str(), &pLunL0);
3761	if (ppLunL0)
3762	*ppLunL0 = pLunL0;
3763
3764	PCFGMNODE pCfg = CFGMR3GetChild(pCtlInst, "Config");
3765	if (pCfg)
3766	{
3767	if (!strcmp(pcszDevice, "piix3ide"))
3768	{
3769	PCFGMNODE pDrive = CFGMR3GetChild(pCfg, g_apszIDEDrives[uLUN]);
3770	if (!pDrive)
3771	InsertConfigNode(pCfg, g_apszIDEDrives[uLUN], &pDrive);
3772	/* Don't use the RemoveConfigValue wrapper above, as we don't
3773	* know if the leaf is present or not. */
3774	CFGMR3RemoveValue(pDrive, "NonRotationalMedium");
3775	InsertConfigInteger(pDrive, "NonRotationalMedium", !!fNonRotational);
3776	}
3777	else if (!strcmp(pcszDevice, "ahci"))
3778	{
3779	Utf8Str strPort = Utf8StrFmt("Port%u", uLUN);
3780	PCFGMNODE pDrive = CFGMR3GetChild(pCfg, strPort.c_str());
3781	if (!pDrive)
3782	InsertConfigNode(pCfg, strPort.c_str(), &pDrive);
3783	/* Don't use the RemoveConfigValue wrapper above, as we don't
3784	* know if the leaf is present or not. */
3785	CFGMR3RemoveValue(pDrive, "NonRotationalMedium");
3786	InsertConfigInteger(pDrive, "NonRotationalMedium", !!fNonRotational);
3787	}
3788	}
3789
3790	Utf8Str devicePath = Utf8StrFmt("%s/%u/LUN#%u", pcszDevice, uInstance, uLUN);
3791	mapMediumAttachments[devicePath] = pMediumAtt;
3792
3793	/* SCSI has a another driver between device and block. */
3794	if (enmBus == StorageBus_SCSI \|\| enmBus == StorageBus_SAS \|\| enmBus == StorageBus_USB)
3795	{
3796	InsertConfigString(pLunL0, "Driver", "SCSI");
3797	PCFGMNODE pL1Cfg = NULL;
3798	InsertConfigNode(pLunL0, "Config", &pL1Cfg);
3799	InsertConfigInteger(pL1Cfg, "NonRotationalMedium", !!fNonRotational);
3800
3801	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL0);
3802	}
3803
3804	ComPtr<IMedium> pMedium;
3805	hrc = pMediumAtt->COMGETTER(Medium)(pMedium.asOutParam()); H();
3806
3807	/*
3808	* 1. Only check this for hard disk images.
3809	* 2. Only check during VM creation and not later, especially not during
3810	* taking an online snapshot!
3811	*/
3812	if ( lType == DeviceType_HardDisk
3813	&& ( aMachineState == MachineState_Starting
3814	\|\| aMachineState == MachineState_Restoring))
3815	{
3816	/*
3817	* Some sanity checks.
3818	*/
3819	ComPtr<IMediumFormat> pMediumFormat;
3820	hrc = pMedium->COMGETTER(MediumFormat)(pMediumFormat.asOutParam()); H();
3821	ULONG uCaps = 0;
3822	com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
3823	hrc = pMediumFormat->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap)); H();
3824
3825	for (ULONG j = 0; j < mediumFormatCap.size(); j++)
3826	uCaps \|= mediumFormatCap[j];
3827
3828	if (uCaps & MediumFormatCapabilities_File)
3829	{
3830	Bstr strFile;
3831	hrc = pMedium->COMGETTER(Location)(strFile.asOutParam()); H();
3832	Utf8Str utfFile = Utf8Str(strFile);
3833	Bstr strSnap;
3834	ComPtr<IMachine> pMachine = i_machine();
3835	hrc = pMachine->COMGETTER(SnapshotFolder)(strSnap.asOutParam()); H();
3836	Utf8Str utfSnap = Utf8Str(strSnap);
3837	RTFSTYPE enmFsTypeFile = RTFSTYPE_UNKNOWN;
3838	RTFSTYPE enmFsTypeSnap = RTFSTYPE_UNKNOWN;
3839	int rc2 = RTFsQueryType(utfFile.c_str(), &enmFsTypeFile);
3840	AssertMsgRCReturn(rc2, ("Querying the file type of '%s' failed!\n", utfFile.c_str()), rc2);
3841	/* Ignore the error code. On error, the file system type is still 'unknown' so
3842	* none of the following paths are taken. This can happen for new VMs which
3843	* still don't have a snapshot folder. */
3844	(void)RTFsQueryType(utfSnap.c_str(), &enmFsTypeSnap);
3845	if (!mfSnapshotFolderDiskTypeShown)
3846	{
3847	LogRel(("File system of '%s' (snapshots) is %s\n",
3848	utfSnap.c_str(), RTFsTypeName(enmFsTypeSnap)));
3849	mfSnapshotFolderDiskTypeShown = true;
3850	}
3851	LogRel(("File system of '%s' is %s\n", utfFile.c_str(), RTFsTypeName(enmFsTypeFile)));
3852	LONG64 i64Size;
3853	hrc = pMedium->COMGETTER(LogicalSize)(&i64Size); H();
3854	#ifdef RT_OS_WINDOWS
3855	if ( enmFsTypeFile == RTFSTYPE_FAT
3856	&& i64Size >= _4G)
3857	{
3858	const char *pszUnit;
3859	uint64_t u64Print = formatDiskSize((uint64_t)i64Size, &pszUnit);
3860	i_setVMRuntimeErrorCallbackF(0, "FatPartitionDetected",
3861	N_("The medium '%ls' has a logical size of %RU64%s "
3862	"but the file system the medium is located on seems "
3863	"to be FAT(32) which cannot handle files bigger than 4GB.\n"
3864	"We strongly recommend to put all your virtual disk images and "
3865	"the snapshot folder onto an NTFS partition"),
3866	strFile.raw(), u64Print, pszUnit);
3867	}
3868	#else /* !RT_OS_WINDOWS */
3869	if ( enmFsTypeFile == RTFSTYPE_FAT
3870	\|\| enmFsTypeFile == RTFSTYPE_EXT
3871	\|\| enmFsTypeFile == RTFSTYPE_EXT2
3872	\|\| enmFsTypeFile == RTFSTYPE_EXT3
3873	\|\| enmFsTypeFile == RTFSTYPE_EXT4)
3874	{
3875	RTFILE file;
3876	rc = RTFileOpen(&file, utfFile.c_str(), RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
3877	if (RT_SUCCESS(rc))
3878	{
3879	RTFOFF maxSize;
3880	/* Careful: This function will work only on selected local file systems! */
3881	rc = RTFileGetMaxSizeEx(file, &maxSize);
3882	RTFileClose(file);
3883	if ( RT_SUCCESS(rc)
3884	&& maxSize > 0
3885	&& i64Size > (LONG64)maxSize)
3886	{
3887	const char *pszUnitSiz;
3888	const char *pszUnitMax;
3889	uint64_t u64PrintSiz = formatDiskSize((LONG64)i64Size, &pszUnitSiz);
3890	uint64_t u64PrintMax = formatDiskSize(maxSize, &pszUnitMax);
3891	i_setVMRuntimeErrorCallbackF(0, "FatPartitionDetected", /* <= not exact but ... */
3892	N_("The medium '%ls' has a logical size of %RU64%s "
3893	"but the file system the medium is located on can "
3894	"only handle files up to %RU64%s in theory.\n"
3895	"We strongly recommend to put all your virtual disk "
3896	"images and the snapshot folder onto a proper "
3897	"file system (e.g. ext3) with a sufficient size"),
3898	strFile.raw(), u64PrintSiz, pszUnitSiz, u64PrintMax, pszUnitMax);
3899	}
3900	}
3901	}
3902	#endif /* !RT_OS_WINDOWS */
3903
3904	/*
3905	* Snapshot folder:
3906	* Here we test only for a FAT partition as we had to create a dummy file otherwise
3907	*/
3908	if ( enmFsTypeSnap == RTFSTYPE_FAT
3909	&& i64Size >= _4G
3910	&& !mfSnapshotFolderSizeWarningShown)
3911	{
3912	const char *pszUnit;
3913	uint64_t u64Print = formatDiskSize(i64Size, &pszUnit);
3914	i_setVMRuntimeErrorCallbackF(0, "FatPartitionDetected",
3915	#ifdef RT_OS_WINDOWS
3916	N_("The snapshot folder of this VM '%ls' seems to be located on "
3917	"a FAT(32) file system. The logical size of the medium '%ls' "
3918	"(%RU64%s) is bigger than the maximum file size this file "
3919	"system can handle (4GB).\n"
3920	"We strongly recommend to put all your virtual disk images and "
3921	"the snapshot folder onto an NTFS partition"),
3922	#else
3923	N_("The snapshot folder of this VM '%ls' seems to be located on "
3924	"a FAT(32) file system. The logical size of the medium '%ls' "
3925	"(%RU64%s) is bigger than the maximum file size this file "
3926	"system can handle (4GB).\n"
3927	"We strongly recommend to put all your virtual disk images and "
3928	"the snapshot folder onto a proper file system (e.g. ext3)"),
3929	#endif
3930	strSnap.raw(), strFile.raw(), u64Print, pszUnit);
3931	/* Show this particular warning only once */
3932	mfSnapshotFolderSizeWarningShown = true;
3933	}
3934
3935	#ifdef RT_OS_LINUX
3936	/*
3937	* Ext4 bug: Check if the host I/O cache is disabled and the disk image is located
3938	* on an ext4 partition. Later we have to check the Linux kernel version!
3939	* This bug apparently applies to the XFS file system as well.
3940	* Linux 2.6.36 is known to be fixed (tested with 2.6.36-rc4).
3941	*/
3942
3943	char szOsRelease[128];
3944	rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szOsRelease, sizeof(szOsRelease));
3945	bool fKernelHasODirectBug = RT_FAILURE(rc)
3946	\|\| (RTStrVersionCompare(szOsRelease, "2.6.36-rc4") < 0);
3947
3948	if ( (uCaps & MediumFormatCapabilities_Asynchronous)
3949	&& !fUseHostIOCache
3950	&& fKernelHasODirectBug)
3951	{
3952	if ( enmFsTypeFile == RTFSTYPE_EXT4
3953	\|\| enmFsTypeFile == RTFSTYPE_XFS)
3954	{
3955	i_setVMRuntimeErrorCallbackF(0, "Ext4PartitionDetected",
3956	N_("The host I/O cache for at least one controller is disabled "
3957	"and the medium '%ls' for this VM "
3958	"is located on an %s partition. There is a known Linux "
3959	"kernel bug which can lead to the corruption of the virtual "
3960	"disk image under these conditions.\n"
3961	"Either enable the host I/O cache permanently in the VM "
3962	"settings or put the disk image and the snapshot folder "
3963	"onto a different file system.\n"
3964	"The host I/O cache will now be enabled for this medium"),
3965	strFile.raw(), enmFsTypeFile == RTFSTYPE_EXT4 ? "ext4" : "xfs");
3966	fUseHostIOCache = true;
3967	}
3968	else if ( ( enmFsTypeSnap == RTFSTYPE_EXT4
3969	\|\| enmFsTypeSnap == RTFSTYPE_XFS)
3970	&& !mfSnapshotFolderExt4WarningShown)
3971	{
3972	i_setVMRuntimeErrorCallbackF(0, "Ext4PartitionDetected",
3973	N_("The host I/O cache for at least one controller is disabled "
3974	"and the snapshot folder for this VM "
3975	"is located on an %s partition. There is a known Linux "
3976	"kernel bug which can lead to the corruption of the virtual "
3977	"disk image under these conditions.\n"
3978	"Either enable the host I/O cache permanently in the VM "
3979	"settings or put the disk image and the snapshot folder "
3980	"onto a different file system.\n"
3981	"The host I/O cache will now be enabled for this medium"),
3982	enmFsTypeSnap == RTFSTYPE_EXT4 ? "ext4" : "xfs");
3983	fUseHostIOCache = true;
3984	mfSnapshotFolderExt4WarningShown = true;
3985	}
3986	}
3987	#endif
3988	}
3989	}
3990
3991	if (pMedium)
3992	{
3993	BOOL fHostDrive;
3994	hrc = pMedium->COMGETTER(HostDrive)(&fHostDrive); H();
3995	if ( ( lType == DeviceType_DVD
3996	\|\| lType == DeviceType_Floppy)
3997	&& !fHostDrive)
3998	{
3999	/*
4000	* Informative logging.
4001	*/
4002	Bstr strFile;
4003	hrc = pMedium->COMGETTER(Location)(strFile.asOutParam()); H();
4004	Utf8Str utfFile = Utf8Str(strFile);
4005	RTFSTYPE enmFsTypeFile = RTFSTYPE_UNKNOWN;
4006	(void)RTFsQueryType(utfFile.c_str(), &enmFsTypeFile);
4007	LogRel(("File system of '%s' (%s) is %s\n",
4008	utfFile.c_str(), lType == DeviceType_DVD ? "DVD" : "Floppy",
4009	RTFsTypeName(enmFsTypeFile)));
4010	}
4011	}
4012
4013	BOOL fPassthrough;
4014	hrc = pMediumAtt->COMGETTER(Passthrough)(&fPassthrough); H();
4015
4016	ComObjPtr<IBandwidthGroup> pBwGroup;
4017	Bstr strBwGroup;
4018	hrc = pMediumAtt->COMGETTER(BandwidthGroup)(pBwGroup.asOutParam()); H();
4019
4020	if (!pBwGroup.isNull())
4021	{
4022	hrc = pBwGroup->COMGETTER(Name)(strBwGroup.asOutParam()); H();
4023	}
4024
4025	rc = i_configMedium(pLunL0,
4026	!!fPassthrough,
4027	lType,
4028	fUseHostIOCache,
4029	fBuiltinIOCache,
4030	fSetupMerge,
4031	uMergeSource,
4032	uMergeTarget,
4033	strBwGroup.isEmpty() ? NULL : Utf8Str(strBwGroup).c_str(),
4034	!!fDiscard,
4035	pMedium,
4036	aMachineState,
4037	phrc);
4038	if (RT_FAILURE(rc))
4039	return rc;
4040
4041	if (fAttachDetach)
4042	{
4043	/* Attach the new driver. */
4044	if (enmBus == StorageBus_USB)
4045	{
4046	if (fHotplug)
4047	{
4048	USBStorageDevice UsbMsd = USBStorageDevice();
4049	RTUuidCreate(&UsbMsd.mUuid);
4050	UsbMsd.iPort = uInstance;
4051	rc = PDMR3UsbCreateEmulatedDevice(pUVM, pcszDevice, pCtlInst, &UsbMsd.mUuid, NULL);
4052	if (RT_SUCCESS(rc))
4053	mUSBStorageDevices.push_back(UsbMsd);
4054	}
4055	else
4056	rc = PDMR3UsbDriverAttach(pUVM, pcszDevice, uInstance, uLUN,
4057	fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG, NULL /ppBase/);
4058	}
4059	else
4060	rc = PDMR3DeviceAttach(pUVM, pcszDevice, uInstance, uLUN,
4061	fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG, NULL /ppBase/);
4062	AssertRCReturn(rc, rc);
4063
4064	/*
4065	* Make the secret key helper interface known to the VD driver if it is attached,
4066	* so we can get notified about missing keys.
4067	*/
4068	PPDMIBASE pIBase = NULL;
4069	rc = PDMR3QueryDriverOnLun(pUVM, pcszDevice, uInstance, uLUN, "VD", &pIBase);
4070	if (RT_SUCCESS(rc) && pIBase)
4071	{
4072	PPDMIMEDIA pIMedium = (PPDMIMEDIA)pIBase->pfnQueryInterface(pIBase, PDMIMEDIA_IID);
4073	if (pIMedium)
4074	{
4075	rc = pIMedium->pfnSetSecKeyIf(pIMedium, mpIfSecKey, mpIfSecKeyHlp);
4076	Assert(RT_SUCCESS(rc) \|\| rc == VERR_NOT_SUPPORTED);
4077	}
4078	}
4079
4080	/* There is no need to handle removable medium mounting, as we
4081	* unconditionally replace everthing including the block driver level.
4082	* This means the new medium will be picked up automatically. */
4083	}
4084
4085	if (paLedDevType)
4086	paLedDevType[uLUN] = lType;
4087
4088	/* Dump the changed LUN if possible, dump the complete device otherwise */
4089	if ( aMachineState != MachineState_Starting
4090	&& aMachineState != MachineState_Restoring)
4091	CFGMR3Dump(pLunL0 ? pLunL0 : pCtlInst);
4092	}
4093	catch (ConfigError &x)
4094	{
4095	// InsertConfig threw something:
4096	return x.m_vrc;
4097	}
4098
4099	#undef H
4100
4101	return VINF_SUCCESS;
4102	}
4103
4104	int Console::i_configMedium(PCFGMNODE pLunL0,
4105	bool fPassthrough,
4106	DeviceType_T enmType,
4107	bool fUseHostIOCache,
4108	bool fBuiltinIOCache,
4109	bool fSetupMerge,
4110	unsigned uMergeSource,
4111	unsigned uMergeTarget,
4112	const char *pcszBwGroup,
4113	bool fDiscard,
4114	IMedium *pMedium,
4115	MachineState_T aMachineState,
4116	HRESULT *phrc)
4117	{
4118	// InsertConfig* throws
4119	try
4120	{
4121	int rc = VINF_SUCCESS;
4122	HRESULT hrc;
4123	Bstr bstr;
4124	PCFGMNODE pLunL1 = NULL;
4125	PCFGMNODE pCfg = NULL;
4126
4127	#define H() \
4128	AssertMsgReturnStmt(SUCCEEDED(hrc), ("hrc=%Rhrc\n", hrc), if (phrc) *phrc = hrc, Global::vboxStatusCodeFromCOM(hrc))
4129
4130
4131	BOOL fHostDrive = FALSE;
4132	MediumType_T mediumType = MediumType_Normal;
4133	if (pMedium)
4134	{
4135	hrc = pMedium->COMGETTER(HostDrive)(&fHostDrive); H();
4136	hrc = pMedium->COMGETTER(Type)(&mediumType); H();
4137	}
4138
4139	if (fHostDrive)
4140	{
4141	Assert(pMedium);
4142	if (enmType == DeviceType_DVD)
4143	{
4144	InsertConfigString(pLunL0, "Driver", "HostDVD");
4145	InsertConfigNode(pLunL0, "Config", &pCfg);
4146
4147	hrc = pMedium->COMGETTER(Location)(bstr.asOutParam()); H();
4148	InsertConfigString(pCfg, "Path", bstr);
4149
4150	InsertConfigInteger(pCfg, "Passthrough", fPassthrough);
4151	}
4152	else if (enmType == DeviceType_Floppy)
4153	{
4154	InsertConfigString(pLunL0, "Driver", "HostFloppy");
4155	InsertConfigNode(pLunL0, "Config", &pCfg);
4156
4157	hrc = pMedium->COMGETTER(Location)(bstr.asOutParam()); H();
4158	InsertConfigString(pCfg, "Path", bstr);
4159	}
4160	}
4161	else
4162	{
4163	InsertConfigString(pLunL0, "Driver", "Block");
4164	InsertConfigNode(pLunL0, "Config", &pCfg);
4165	switch (enmType)
4166	{
4167	case DeviceType_DVD:
4168	InsertConfigString(pCfg, "Type", "DVD");
4169	InsertConfigInteger(pCfg, "Mountable", 1);
4170	break;
4171	case DeviceType_Floppy:
4172	InsertConfigString(pCfg, "Type", "Floppy 1.44");
4173	InsertConfigInteger(pCfg, "Mountable", 1);
4174	break;
4175	case DeviceType_HardDisk:
4176	default:
4177	InsertConfigString(pCfg, "Type", "HardDisk");
4178	InsertConfigInteger(pCfg, "Mountable", 0);
4179	}
4180
4181	if ( pMedium
4182	&& ( enmType == DeviceType_DVD
4183	\|\| enmType == DeviceType_Floppy)
4184	)
4185	{
4186	// if this medium represents an ISO image and this image is inaccessible,
4187	// the ignore it instead of causing a failure; this can happen when we
4188	// restore a VM state and the ISO has disappeared, e.g. because the Guest
4189	// Additions were mounted and the user upgraded VirtualBox. Previously
4190	// we failed on startup, but that's not good because the only way out then
4191	// would be to discard the VM state...
4192	MediumState_T mediumState;
4193	hrc = pMedium->RefreshState(&mediumState); H();
4194	if (mediumState == MediumState_Inaccessible)
4195	{
4196	Bstr loc;
4197	hrc = pMedium->COMGETTER(Location)(loc.asOutParam()); H();
4198	i_setVMRuntimeErrorCallbackF(0, "DvdOrFloppyImageInaccessible",
4199	"The image file '%ls' is inaccessible and is being ignored. "
4200	"Please select a different image file for the virtual %s drive.",
4201	loc.raw(),
4202	enmType == DeviceType_DVD ? "DVD" : "floppy");
4203	pMedium = NULL;
4204	}
4205	}
4206
4207	if (pMedium)
4208	{
4209	/* Start with length of parent chain, as the list is reversed */
4210	unsigned uImage = 0;
4211	IMedium *pTmp = pMedium;
4212	while (pTmp)
4213	{
4214	uImage++;
4215	hrc = pTmp->COMGETTER(Parent)(&pTmp); H();
4216	}
4217	/* Index of last image */
4218	uImage--;
4219
4220	#if 0 /* Enable for I/O debugging */
4221	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL0);
4222	InsertConfigString(pLunL0, "Driver", "DiskIntegrity");
4223	InsertConfigNode(pLunL0, "Config", &pCfg);
4224	InsertConfigInteger(pCfg, "CheckConsistency", 0);
4225	InsertConfigInteger(pCfg, "CheckDoubleCompletions", 1);
4226	#endif
4227
4228	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL1);
4229	InsertConfigString(pLunL1, "Driver", "VD");
4230	InsertConfigNode(pLunL1, "Config", &pCfg);
4231
4232	# ifdef VBOX_WITH_EXTPACK
4233	static const Utf8Str strExtPackPuel("Oracle VM VirtualBox Extension Pack");
4234	static const char *s_pszVDPlugin = "VDPluginCrypt";
4235	if (mptrExtPackManager->i_isExtPackUsable(strExtPackPuel.c_str()))
4236	{
4237	/* Configure loading the VDPlugin. */
4238	PCFGMNODE pCfgPlugins = NULL;
4239	PCFGMNODE pCfgPlugin = NULL;
4240	Utf8Str strPlugin;
4241	hrc = mptrExtPackManager->i_getLibraryPathForExtPack(s_pszVDPlugin, &strExtPackPuel, &strPlugin);
4242	// Don't fail, this is optional!
4243	if (SUCCEEDED(hrc))
4244	{
4245	InsertConfigNode(pCfg, "Plugins", &pCfgPlugins);
4246	InsertConfigNode(pCfgPlugins, s_pszVDPlugin, &pCfgPlugin);
4247	InsertConfigString(pCfgPlugin, "Path", strPlugin.c_str());
4248	}
4249	}
4250	# endif
4251
4252	hrc = pMedium->COMGETTER(Location)(bstr.asOutParam()); H();
4253	InsertConfigString(pCfg, "Path", bstr);
4254
4255	hrc = pMedium->COMGETTER(Format)(bstr.asOutParam()); H();
4256	InsertConfigString(pCfg, "Format", bstr);
4257
4258	if (mediumType == MediumType_Readonly)
4259	InsertConfigInteger(pCfg, "ReadOnly", 1);
4260	else if (enmType == DeviceType_Floppy)
4261	InsertConfigInteger(pCfg, "MaybeReadOnly", 1);
4262
4263	/* Start without exclusive write access to the images. */
4264	/** @todo Live Migration: I don't quite like this, we risk screwing up when
4265	* we're resuming the VM if some 3rd dude have any of the VDIs open
4266	* with write sharing denied. However, if the two VMs are sharing a
4267	* image it really is necessary....
4268	*
4269	* So, on the "lock-media" command, the target teleporter should also
4270	* make DrvVD undo TempReadOnly. It gets interesting if we fail after
4271	* that. Grumble. */
4272	if ( enmType == DeviceType_HardDisk
4273	&& ( aMachineState == MachineState_TeleportingIn
4274	\|\| aMachineState == MachineState_FaultTolerantSyncing))
4275	InsertConfigInteger(pCfg, "TempReadOnly", 1);
4276
4277	/* Flag for opening the medium for sharing between VMs. This
4278	* is done at the moment only for the first (and only) medium
4279	* in the chain, as shared media can have no diffs. */
4280	if (mediumType == MediumType_Shareable)
4281	InsertConfigInteger(pCfg, "Shareable", 1);
4282
4283	if (!fUseHostIOCache)
4284	{
4285	InsertConfigInteger(pCfg, "UseNewIo", 1);
4286	/*
4287	* Activate the builtin I/O cache for harddisks only.
4288	* It caches writes only which doesn't make sense for DVD drives
4289	* and just increases the overhead.
4290	*/
4291	if ( fBuiltinIOCache
4292	&& (enmType == DeviceType_HardDisk))
4293	InsertConfigInteger(pCfg, "BlockCache", 1);
4294	}
4295
4296	if (fSetupMerge)
4297	{
4298	InsertConfigInteger(pCfg, "SetupMerge", 1);
4299	if (uImage == uMergeSource)
4300	InsertConfigInteger(pCfg, "MergeSource", 1);
4301	else if (uImage == uMergeTarget)
4302	InsertConfigInteger(pCfg, "MergeTarget", 1);
4303	}
4304
4305	switch (enmType)
4306	{
4307	case DeviceType_DVD:
4308	InsertConfigString(pCfg, "Type", "DVD");
4309	break;
4310	case DeviceType_Floppy:
4311	InsertConfigString(pCfg, "Type", "Floppy");
4312	break;
4313	case DeviceType_HardDisk:
4314	default:
4315	InsertConfigString(pCfg, "Type", "HardDisk");
4316	}
4317
4318	if (pcszBwGroup)
4319	InsertConfigString(pCfg, "BwGroup", pcszBwGroup);
4320
4321	if (fDiscard)
4322	InsertConfigInteger(pCfg, "Discard", 1);
4323
4324	/* Pass all custom parameters. */
4325	bool fHostIP = true;
4326	bool fEncrypted = false;
4327	hrc = i_configMediumProperties(pCfg, pMedium, &fHostIP, &fEncrypted); H();
4328
4329	/* Create an inverted list of parents. */
4330	uImage--;
4331	IMedium *pParentMedium = pMedium;
4332	for (PCFGMNODE pParent = pCfg;; uImage--)
4333	{
4334	hrc = pParentMedium->COMGETTER(Parent)(&pMedium); H();
4335	if (!pMedium)
4336	break;
4337
4338	PCFGMNODE pCur;
4339	InsertConfigNode(pParent, "Parent", &pCur);
4340	hrc = pMedium->COMGETTER(Location)(bstr.asOutParam()); H();
4341	InsertConfigString(pCur, "Path", bstr);
4342
4343	hrc = pMedium->COMGETTER(Format)(bstr.asOutParam()); H();
4344	InsertConfigString(pCur, "Format", bstr);
4345
4346	if (fSetupMerge)
4347	{
4348	if (uImage == uMergeSource)
4349	InsertConfigInteger(pCur, "MergeSource", 1);
4350	else if (uImage == uMergeTarget)
4351	InsertConfigInteger(pCur, "MergeTarget", 1);
4352	}
4353
4354	/* Configure medium properties. */
4355	hrc = i_configMediumProperties(pCur, pMedium, &fHostIP, &fEncrypted); H();
4356
4357	/* next */
4358	pParent = pCur;
4359	pParentMedium = pMedium;
4360	}
4361
4362	/* Custom code: put marker to not use host IP stack to driver
4363	* configuration node. Simplifies life of DrvVD a bit. */
4364	if (!fHostIP)
4365	InsertConfigInteger(pCfg, "HostIPStack", 0);
4366
4367	if (fEncrypted)
4368	m_cDisksEncrypted++;
4369	}
4370	}
4371	#undef H
4372	}
4373	catch (ConfigError &x)
4374	{
4375	// InsertConfig threw something:
4376	return x.m_vrc;
4377	}
4378
4379	return VINF_SUCCESS;
4380	}
4381
4382	/**
4383	* Adds the medium properties to the CFGM tree.
4384	*
4385	* @returns VBox status code.
4386	* @param pCur The current CFGM node.
4387	* @param pMedium The medium object to configure.
4388	* @param pfHostIP Where to return the value of the \"HostIPStack\" property if found.
4389	* @param pfEncrypted Where to return whether the medium is encrypted.
4390	*/
4391	int Console::i_configMediumProperties(PCFGMNODE pCur, IMedium pMedium, bool pfHostIP, bool *pfEncrypted)
4392	{
4393	/* Pass all custom parameters. */
4394	SafeArray<BSTR> aNames;
4395	SafeArray<BSTR> aValues;
4396	HRESULT hrc = pMedium->GetProperties(NULL, ComSafeArrayAsOutParam(aNames),
4397	ComSafeArrayAsOutParam(aValues));
4398
4399	if ( SUCCEEDED(hrc)
4400	&& aNames.size() != 0)
4401	{
4402	PCFGMNODE pVDC;
4403	InsertConfigNode(pCur, "VDConfig", &pVDC);
4404	for (size_t ii = 0; ii < aNames.size(); ++ii)
4405	{
4406	if (aValues[ii] && *aValues[ii])
4407	{
4408	Utf8Str name = aNames[ii];
4409	Utf8Str value = aValues[ii];
4410	size_t offSlash = name.find("/", 0);
4411	if ( offSlash != name.npos
4412	&& !name.startsWith("Special/"))
4413	{
4414	com::Utf8Str strFilter;
4415	com::Utf8Str strKey;
4416
4417	hrc = strFilter.assignEx(name, 0, offSlash);
4418	if (FAILED(hrc))
4419	break;
4420
4421	hrc = strKey.assignEx(name, offSlash + 1, name.length() - offSlash - 1); /* Skip slash */
4422	if (FAILED(hrc))
4423	break;
4424
4425	PCFGMNODE pCfgFilterConfig = CFGMR3GetChild(pVDC, strFilter.c_str());
4426	if (!pCfgFilterConfig)
4427	InsertConfigNode(pVDC, strFilter.c_str(), &pCfgFilterConfig);
4428
4429	InsertConfigString(pCfgFilterConfig, strKey.c_str(), value);
4430	}
4431	else
4432	{
4433	InsertConfigString(pVDC, name.c_str(), value);
4434	if ( name.compare("HostIPStack") == 0
4435	&& value.compare("0") == 0)
4436	*pfHostIP = false;
4437	}
4438
4439	if ( name.compare("CRYPT/KeyId") == 0
4440	&& pfEncrypted)
4441	*pfEncrypted = true;
4442	}
4443	}
4444	}
4445
4446	return hrc;
4447	}
4448
4449
4450	#ifdef RT_OS_WINDOWS
4451	DECLINLINE(bool) IsNdis6(void)
4452	{
4453	LogFlowFunc(("entry\n"));
4454	HANDLE hFile = CreateFile(L"\\\\.\\VBoxNetLwf",
4455	0,
4456	FILE_SHARE_READ \| FILE_SHARE_WRITE,
4457	NULL,
4458	OPEN_EXISTING,
4459	0,
4460	NULL);
4461	bool fNdis6 = hFile != INVALID_HANDLE_VALUE;
4462	if (fNdis6)
4463	CloseHandle(hFile);
4464	else
4465	LogFunc(("CreateFile failed with 0x%x\n", GetLastError()));
4466	LogFlowFunc(("return %s\n", fNdis6 ? "true" : "false"));
4467	return fNdis6;
4468	}
4469	#endif /* RT_OS_WINDOWS */
4470
4471
4472	/**
4473	* Construct the Network configuration tree
4474	*
4475	* @returns VBox status code.
4476	*
4477	* @param pszDevice The PDM device name.
4478	* @param uInstance The PDM device instance.
4479	* @param uLun The PDM LUN number of the drive.
4480	* @param aNetworkAdapter The network adapter whose attachment needs to be changed
4481	* @param pCfg Configuration node for the device
4482	* @param pLunL0 To store the pointer to the LUN#0.
4483	* @param pInst The instance CFGM node
4484	* @param fAttachDetach To determine if the network attachment should
4485	* be attached/detached after/before
4486	* configuration.
4487	* @param fIgnoreConnectFailure
4488	* True if connection failures should be ignored
4489	* (makes only sense for bridged/host-only networks).
4490	*
4491	* @note Locks this object for writing.
4492	* @thread EMT
4493	*/
4494	int Console::i_configNetwork(const char *pszDevice,
4495	unsigned uInstance,
4496	unsigned uLun,
4497	INetworkAdapter *aNetworkAdapter,
4498	PCFGMNODE pCfg,
4499	PCFGMNODE pLunL0,
4500	PCFGMNODE pInst,
4501	bool fAttachDetach,
4502	bool fIgnoreConnectFailure)
4503	{
4504	AutoCaller autoCaller(this);
4505	AssertComRCReturn(autoCaller.rc(), VERR_ACCESS_DENIED);
4506
4507	// InsertConfig* throws
4508	try
4509	{
4510	int rc = VINF_SUCCESS;
4511	HRESULT hrc;
4512	Bstr bstr;
4513
4514	#define H() AssertLogRelMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR)
4515
4516	/*
4517	* Locking the object before doing VMR3* calls is quite safe here, since
4518	* we're on EMT. Write lock is necessary because we indirectly modify the
4519	* meAttachmentType member.
4520	*/
4521	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4522
4523	ComPtr<IMachine> pMachine = i_machine();
4524
4525	ComPtr<IVirtualBox> virtualBox;
4526	hrc = pMachine->COMGETTER(Parent)(virtualBox.asOutParam()); H();
4527
4528	ComPtr<IHost> host;
4529	hrc = virtualBox->COMGETTER(Host)(host.asOutParam()); H();
4530
4531	BOOL fSniffer;
4532	hrc = aNetworkAdapter->COMGETTER(TraceEnabled)(&fSniffer); H();
4533
4534	NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
4535	hrc = aNetworkAdapter->COMGETTER(PromiscModePolicy)(&enmPromiscModePolicy); H();
4536	const char *pszPromiscuousGuestPolicy;
4537	switch (enmPromiscModePolicy)
4538	{
4539	case NetworkAdapterPromiscModePolicy_Deny: pszPromiscuousGuestPolicy = "deny"; break;
4540	case NetworkAdapterPromiscModePolicy_AllowNetwork: pszPromiscuousGuestPolicy = "allow-network"; break;
4541	case NetworkAdapterPromiscModePolicy_AllowAll: pszPromiscuousGuestPolicy = "allow-all"; break;
4542	default: AssertFailedReturn(VERR_INTERNAL_ERROR_4);
4543	}
4544
4545	if (fAttachDetach)
4546	{
4547	rc = PDMR3DeviceDetach(mpUVM, pszDevice, uInstance, uLun, 0 /fFlags/);
4548	if (rc == VINF_PDM_NO_DRIVER_ATTACHED_TO_LUN)
4549	rc = VINF_SUCCESS;
4550	AssertLogRelRCReturn(rc, rc);
4551
4552	/* nuke anything which might have been left behind. */
4553	CFGMR3RemoveNode(CFGMR3GetChildF(pInst, "LUN#%u", uLun));
4554	}
4555
4556	#ifdef VBOX_WITH_NETSHAPER
4557	ComObjPtr<IBandwidthGroup> pBwGroup;
4558	Bstr strBwGroup;
4559	hrc = aNetworkAdapter->COMGETTER(BandwidthGroup)(pBwGroup.asOutParam()); H();
4560
4561	if (!pBwGroup.isNull())
4562	{
4563	hrc = pBwGroup->COMGETTER(Name)(strBwGroup.asOutParam()); H();
4564	}
4565	#endif /* VBOX_WITH_NETSHAPER */
4566
4567	Utf8Str strNetDriver;
4568
4569
4570	InsertConfigNode(pInst, "LUN#0", &pLunL0);
4571
4572	#ifdef VBOX_WITH_NETSHAPER
4573	if (!strBwGroup.isEmpty())
4574	{
4575	InsertConfigString(pLunL0, "Driver", "NetShaper");
4576	InsertConfigNode(pLunL0, "Config", &pCfg);
4577	InsertConfigString(pCfg, "BwGroup", strBwGroup);
4578	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL0);
4579	}
4580	#endif /* VBOX_WITH_NETSHAPER */
4581
4582	if (fSniffer)
4583	{
4584	InsertConfigString(pLunL0, "Driver", "NetSniffer");
4585	InsertConfigNode(pLunL0, "Config", &pCfg);
4586	hrc = aNetworkAdapter->COMGETTER(TraceFile)(bstr.asOutParam()); H();
4587	if (!bstr.isEmpty()) /* check convention for indicating default file. */
4588	InsertConfigString(pCfg, "File", bstr);
4589	InsertConfigNode(pLunL0, "AttachedDriver", &pLunL0);
4590	}
4591
4592
4593	Bstr networkName, trunkName, trunkType;
4594	NetworkAttachmentType_T eAttachmentType;
4595	hrc = aNetworkAdapter->COMGETTER(AttachmentType)(&eAttachmentType); H();
4596	switch (eAttachmentType)
4597	{
4598	case NetworkAttachmentType_Null:
4599	break;
4600
4601	case NetworkAttachmentType_NAT:
4602	{
4603	ComPtr<INATEngine> natEngine;
4604	hrc = aNetworkAdapter->COMGETTER(NATEngine)(natEngine.asOutParam()); H();
4605	InsertConfigString(pLunL0, "Driver", "NAT");
4606	InsertConfigNode(pLunL0, "Config", &pCfg);
4607
4608	/* Configure TFTP prefix and boot filename. */
4609	hrc = virtualBox->COMGETTER(HomeFolder)(bstr.asOutParam()); H();
4610	if (!bstr.isEmpty())
4611	InsertConfigString(pCfg, "TFTPPrefix", Utf8StrFmt("%ls%c%s", bstr.raw(), RTPATH_DELIMITER, "TFTP"));
4612	hrc = pMachine->COMGETTER(Name)(bstr.asOutParam()); H();
4613	InsertConfigString(pCfg, "BootFile", Utf8StrFmt("%ls.pxe", bstr.raw()));
4614
4615	hrc = natEngine->COMGETTER(Network)(bstr.asOutParam()); H();
4616	if (!bstr.isEmpty())
4617	InsertConfigString(pCfg, "Network", bstr);
4618	else
4619	{
4620	ULONG uSlot;
4621	hrc = aNetworkAdapter->COMGETTER(Slot)(&uSlot); H();
4622	InsertConfigString(pCfg, "Network", Utf8StrFmt("10.0.%d.0/24", uSlot+2));
4623	}
4624	hrc = natEngine->COMGETTER(HostIP)(bstr.asOutParam()); H();
4625	if (!bstr.isEmpty())
4626	InsertConfigString(pCfg, "BindIP", bstr);
4627	ULONG mtu = 0;
4628	ULONG sockSnd = 0;
4629	ULONG sockRcv = 0;
4630	ULONG tcpSnd = 0;
4631	ULONG tcpRcv = 0;
4632	hrc = natEngine->GetNetworkSettings(&mtu, &sockSnd, &sockRcv, &tcpSnd, &tcpRcv); H();
4633	if (mtu)
4634	InsertConfigInteger(pCfg, "SlirpMTU", mtu);
4635	if (sockRcv)
4636	InsertConfigInteger(pCfg, "SockRcv", sockRcv);
4637	if (sockSnd)
4638	InsertConfigInteger(pCfg, "SockSnd", sockSnd);
4639	if (tcpRcv)
4640	InsertConfigInteger(pCfg, "TcpRcv", tcpRcv);
4641	if (tcpSnd)
4642	InsertConfigInteger(pCfg, "TcpSnd", tcpSnd);
4643	hrc = natEngine->COMGETTER(TFTPPrefix)(bstr.asOutParam()); H();
4644	if (!bstr.isEmpty())
4645	{
4646	RemoveConfigValue(pCfg, "TFTPPrefix");
4647	InsertConfigString(pCfg, "TFTPPrefix", bstr);
4648	}
4649	hrc = natEngine->COMGETTER(TFTPBootFile)(bstr.asOutParam()); H();
4650	if (!bstr.isEmpty())
4651	{
4652	RemoveConfigValue(pCfg, "BootFile");
4653	InsertConfigString(pCfg, "BootFile", bstr);
4654	}
4655	hrc = natEngine->COMGETTER(TFTPNextServer)(bstr.asOutParam()); H();
4656	if (!bstr.isEmpty())
4657	InsertConfigString(pCfg, "NextServer", bstr);
4658	BOOL fDNSFlag;
4659	hrc = natEngine->COMGETTER(DNSPassDomain)(&fDNSFlag); H();
4660	InsertConfigInteger(pCfg, "PassDomain", fDNSFlag);
4661	hrc = natEngine->COMGETTER(DNSProxy)(&fDNSFlag); H();
4662	InsertConfigInteger(pCfg, "DNSProxy", fDNSFlag);
4663	hrc = natEngine->COMGETTER(DNSUseHostResolver)(&fDNSFlag); H();
4664	InsertConfigInteger(pCfg, "UseHostResolver", fDNSFlag);
4665
4666	ULONG aliasMode;
4667	hrc = natEngine->COMGETTER(AliasMode)(&aliasMode); H();
4668	InsertConfigInteger(pCfg, "AliasMode", aliasMode);
4669
4670	/* port-forwarding */
4671	SafeArray<BSTR> pfs;
4672	hrc = natEngine->COMGETTER(Redirects)(ComSafeArrayAsOutParam(pfs)); H();
4673	PCFGMNODE pPF = NULL; /* /Devices/Dev/.../Config/PF#0/ */
4674	for (unsigned int i = 0; i < pfs.size(); ++i)
4675	{
4676	uint16_t port = 0;
4677	BSTR r = pfs[i];
4678	Utf8Str utf = Utf8Str(r);
4679	Utf8Str strName;
4680	Utf8Str strProto;
4681	Utf8Str strHostPort;
4682	Utf8Str strHostIP;
4683	Utf8Str strGuestPort;
4684	Utf8Str strGuestIP;
4685	size_t pos, ppos;
4686	pos = ppos = 0;
4687	#define ITERATE_TO_NEXT_TERM(res, str, pos, ppos) \
4688	do { \
4689	pos = str.find(",", ppos); \
4690	if (pos == Utf8Str::npos) \
4691	{ \
4692	Log(( #res " extracting from %s is failed\n", str.c_str())); \
4693	continue; \
4694	} \
4695	res = str.substr(ppos, pos - ppos); \
4696	Log2((#res " %s pos:%d, ppos:%d\n", res.c_str(), pos, ppos)); \
4697	ppos = pos + 1; \
4698	} while (0)
4699	ITERATE_TO_NEXT_TERM(strName, utf, pos, ppos);
4700	ITERATE_TO_NEXT_TERM(strProto, utf, pos, ppos);
4701	ITERATE_TO_NEXT_TERM(strHostIP, utf, pos, ppos);
4702	ITERATE_TO_NEXT_TERM(strHostPort, utf, pos, ppos);
4703	ITERATE_TO_NEXT_TERM(strGuestIP, utf, pos, ppos);
4704	strGuestPort = utf.substr(ppos, utf.length() - ppos);
4705	#undef ITERATE_TO_NEXT_TERM
4706
4707	uint32_t proto = strProto.toUInt32();
4708	bool fValid = true;
4709	switch (proto)
4710	{
4711	case NATProtocol_UDP:
4712	strProto = "UDP";
4713	break;
4714	case NATProtocol_TCP:
4715	strProto = "TCP";
4716	break;
4717	default:
4718	fValid = false;
4719	}
4720	/* continue with next rule if no valid proto was passed */
4721	if (!fValid)
4722	continue;
4723
4724	if (strName.isEmpty())
4725	VMSetError(VMR3GetVM(mpUVM), VERR_CFGM_NO_NODE, RT_SRC_POS,
4726	N_("NAT redirection rule without a name"));
4727
4728	InsertConfigNode(pCfg, strName.c_str(), &pPF);
4729	InsertConfigString(pPF, "Protocol", strProto);
4730
4731	if (!strHostIP.isEmpty())
4732	InsertConfigString(pPF, "BindIP", strHostIP);
4733
4734	if (!strGuestIP.isEmpty())
4735	InsertConfigString(pPF, "GuestIP", strGuestIP);
4736
4737	port = RTStrToUInt16(strHostPort.c_str());
4738	if (port)
4739	InsertConfigInteger(pPF, "HostPort", port);
4740
4741	port = RTStrToUInt16(strGuestPort.c_str());
4742	if (port)
4743	InsertConfigInteger(pPF, "GuestPort", port);
4744	}
4745	break;
4746	}
4747
4748	case NetworkAttachmentType_Bridged:
4749	{
4750	#if (defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)) && !defined(VBOX_WITH_NETFLT)
4751	hrc = i_attachToTapInterface(aNetworkAdapter);
4752	if (FAILED(hrc))
4753	{
4754	switch (hrc)
4755	{
4756	case VERR_ACCESS_DENIED:
4757	return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
4758	"Failed to open '/dev/net/tun' for read/write access. Please check the "
4759	"permissions of that node. Either run 'chmod 0666 /dev/net/tun' or "
4760	"change the group of that node and make yourself a member of that group. Make "
4761	"sure that these changes are permanent, especially if you are "
4762	"using udev"));
4763	default:
4764	AssertMsgFailed(("Could not attach to host interface! Bad!\n"));
4765	return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
4766	"Failed to initialize Host Interface Networking"));
4767	}
4768	}
4769
4770	Assert((intptr_t)maTapFD[uInstance] >= 0);
4771	if ((intptr_t)maTapFD[uInstance] >= 0)
4772	{
4773	InsertConfigString(pLunL0, "Driver", "HostInterface");
4774	InsertConfigNode(pLunL0, "Config", &pCfg);
4775	InsertConfigInteger(pCfg, "FileHandle", (intptr_t)maTapFD[uInstance]);
4776	}
4777
4778	#elif defined(VBOX_WITH_NETFLT)
4779	/*
4780	* This is the new VBoxNetFlt+IntNet stuff.
4781	*/
4782	Bstr BridgedIfName;
4783	hrc = aNetworkAdapter->COMGETTER(BridgedInterface)(BridgedIfName.asOutParam());
4784	if (FAILED(hrc))
4785	{
4786	LogRel(("NetworkAttachmentType_Bridged: COMGETTER(BridgedInterface) failed, hrc (0x%x)\n", hrc));
4787	H();
4788	}
4789
4790	Utf8Str BridgedIfNameUtf8(BridgedIfName);
4791	const char *pszBridgedIfName = BridgedIfNameUtf8.c_str();
4792
4793	# if defined(RT_OS_DARWIN)
4794	/* The name is on the form 'ifX: long name', chop it off at the colon. */
4795	char szTrunk[8];
4796	RTStrCopy(szTrunk, sizeof(szTrunk), pszBridgedIfName);
4797	char pszColon = (char )memchr(szTrunk, ':', sizeof(szTrunk));
4798	// Quick fix for @bugref{5633}
4799	// if (!pszColon)
4800	// {
4801	// /*
4802	// * Dynamic changing of attachment causes an attempt to configure
4803	// * network with invalid host adapter (as it is must be changed before
4804	// * the attachment), calling Detach here will cause a deadlock.
4805	// * See @bugref{4750}.
4806	// * hrc = aNetworkAdapter->Detach(); H();
4807	// */
4808	// return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
4809	// N_("Malformed host interface networking name '%ls'"),
4810	// BridgedIfName.raw());
4811	// }
4812	if (pszColon)
4813	*pszColon = '\0';
4814	const char *pszTrunk = szTrunk;
4815
4816	# elif defined(RT_OS_SOLARIS)
4817	/* The name is on the form format 'ifX[:1] - long name, chop it off at space. */
4818	char szTrunk[256];
4819	strlcpy(szTrunk, pszBridgedIfName, sizeof(szTrunk));
4820	char pszSpace = (char )memchr(szTrunk, ' ', sizeof(szTrunk));
4821
4822	/*
4823	* Currently don't bother about malformed names here for the sake of people using
4824	* VBoxManage and setting only the NIC name from there. If there is a space we
4825	* chop it off and proceed, otherwise just use whatever we've got.
4826	*/
4827	if (pszSpace)
4828	*pszSpace = '\0';
4829
4830	/* Chop it off at the colon (zone naming eg: e1000g:1 we need only the e1000g) */
4831	char pszColon = (char )memchr(szTrunk, ':', sizeof(szTrunk));
4832	if (pszColon)
4833	*pszColon = '\0';
4834
4835	const char *pszTrunk = szTrunk;
4836
4837	# elif defined(RT_OS_WINDOWS)
4838	ComPtr<IHostNetworkInterface> hostInterface;
4839	hrc = host->FindHostNetworkInterfaceByName(BridgedIfName.raw(),
4840	hostInterface.asOutParam());
4841	if (!SUCCEEDED(hrc))
4842	{
4843	AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: FindByName failed, rc=%Rhrc (0x%x)", hrc, hrc));
4844	return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
4845	N_("Nonexistent host networking interface, name '%ls'"),
4846	BridgedIfName.raw());
4847	}
4848
4849	HostNetworkInterfaceType_T eIfType;
4850	hrc = hostInterface->COMGETTER(InterfaceType)(&eIfType);
4851	if (FAILED(hrc))
4852	{
4853	LogRel(("NetworkAttachmentType_Bridged: COMGETTER(InterfaceType) failed, hrc (0x%x)\n", hrc));
4854	H();
4855	}
4856
4857	if (eIfType != HostNetworkInterfaceType_Bridged)
4858	{
4859	return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
4860	N_("Interface ('%ls') is not a Bridged Adapter interface"),
4861	BridgedIfName.raw());
4862	}
4863
4864	hrc = hostInterface->COMGETTER(Id)(bstr.asOutParam());
4865	if (FAILED(hrc))
4866	{
4867	LogRel(("NetworkAttachmentType_Bridged: COMGETTER(Id) failed, hrc (0x%x)\n", hrc));
4868	H();
4869	}
4870	Guid hostIFGuid(bstr);
4871
4872	INetCfg *pNc;
4873	ComPtr<INetCfgComponent> pAdaptorComponent;
4874	LPWSTR pszApp;
4875
4876	hrc = VBoxNetCfgWinQueryINetCfg(&pNc, FALSE, L"VirtualBox", 10, &pszApp);
4877	Assert(hrc == S_OK);
4878	if (hrc != S_OK)
4879	{
4880	LogRel(("NetworkAttachmentType_Bridged: Failed to get NetCfg, hrc=%Rhrc (0x%x)\n", hrc, hrc));
4881	H();
4882	}
4883
4884	/* get the adapter's INetCfgComponent*/
4885	hrc = VBoxNetCfgWinGetComponentByGuid(pNc, &GUID_DEVCLASS_NET, (GUID*)hostIFGuid.raw(),
4886	pAdaptorComponent.asOutParam());
4887	if (hrc != S_OK)
4888	{
4889	VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /fHasWriteLock/);
4890	LogRel(("NetworkAttachmentType_Bridged: VBoxNetCfgWinGetComponentByGuid failed, hrc (0x%x)\n", hrc));
4891	H();
4892	}
4893	#define VBOX_WIN_BINDNAME_PREFIX "\\DEVICE\\"
4894	char szTrunkName[INTNET_MAX_TRUNK_NAME];
4895	char *pszTrunkName = szTrunkName;
4896	wchar_t * pswzBindName;
4897	hrc = pAdaptorComponent->GetBindName(&pswzBindName);
4898	Assert(hrc == S_OK);
4899	if (hrc == S_OK)
4900	{
4901	int cwBindName = (int)wcslen(pswzBindName) + 1;
4902	int cbFullBindNamePrefix = sizeof(VBOX_WIN_BINDNAME_PREFIX);
4903	if (sizeof(szTrunkName) > cbFullBindNamePrefix + cwBindName)
4904	{
4905	strcpy(szTrunkName, VBOX_WIN_BINDNAME_PREFIX);
4906	pszTrunkName += cbFullBindNamePrefix-1;
4907	if (!WideCharToMultiByte(CP_ACP, 0, pswzBindName, cwBindName, pszTrunkName,
4908	sizeof(szTrunkName) - cbFullBindNamePrefix + 1, NULL, NULL))
4909	{
4910	DWORD err = GetLastError();
4911	hrc = HRESULT_FROM_WIN32(err);
4912	AssertMsgFailed(("%hrc=%Rhrc %#x\n", hrc, hrc));
4913	AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: WideCharToMultiByte failed, hr=%Rhrc (0x%x) err=%u\n",
4914	hrc, hrc, err));
4915	}
4916	}
4917	else
4918	{
4919	AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: insufficient szTrunkName buffer space\n"));
4920	/** @todo set appropriate error code */
4921	hrc = E_FAIL;
4922	}
4923
4924	if (hrc != S_OK)
4925	{
4926	AssertFailed();
4927	CoTaskMemFree(pswzBindName);
4928	VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /fHasWriteLock/);
4929	H();
4930	}
4931
4932	/* we're not freeing the bind name since we'll use it later for detecting wireless*/
4933	}
4934	else
4935	{
4936	VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /fHasWriteLock/);
4937	AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: VBoxNetCfgWinGetComponentByGuid failed, hrc (0x%x)",
4938	hrc));
4939	H();
4940	}
4941
4942	const char *pszTrunk = szTrunkName;
4943	/* we're not releasing the INetCfg stuff here since we use it later to figure out whether it is wireless */
4944
4945	# elif defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)
4946	# if defined(RT_OS_FREEBSD)
4947	/*
4948	* If we bridge to a tap interface open it the `old' direct way.
4949	* This works and performs better than bridging a physical
4950	* interface via the current FreeBSD vboxnetflt implementation.
4951	*/
4952	if (!strncmp(pszBridgedIfName, RT_STR_TUPLE("tap"))) {
4953	hrc = i_attachToTapInterface(aNetworkAdapter);
4954	if (FAILED(hrc))
4955	{
4956	switch (hrc)
4957	{
4958	case VERR_ACCESS_DENIED:
4959	return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
4960	"Failed to open '/dev/%s' for read/write access. Please check the "
4961	"permissions of that node, and that the net.link.tap.user_open "
4962	"sysctl is set. Either run 'chmod 0666 /dev/%s' or "
4963	"change the group of that node to vboxusers and make yourself "
4964	"a member of that group. Make sure that these changes are permanent."),
4965	pszBridgedIfName, pszBridgedIfName);
4966	default:
4967	AssertMsgFailed(("Could not attach to tap interface! Bad!\n"));
4968	return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
4969	"Failed to initialize Host Interface Networking"));
4970	}
4971	}
4972
4973	Assert((intptr_t)maTapFD[uInstance] >= 0);
4974	if ((intptr_t)maTapFD[uInstance] >= 0)
4975	{
4976	InsertConfigString(pLunL0, "Driver", "HostInterface");
4977	InsertConfigNode(pLunL0, "Config", &pCfg);
4978	InsertConfigInteger(pCfg, "FileHandle", (intptr_t)maTapFD[uInstance]);
4979	}
4980	break;
4981	}
4982	# endif
4983	/** @todo Check for malformed names. */
4984	const char *pszTrunk = pszBridgedIfName;
4985
4986	/* Issue a warning if the interface is down */
4987	{
4988	int iSock = socket(AF_INET, SOCK_DGRAM, 0);
4989	if (iSock >= 0)
4990	{
4991	struct ifreq Req;
4992	RT_ZERO(Req);
4993	RTStrCopy(Req.ifr_name, sizeof(Req.ifr_name), pszBridgedIfName);
4994	if (ioctl(iSock, SIOCGIFFLAGS, &Req) >= 0)
4995	if ((Req.ifr_flags & IFF_UP) == 0)
4996	i_setVMRuntimeErrorCallbackF(0, "BridgedInterfaceDown",
4997	N_("Bridged interface %s is down. Guest will not be able to use this interface"),
4998	pszBridgedIfName);
4999
5000	close(iSock);
5001	}
5002	}
5003
5004	# else
5005	# error "PORTME (VBOX_WITH_NETFLT)"
5006	# endif
5007
5008	InsertConfigString(pLunL0, "Driver", "IntNet");
5009	InsertConfigNode(pLunL0, "Config", &pCfg);
5010	InsertConfigString(pCfg, "Trunk", pszTrunk);
5011	InsertConfigInteger(pCfg, "TrunkType", kIntNetTrunkType_NetFlt);
5012	InsertConfigInteger(pCfg, "IgnoreConnectFailure", (uint64_t)fIgnoreConnectFailure);
5013	InsertConfigString(pCfg, "IfPolicyPromisc", pszPromiscuousGuestPolicy);
5014	char szNetwork[INTNET_MAX_NETWORK_NAME];
5015
5016	#if defined(RT_OS_SOLARIS) \|\| defined(RT_OS_DARWIN)
5017	/*
5018	* 'pszTrunk' contains just the interface name required in ring-0, while 'pszBridgedIfName' contains
5019	* interface name + optional description. We must not pass any description to the VM as it can differ
5020	* for the same interface name, eg: "nge0 - ethernet" (GUI) vs "nge0" (VBoxManage).
5021	*/
5022	RTStrPrintf(szNetwork, sizeof(szNetwork), "HostInterfaceNetworking-%s", pszTrunk);
5023	#else
5024	RTStrPrintf(szNetwork, sizeof(szNetwork), "HostInterfaceNetworking-%s", pszBridgedIfName);
5025	#endif
5026	InsertConfigString(pCfg, "Network", szNetwork);
5027	networkName = Bstr(szNetwork);
5028	trunkName = Bstr(pszTrunk);
5029	trunkType = Bstr(TRUNKTYPE_NETFLT);
5030
5031	# if defined(RT_OS_DARWIN)
5032	/** @todo Come up with a better deal here. Problem is that IHostNetworkInterface is completely useless here. */
5033	if ( strstr(pszBridgedIfName, "Wireless")
5034	\|\| strstr(pszBridgedIfName, "AirPort" ))
5035	InsertConfigInteger(pCfg, "SharedMacOnWire", true);
5036	# elif defined(RT_OS_LINUX)
5037	int iSock = socket(AF_INET, SOCK_DGRAM, 0);
5038	if (iSock >= 0)
5039	{
5040	struct iwreq WRq;
5041
5042	RT_ZERO(WRq);
5043	strncpy(WRq.ifr_name, pszBridgedIfName, IFNAMSIZ);
5044	bool fSharedMacOnWire = ioctl(iSock, SIOCGIWNAME, &WRq) >= 0;
5045	close(iSock);
5046	if (fSharedMacOnWire)
5047	{
5048	InsertConfigInteger(pCfg, "SharedMacOnWire", true);
5049	Log(("Set SharedMacOnWire\n"));
5050	}
5051	else
5052	Log(("Failed to get wireless name\n"));
5053	}
5054	else
5055	Log(("Failed to open wireless socket\n"));
5056	# elif defined(RT_OS_FREEBSD)
5057	int iSock = socket(AF_INET, SOCK_DGRAM, 0);
5058	if (iSock >= 0)
5059	{
5060	struct ieee80211req WReq;
5061	uint8_t abData[32];
5062
5063	RT_ZERO(WReq);
5064	strncpy(WReq.i_name, pszBridgedIfName, sizeof(WReq.i_name));
5065	WReq.i_type = IEEE80211_IOC_SSID;
5066	WReq.i_val = -1;
5067	WReq.i_data = abData;
5068	WReq.i_len = sizeof(abData);
5069
5070	bool fSharedMacOnWire = ioctl(iSock, SIOCG80211, &WReq) >= 0;
5071	close(iSock);
5072	if (fSharedMacOnWire)
5073	{
5074	InsertConfigInteger(pCfg, "SharedMacOnWire", true);
5075	Log(("Set SharedMacOnWire\n"));
5076	}
5077	else
5078	Log(("Failed to get wireless name\n"));
5079	}
5080	else
5081	Log(("Failed to open wireless socket\n"));
5082	# elif defined(RT_OS_WINDOWS)
5083	# define DEVNAME_PREFIX L"\\\\.\\"
5084	/* we are getting the medium type via IOCTL_NDIS_QUERY_GLOBAL_STATS Io Control
5085	* there is a pretty long way till there though since we need to obtain the symbolic link name
5086	* for the adapter device we are going to query given the device Guid */
5087
5088
5089	/* prepend the "\\\\.\\" to the bind name to obtain the link name */
5090
5091	wchar_t FileName[MAX_PATH];
5092	wcscpy(FileName, DEVNAME_PREFIX);
5093	wcscpy((wchar_t)(((char)FileName) + sizeof(DEVNAME_PREFIX) - sizeof(FileName[0])), pswzBindName);
5094
5095	/* open the device */
5096	HANDLE hDevice = CreateFile(FileName,
5097	GENERIC_READ \| GENERIC_WRITE, FILE_SHARE_READ \| FILE_SHARE_WRITE,
5098	NULL,
5099	OPEN_EXISTING,
5100	FILE_ATTRIBUTE_NORMAL,
5101	NULL);
5102
5103	if (hDevice != INVALID_HANDLE_VALUE)
5104	{
5105	bool fSharedMacOnWire = false;
5106
5107	/* now issue the OID_GEN_PHYSICAL_MEDIUM query */
5108	DWORD Oid = OID_GEN_PHYSICAL_MEDIUM;
5109	NDIS_PHYSICAL_MEDIUM PhMedium;
5110	DWORD cbResult;
5111	if (DeviceIoControl(hDevice,
5112	IOCTL_NDIS_QUERY_GLOBAL_STATS,
5113	&Oid,
5114	sizeof(Oid),
5115	&PhMedium,
5116	sizeof(PhMedium),
5117	&cbResult,
5118	NULL))
5119	{
5120	/* that was simple, now examine PhMedium */
5121	if ( PhMedium == NdisPhysicalMediumWirelessWan
5122	\|\| PhMedium == NdisPhysicalMediumWirelessLan
5123	\|\| PhMedium == NdisPhysicalMediumNative802_11
5124	\|\| PhMedium == NdisPhysicalMediumBluetooth)
5125	fSharedMacOnWire = true;
5126	}
5127	else
5128	{
5129	int winEr = GetLastError();
5130	LogRel(("Console::configNetwork: DeviceIoControl failed, err (0x%x), ignoring\n", winEr));
5131	Assert(winEr == ERROR_INVALID_PARAMETER \|\| winEr == ERROR_NOT_SUPPORTED \|\| winEr == ERROR_BAD_COMMAND);
5132	}
5133	CloseHandle(hDevice);
5134
5135	if (fSharedMacOnWire)
5136	{
5137	Log(("this is a wireless adapter"));
5138	InsertConfigInteger(pCfg, "SharedMacOnWire", true);
5139	Log(("Set SharedMacOnWire\n"));
5140	}
5141	else
5142	Log(("this is NOT a wireless adapter"));
5143	}
5144	else
5145	{
5146	int winEr = GetLastError();
5147	AssertLogRelMsgFailed(("Console::configNetwork: CreateFile failed, err (0x%x), ignoring\n", winEr));
5148	}
5149
5150	CoTaskMemFree(pswzBindName);
5151
5152	pAdaptorComponent.setNull();
5153	/* release the pNc finally */
5154	VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /fHasWriteLock/);
5155	# else
5156	/** @todo PORTME: wireless detection */
5157	# endif
5158
5159	# if defined(RT_OS_SOLARIS)
5160	# if 0 /* bird: this is a bit questionable and might cause more trouble than its worth. */
5161	/* Zone access restriction, don't allow snooping the global zone. */
5162	zoneid_t ZoneId = getzoneid();
5163	if (ZoneId != GLOBAL_ZONEID)
5164	{
5165	InsertConfigInteger(pCfg, "IgnoreAllPromisc", true);
5166	}
5167	# endif
5168	# endif
5169
5170	#elif defined(RT_OS_WINDOWS) /* not defined NetFlt */
5171	/* NOTHING TO DO HERE */
5172	#elif defined(RT_OS_LINUX)
5173	/// @todo aleksey: is there anything to be done here?
5174	#elif defined(RT_OS_FREEBSD)
5175	/** @todo FreeBSD: Check out this later (HIF networking). */
5176	#else
5177	# error "Port me"
5178	#endif
5179	break;
5180	}
5181
5182	case NetworkAttachmentType_Internal:
5183	{
5184	hrc = aNetworkAdapter->COMGETTER(InternalNetwork)(bstr.asOutParam()); H();
5185	if (!bstr.isEmpty())
5186	{
5187	InsertConfigString(pLunL0, "Driver", "IntNet");
5188	InsertConfigNode(pLunL0, "Config", &pCfg);
5189	InsertConfigString(pCfg, "Network", bstr);
5190	InsertConfigInteger(pCfg, "TrunkType", kIntNetTrunkType_WhateverNone);
5191	InsertConfigString(pCfg, "IfPolicyPromisc", pszPromiscuousGuestPolicy);
5192	networkName = bstr;
5193	trunkType = Bstr(TRUNKTYPE_WHATEVER);
5194	}
5195	break;
5196	}
5197
5198	case NetworkAttachmentType_HostOnly:
5199	{
5200	InsertConfigString(pLunL0, "Driver", "IntNet");
5201	InsertConfigNode(pLunL0, "Config", &pCfg);
5202
5203	Bstr HostOnlyName;
5204	hrc = aNetworkAdapter->COMGETTER(HostOnlyInterface)(HostOnlyName.asOutParam());
5205	if (FAILED(hrc))
5206	{
5207	LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(HostOnlyInterface) failed, hrc (0x%x)\n", hrc));
5208	H();
5209	}
5210
5211	Utf8Str HostOnlyNameUtf8(HostOnlyName);
5212	const char *pszHostOnlyName = HostOnlyNameUtf8.c_str();
5213	ComPtr<IHostNetworkInterface> hostInterface;
5214	rc = host->FindHostNetworkInterfaceByName(HostOnlyName.raw(),
5215	hostInterface.asOutParam());
5216	if (!SUCCEEDED(rc))
5217	{
5218	LogRel(("NetworkAttachmentType_HostOnly: FindByName failed, rc (0x%x)\n", rc));
5219	return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
5220	N_("Nonexistent host networking interface, name '%ls'"),
5221	HostOnlyName.raw());
5222	}
5223
5224	char szNetwork[INTNET_MAX_NETWORK_NAME];
5225	RTStrPrintf(szNetwork, sizeof(szNetwork), "HostInterfaceNetworking-%s", pszHostOnlyName);
5226
5227	#if defined(RT_OS_WINDOWS)
5228	# ifndef VBOX_WITH_NETFLT
5229	hrc = E_NOTIMPL;
5230	LogRel(("NetworkAttachmentType_HostOnly: Not Implemented\n"));
5231	H();
5232	# else /* defined VBOX_WITH_NETFLT*/
5233	/** @todo r=bird: Put this in a function. */
5234
5235	HostNetworkInterfaceType_T eIfType;
5236	hrc = hostInterface->COMGETTER(InterfaceType)(&eIfType);
5237	if (FAILED(hrc))
5238	{
5239	LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(InterfaceType) failed, hrc (0x%x)\n", hrc));
5240	H();
5241	}
5242
5243	if (eIfType != HostNetworkInterfaceType_HostOnly)
5244	return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
5245	N_("Interface ('%ls') is not a Host-Only Adapter interface"),
5246	HostOnlyName.raw());
5247
5248	hrc = hostInterface->COMGETTER(Id)(bstr.asOutParam());
5249	if (FAILED(hrc))
5250	{
5251	LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(Id) failed, hrc (0x%x)\n", hrc));
5252	H();
5253	}
5254	Guid hostIFGuid(bstr);
5255
5256	INetCfg *pNc;
5257	ComPtr<INetCfgComponent> pAdaptorComponent;
5258	LPWSTR pszApp;
5259	hrc = VBoxNetCfgWinQueryINetCfg(&pNc, FALSE, L"VirtualBox", 10, &pszApp);
5260	Assert(hrc == S_OK);
5261	if (hrc != S_OK)
5262	{
5263	LogRel(("NetworkAttachmentType_HostOnly: Failed to get NetCfg, hrc=%Rhrc (0x%x)\n", hrc, hrc));
5264	H();
5265	}
5266
5267	/* get the adapter's INetCfgComponent*/
5268	hrc = VBoxNetCfgWinGetComponentByGuid(pNc, &GUID_DEVCLASS_NET, (GUID*)hostIFGuid.raw(),
5269	pAdaptorComponent.asOutParam());
5270	if (hrc != S_OK)
5271	{
5272	VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /fHasWriteLock/);
5273	LogRel(("NetworkAttachmentType_HostOnly: VBoxNetCfgWinGetComponentByGuid failed, hrc=%Rhrc (0x%x)\n", hrc, hrc));
5274	H();
5275	}
5276	# define VBOX_WIN_BINDNAME_PREFIX "\\DEVICE\\"
5277	char szTrunkName[INTNET_MAX_TRUNK_NAME];
5278	char *pszTrunkName = szTrunkName;
5279	wchar_t * pswzBindName;
5280	hrc = pAdaptorComponent->GetBindName(&pswzBindName);
5281	Assert(hrc == S_OK);
5282	if (hrc == S_OK)
5283	{
5284	int cwBindName = (int)wcslen(pswzBindName) + 1;
5285	int cbFullBindNamePrefix = sizeof(VBOX_WIN_BINDNAME_PREFIX);
5286	if (sizeof(szTrunkName) > cbFullBindNamePrefix + cwBindName)
5287	{
5288	strcpy(szTrunkName, VBOX_WIN_BINDNAME_PREFIX);
5289	pszTrunkName += cbFullBindNamePrefix-1;
5290	if (!WideCharToMultiByte(CP_ACP, 0, pswzBindName, cwBindName, pszTrunkName,
5291	sizeof(szTrunkName) - cbFullBindNamePrefix + 1, NULL, NULL))
5292	{
5293	DWORD err = GetLastError();
5294	hrc = HRESULT_FROM_WIN32(err);
5295	AssertLogRelMsgFailed(("NetworkAttachmentType_HostOnly: WideCharToMultiByte failed, hr=%Rhrc (0x%x) err=%u\n",
5296	hrc, hrc, err));
5297	}
5298	}
5299	else
5300	{
5301	AssertLogRelMsgFailed(("NetworkAttachmentType_HostOnly: insufficient szTrunkName buffer space\n"));
5302	/** @todo set appropriate error code */
5303	hrc = E_FAIL;
5304	}
5305
5306	if (hrc != S_OK)
5307	{
5308	AssertFailed();
5309	CoTaskMemFree(pswzBindName);
5310	VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /fHasWriteLock/);
5311	H();
5312	}
5313	}
5314	else
5315	{
5316	VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /fHasWriteLock/);
5317	AssertLogRelMsgFailed(("NetworkAttachmentType_HostOnly: VBoxNetCfgWinGetComponentByGuid failed, hrc=%Rhrc (0x%x)\n",
5318	hrc, hrc));
5319	H();
5320	}
5321
5322
5323	CoTaskMemFree(pswzBindName);
5324
5325	/* The old NDIS5.1 version of driver uses TRUNKTYPE_NETADP */
5326	trunkType = IsNdis6() ? TRUNKTYPE_NETFLT : TRUNKTYPE_NETADP;
5327	InsertConfigInteger(pCfg, "TrunkType", trunkType == TRUNKTYPE_NETFLT ? kIntNetTrunkType_NetFlt : kIntNetTrunkType_NetAdp);
5328
5329	pAdaptorComponent.setNull();
5330	/* release the pNc finally */
5331	VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /fHasWriteLock/);
5332
5333	const char *pszTrunk = szTrunkName;
5334
5335	InsertConfigString(pCfg, "Trunk", pszTrunk);
5336	InsertConfigString(pCfg, "Network", szNetwork);
5337	InsertConfigInteger(pCfg, "IgnoreConnectFailure", (uint64_t)fIgnoreConnectFailure); /** @todo why is this
5338	windows only?? */
5339	networkName = Bstr(szNetwork);
5340	trunkName = Bstr(pszTrunk);
5341	# endif /* defined VBOX_WITH_NETFLT*/
5342	#elif defined(RT_OS_DARWIN)
5343	InsertConfigString(pCfg, "Trunk", pszHostOnlyName);
5344	InsertConfigString(pCfg, "Network", szNetwork);
5345	InsertConfigInteger(pCfg, "TrunkType", kIntNetTrunkType_NetAdp);
5346	networkName = Bstr(szNetwork);
5347	trunkName = Bstr(pszHostOnlyName);
5348	trunkType = TRUNKTYPE_NETADP;
5349	#else
5350	InsertConfigString(pCfg, "Trunk", pszHostOnlyName);
5351	InsertConfigString(pCfg, "Network", szNetwork);
5352	InsertConfigInteger(pCfg, "TrunkType", kIntNetTrunkType_NetFlt);
5353	networkName = Bstr(szNetwork);
5354	trunkName = Bstr(pszHostOnlyName);
5355	trunkType = TRUNKTYPE_NETFLT;
5356	#endif
5357	InsertConfigString(pCfg, "IfPolicyPromisc", pszPromiscuousGuestPolicy);
5358
5359	#if !defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
5360
5361	Bstr tmpAddr, tmpMask;
5362
5363	hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPAddress",
5364	pszHostOnlyName).raw(),
5365	tmpAddr.asOutParam());
5366	if (SUCCEEDED(hrc) && !tmpAddr.isEmpty())
5367	{
5368	hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPNetMask",
5369	pszHostOnlyName).raw(),
5370	tmpMask.asOutParam());
5371	if (SUCCEEDED(hrc) && !tmpMask.isEmpty())
5372	hrc = hostInterface->EnableStaticIPConfig(tmpAddr.raw(),
5373	tmpMask.raw());
5374	else
5375	hrc = hostInterface->EnableStaticIPConfig(tmpAddr.raw(),
5376	Bstr(VBOXNET_IPV4MASK_DEFAULT).raw());
5377	}
5378	else
5379	{
5380	/* Grab the IP number from the 'vboxnetX' instance number (see netif.h) */
5381	hrc = hostInterface->EnableStaticIPConfig(getDefaultIPv4Address(Bstr(pszHostOnlyName)).raw(),
5382	Bstr(VBOXNET_IPV4MASK_DEFAULT).raw());
5383	}
5384
5385	ComAssertComRC(hrc); /** @todo r=bird: Why this isn't fatal? (H()) */
5386
5387	hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPV6Address",
5388	pszHostOnlyName).raw(),
5389	tmpAddr.asOutParam());
5390	if (SUCCEEDED(hrc))
5391	hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPV6NetMask", pszHostOnlyName).raw(),
5392	tmpMask.asOutParam());
5393	if (SUCCEEDED(hrc) && !tmpAddr.isEmpty() && !tmpMask.isEmpty())
5394	{
5395	hrc = hostInterface->EnableStaticIPConfigV6(tmpAddr.raw(),
5396	Utf8Str(tmpMask).toUInt32());
5397	ComAssertComRC(hrc); /** @todo r=bird: Why this isn't fatal? (H()) */
5398	}
5399	#endif
5400	break;
5401	}
5402
5403	case NetworkAttachmentType_Generic:
5404	{
5405	hrc = aNetworkAdapter->COMGETTER(GenericDriver)(bstr.asOutParam()); H();
5406	SafeArray<BSTR> names;
5407	SafeArray<BSTR> values;
5408	hrc = aNetworkAdapter->GetProperties(Bstr().raw(),
5409	ComSafeArrayAsOutParam(names),
5410	ComSafeArrayAsOutParam(values)); H();
5411
5412	InsertConfigString(pLunL0, "Driver", bstr);
5413	InsertConfigNode(pLunL0, "Config", &pCfg);
5414	for (size_t ii = 0; ii < names.size(); ++ii)
5415	{
5416	if (values[ii] && *values[ii])
5417	{
5418	Utf8Str name = names[ii];
5419	Utf8Str value = values[ii];
5420	InsertConfigString(pCfg, name.c_str(), value);
5421	}
5422	}
5423	break;
5424	}
5425
5426	case NetworkAttachmentType_NATNetwork:
5427	{
5428	hrc = aNetworkAdapter->COMGETTER(NATNetwork)(bstr.asOutParam()); H();
5429	if (!bstr.isEmpty())
5430	{
5431	/** @todo add intnet prefix to separate namespaces, and add trunk if dealing with vboxnatX */
5432	InsertConfigString(pLunL0, "Driver", "IntNet");
5433	InsertConfigNode(pLunL0, "Config", &pCfg);
5434	InsertConfigString(pCfg, "Network", bstr);
5435	InsertConfigInteger(pCfg, "TrunkType", kIntNetTrunkType_WhateverNone);
5436	InsertConfigString(pCfg, "IfPolicyPromisc", pszPromiscuousGuestPolicy);
5437	networkName = bstr;
5438	trunkType = Bstr(TRUNKTYPE_WHATEVER);
5439	}
5440	break;
5441	}
5442
5443	default:
5444	AssertMsgFailed(("should not get here!\n"));
5445	break;
5446	}
5447
5448	/*
5449	* Attempt to attach the driver.
5450	*/
5451	switch (eAttachmentType)
5452	{
5453	case NetworkAttachmentType_Null:
5454	break;
5455
5456	case NetworkAttachmentType_Bridged:
5457	case NetworkAttachmentType_Internal:
5458	case NetworkAttachmentType_HostOnly:
5459	case NetworkAttachmentType_NAT:
5460	case NetworkAttachmentType_Generic:
5461	case NetworkAttachmentType_NATNetwork:
5462	{
5463	if (SUCCEEDED(hrc) && SUCCEEDED(rc))
5464	{
5465	if (fAttachDetach)
5466	{
5467	rc = PDMR3DriverAttach(mpUVM, pszDevice, uInstance, uLun, 0 /fFlags/, NULL /* ppBase */);
5468	//AssertRC(rc);
5469	}
5470
5471	{
5472	/** @todo pritesh: get the dhcp server name from the
5473	* previous network configuration and then stop the server
5474	* else it may conflict with the dhcp server running with
5475	* the current attachment type
5476	*/
5477	/* Stop the hostonly DHCP Server */
5478	}
5479
5480	/*
5481	* NAT networks start their DHCP server theirself, see NATNetwork::Start()
5482	*/
5483	if ( !networkName.isEmpty()
5484	&& eAttachmentType != NetworkAttachmentType_NATNetwork)
5485	{
5486	/*
5487	* Until we implement service reference counters DHCP Server will be stopped
5488	* by DHCPServerRunner destructor.
5489	*/
5490	ComPtr<IDHCPServer> dhcpServer;
5491	hrc = virtualBox->FindDHCPServerByNetworkName(networkName.raw(),
5492	dhcpServer.asOutParam());
5493	if (SUCCEEDED(hrc))
5494	{
5495	/* there is a DHCP server available for this network */
5496	BOOL fEnabledDhcp;
5497	hrc = dhcpServer->COMGETTER(Enabled)(&fEnabledDhcp);
5498	if (FAILED(hrc))
5499	{
5500	LogRel(("DHCP svr: COMGETTER(Enabled) failed, hrc (%Rhrc)\n", hrc));
5501	H();
5502	}
5503
5504	if (fEnabledDhcp)
5505	hrc = dhcpServer->Start(networkName.raw(),
5506	trunkName.raw(),
5507	trunkType.raw());
5508	}
5509	else
5510	hrc = S_OK;
5511	}
5512	}
5513
5514	break;
5515	}
5516
5517	default:
5518	AssertMsgFailed(("should not get here!\n"));
5519	break;
5520	}
5521
5522	meAttachmentType[uInstance] = eAttachmentType;
5523	}
5524	catch (ConfigError &x)
5525	{
5526	// InsertConfig threw something:
5527	return x.m_vrc;
5528	}
5529
5530	#undef H
5531
5532	return VINF_SUCCESS;
5533	}
5534
5535	#ifdef VBOX_WITH_GUEST_PROPS
5536	/**
5537	* Set an array of guest properties
5538	*/
5539	static void configSetProperties(VMMDev * const pVMMDev,
5540	void *names,
5541	void *values,
5542	void *timestamps,
5543	void *flags)
5544	{
5545	VBOXHGCMSVCPARM parms[4];
5546
5547	parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
5548	parms[0].u.pointer.addr = names;
5549	parms[0].u.pointer.size = 0; /* We don't actually care. */
5550	parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
5551	parms[1].u.pointer.addr = values;
5552	parms[1].u.pointer.size = 0; /* We don't actually care. */
5553	parms[2].type = VBOX_HGCM_SVC_PARM_PTR;
5554	parms[2].u.pointer.addr = timestamps;
5555	parms[2].u.pointer.size = 0; /* We don't actually care. */
5556	parms[3].type = VBOX_HGCM_SVC_PARM_PTR;
5557	parms[3].u.pointer.addr = flags;
5558	parms[3].u.pointer.size = 0; /* We don't actually care. */
5559
5560	pVMMDev->hgcmHostCall("VBoxGuestPropSvc",
5561	guestProp::SET_PROPS_HOST,
5562	4,
5563	&parms[0]);
5564	}
5565
5566	/**
5567	* Set a single guest property
5568	*/
5569	static void configSetProperty(VMMDev * const pVMMDev,
5570	const char *pszName,
5571	const char *pszValue,
5572	const char *pszFlags)
5573	{
5574	VBOXHGCMSVCPARM parms[4];
5575
5576	AssertPtrReturnVoid(pszName);
5577	AssertPtrReturnVoid(pszValue);
5578	AssertPtrReturnVoid(pszFlags);
5579	parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
5580	parms[0].u.pointer.addr = (void *)pszName;
5581	parms[0].u.pointer.size = (uint32_t)strlen(pszName) + 1;
5582	parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
5583	parms[1].u.pointer.addr = (void *)pszValue;
5584	parms[1].u.pointer.size = (uint32_t)strlen(pszValue) + 1;
5585	parms[2].type = VBOX_HGCM_SVC_PARM_PTR;
5586	parms[2].u.pointer.addr = (void *)pszFlags;
5587	parms[2].u.pointer.size = (uint32_t)strlen(pszFlags) + 1;
5588	pVMMDev->hgcmHostCall("VBoxGuestPropSvc", guestProp::SET_PROP_HOST, 3,
5589	&parms[0]);
5590	}
5591
5592	/**
5593	* Set the global flags value by calling the service
5594	* @returns the status returned by the call to the service
5595	*
5596	* @param pTable the service instance handle
5597	* @param eFlags the flags to set
5598	*/
5599	int configSetGlobalPropertyFlags(VMMDev * const pVMMDev,
5600	guestProp::ePropFlags eFlags)
5601	{
5602	VBOXHGCMSVCPARM paParm;
5603	paParm.setUInt32(eFlags);
5604	int rc = pVMMDev->hgcmHostCall("VBoxGuestPropSvc",
5605	guestProp::SET_GLOBAL_FLAGS_HOST, 1,
5606	&paParm);
5607	if (RT_FAILURE(rc))
5608	{
5609	char szFlags[guestProp::MAX_FLAGS_LEN];
5610	if (RT_FAILURE(writeFlags(eFlags, szFlags)))
5611	Log(("Failed to set the global flags.\n"));
5612	else
5613	Log(("Failed to set the global flags \"%s\".\n", szFlags));
5614	}
5615	return rc;
5616	}
5617	#endif /* VBOX_WITH_GUEST_PROPS */
5618
5619	/**
5620	* Set up the Guest Property service, populate it with properties read from
5621	* the machine XML and set a couple of initial properties.
5622	*/
5623	/* static / int Console::i_configGuestProperties(void pvConsole, PUVM pUVM)
5624	{
5625	#ifdef VBOX_WITH_GUEST_PROPS
5626	AssertReturn(pvConsole, VERR_INVALID_POINTER);
5627	ComObjPtr<Console> pConsole = static_cast<Console *>(pvConsole);
5628	AssertReturn(pConsole->m_pVMMDev, VERR_INVALID_POINTER);
5629
5630	/* Load the service */
5631	int rc = pConsole->m_pVMMDev->hgcmLoadService("VBoxGuestPropSvc", "VBoxGuestPropSvc");
5632
5633	if (RT_FAILURE(rc))
5634	{
5635	LogRel(("VBoxGuestPropSvc is not available. rc = %Rrc\n", rc));
5636	/* That is not a fatal failure. */
5637	rc = VINF_SUCCESS;
5638	}
5639	else
5640	{
5641	/*
5642	* Initialize built-in properties that can be changed and saved.
5643	*
5644	* These are typically transient properties that the guest cannot
5645	* change.
5646	*/
5647
5648	{
5649	VBOXHGCMSVCPARM Params[2];
5650	int rc2 = pConsole->m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", guestProp::GET_DBGF_INFO_FN, 2, &Params[0]);
5651	if (RT_SUCCESS(rc2))
5652	{
5653	PFNDBGFHANDLEREXT pfnHandler = (PFNDBGFHANDLEREXT)(uintptr_t)Params[0].u.pointer.addr;
5654	void pService = (void)Params[1].u.pointer.addr;
5655	DBGFR3InfoRegisterExternal(pUVM, "guestprops", "Display the guest properties", pfnHandler, pService);
5656	}
5657	}
5658
5659	/* Sysprep execution by VBoxService. */
5660	configSetProperty(pConsole->m_pVMMDev,
5661	"/VirtualBox/HostGuest/SysprepExec", "",
5662	"TRANSIENT, RDONLYGUEST");
5663	configSetProperty(pConsole->m_pVMMDev,
5664	"/VirtualBox/HostGuest/SysprepArgs", "",
5665	"TRANSIENT, RDONLYGUEST");
5666
5667	/*
5668	* Pull over the properties from the server.
5669	*/
5670	SafeArray<BSTR> namesOut;
5671	SafeArray<BSTR> valuesOut;
5672	SafeArray<LONG64> timestampsOut;
5673	SafeArray<BSTR> flagsOut;
5674	HRESULT hrc;
5675	hrc = pConsole->mControl->PullGuestProperties(ComSafeArrayAsOutParam(namesOut),
5676	ComSafeArrayAsOutParam(valuesOut),
5677	ComSafeArrayAsOutParam(timestampsOut),
5678	ComSafeArrayAsOutParam(flagsOut));
5679	AssertLogRelMsgReturn(SUCCEEDED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR);
5680	size_t cProps = namesOut.size();
5681	size_t cAlloc = cProps + 1;
5682	if ( valuesOut.size() != cProps
5683	\|\| timestampsOut.size() != cProps
5684	\|\| flagsOut.size() != cProps
5685	)
5686	AssertFailedReturn(VERR_INVALID_PARAMETER);
5687
5688	char papszNames, papszValues, **papszFlags;
5689	char szEmpty[] = "";
5690	LONG64 *pai64Timestamps;
5691	papszNames = (char *)RTMemTmpAllocZ(sizeof(void ) * cAlloc);
5692	papszValues = (char *)RTMemTmpAllocZ(sizeof(void ) * cAlloc);
5693	pai64Timestamps = (LONG64 )RTMemTmpAllocZ(sizeof(LONG64) cAlloc);
5694	papszFlags = (char *)RTMemTmpAllocZ(sizeof(void ) * cAlloc);
5695	if (papszNames && papszValues && pai64Timestamps && papszFlags)
5696	{
5697	for (unsigned i = 0; RT_SUCCESS(rc) && i < cProps; ++i)
5698	{
5699	AssertPtrBreakStmt(namesOut[i], rc = VERR_INVALID_PARAMETER);
5700	rc = RTUtf16ToUtf8(namesOut[i], &papszNames[i]);
5701	if (RT_FAILURE(rc))
5702	break;
5703	if (valuesOut[i])
5704	rc = RTUtf16ToUtf8(valuesOut[i], &papszValues[i]);
5705	else
5706	papszValues[i] = szEmpty;
5707	if (RT_FAILURE(rc))
5708	break;
5709	pai64Timestamps[i] = timestampsOut[i];
5710	if (flagsOut[i])
5711	rc = RTUtf16ToUtf8(flagsOut[i], &papszFlags[i]);
5712	else
5713	papszFlags[i] = szEmpty;
5714	}
5715	if (RT_SUCCESS(rc))
5716	configSetProperties(pConsole->m_pVMMDev,
5717	(void *)papszNames,
5718	(void *)papszValues,
5719	(void *)pai64Timestamps,
5720	(void *)papszFlags);
5721	for (unsigned i = 0; i < cProps; ++i)
5722	{
5723	RTStrFree(papszNames[i]);
5724	if (valuesOut[i])
5725	RTStrFree(papszValues[i]);
5726	if (flagsOut[i])
5727	RTStrFree(papszFlags[i]);
5728	}
5729	}
5730	else
5731	rc = VERR_NO_MEMORY;
5732	RTMemTmpFree(papszNames);
5733	RTMemTmpFree(papszValues);
5734	RTMemTmpFree(pai64Timestamps);
5735	RTMemTmpFree(papszFlags);
5736	AssertRCReturn(rc, rc);
5737
5738	/*
5739	* These properties have to be set before pulling over the properties
5740	* from the machine XML, to ensure that properties saved in the XML
5741	* will override them.
5742	*/
5743	/* Set the raw VBox version string as a guest property. Used for host/guest
5744	* version comparison. */
5745	configSetProperty(pConsole->m_pVMMDev, "/VirtualBox/HostInfo/VBoxVer",
5746	VBOX_VERSION_STRING_RAW, "TRANSIENT, RDONLYGUEST");
5747	/* Set the full VBox version string as a guest property. Can contain vendor-specific
5748	* information/branding and/or pre-release tags. */
5749	configSetProperty(pConsole->m_pVMMDev, "/VirtualBox/HostInfo/VBoxVerExt",
5750	VBOX_VERSION_STRING, "TRANSIENT, RDONLYGUEST");
5751	/* Set the VBox SVN revision as a guest property */
5752	configSetProperty(pConsole->m_pVMMDev, "/VirtualBox/HostInfo/VBoxRev",
5753	RTBldCfgRevisionStr(), "TRANSIENT, RDONLYGUEST");
5754
5755	/*
5756	* Register the host notification callback
5757	*/
5758	HGCMSVCEXTHANDLE hDummy;
5759	HGCMHostRegisterServiceExtension(&hDummy, "VBoxGuestPropSvc",
5760	Console::i_doGuestPropNotification,
5761	pvConsole);
5762
5763	#ifdef VBOX_WITH_GUEST_PROPS_RDONLY_GUEST
5764	rc = configSetGlobalPropertyFlags(pConsole->m_pVMMDev,
5765	guestProp::RDONLYGUEST);
5766	AssertRCReturn(rc, rc);
5767	#endif
5768
5769	Log(("Set VBoxGuestPropSvc property store\n"));
5770	}
5771	return VINF_SUCCESS;
5772	#else /* !VBOX_WITH_GUEST_PROPS */
5773	return VERR_NOT_SUPPORTED;
5774	#endif /* !VBOX_WITH_GUEST_PROPS */
5775	}
5776
5777	/**
5778	* Set up the Guest Control service.
5779	*/
5780	/* static / int Console::i_configGuestControl(void pvConsole)
5781	{
5782	#ifdef VBOX_WITH_GUEST_CONTROL
5783	AssertReturn(pvConsole, VERR_INVALID_POINTER);
5784	ComObjPtr<Console> pConsole = static_cast<Console *>(pvConsole);
5785
5786	/* Load the service */
5787	int rc = pConsole->m_pVMMDev->hgcmLoadService("VBoxGuestControlSvc", "VBoxGuestControlSvc");
5788
5789	if (RT_FAILURE(rc))
5790	{
5791	LogRel(("VBoxGuestControlSvc is not available. rc = %Rrc\n", rc));
5792	/* That is not a fatal failure. */
5793	rc = VINF_SUCCESS;
5794	}
5795	else
5796	{
5797	HGCMSVCEXTHANDLE hDummy;
5798	rc = HGCMHostRegisterServiceExtension(&hDummy, "VBoxGuestControlSvc",
5799	&Guest::i_notifyCtrlDispatcher,
5800	pConsole->i_getGuest());
5801	if (RT_FAILURE(rc))
5802	Log(("Cannot register VBoxGuestControlSvc extension!\n"));
5803	else
5804	LogRel(("Guest Control service loaded\n"));
5805	}
5806
5807	return rc;
5808	#else /* !VBOX_WITH_GUEST_CONTROL */
5809	return VERR_NOT_SUPPORTED;
5810	#endif /* !VBOX_WITH_GUEST_CONTROL */
5811	}

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

source: vbox/trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp@ 56616

Download in other formats: