ConsoleImpl2.cpp@ 59090

Last change on this file since 59090 was 58959, checked in by vboxsync, 9 years ago
Main: Fix starting a VM with a physical PCI device attached. The assignment->COMGETTER(...) calls failed unnoticed with E_ACCESSDENIED producing bogues PCI addresses
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 244.1 KB

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

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

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

Download in other formats: