ConsoleImpl2.cpp@ 56148

Last change on this file since 56148 was 56148, checked in by vboxsync, 10 years ago
Audio: use the VM name to name PulseAudio streams
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 238.3 KB

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

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

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

Download in other formats: