ConsoleImpl2.cpp@ 51804

Last change on this file since 51804 was 51804, checked in by vboxsync, 11 years ago
Main/src-client: Fix GIM provider for default/legacy OS X VMs.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 230.6 KB

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

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

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

Download in other formats: