ConsoleImpl2.cpp@ 58437

Last change on this file since 58437 was 58437, checked in by vboxsync, 9 years ago
Main: Added paravirtdebug options.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 243.9 KB

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

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

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

Download in other formats: