ConsoleImpl2.cpp@ 56268

Last change on this file since 56268 was 56268, checked in by vboxsync, 10 years ago
Main/Console: improved NDIS version detection (#7849)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 238.6 KB

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

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

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

Download in other formats: