ConsoleImpl2.cpp@ 61888

Last change on this file since 61888 was 61778, checked in by vboxsync, 8 years ago
ConsoleImpl2.cpp: Maybe gcc is used uninitialized warnings.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 245.0 KB

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

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

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

Download in other formats: