ConsoleImpl2.cpp@ 64508

Last change on this file since 64508 was 64508, checked in by vboxsync, 9 years ago
Audio: Added Validation Kit skeleton driver. Use with VBOX_WITH_AUDIO_VALIDATIONKIT set. Needs to be modifiable at runtime later.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 251.4 KB

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

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

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

Download in other formats: