ConsoleImpl2.cpp@ 51092

最後變更在這個檔案從51092是 51092,由 vboxsync 提交於 11 年前
6813 src-client/MachineDebuggerImpl.cpp + various formatting changes
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 230.0 KB

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

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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

以其他格式下載: