ConsoleImpl2.cpp@ 58056

Last change on this file since 58056 was 58056, checked in by vboxsync, 9 years ago
Main/ConsoleImpl2: Make the default Hyper-V debug port, same as Windbg kernel debug network port. Less typing during setting up debugging.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 241.3 KB

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

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

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

Download in other formats: