ConsoleImpl2.cpp@ 49312

Last change on this file since 49312 was 49190, checked in by vboxsync, 11 years ago
Main,VBoxManage: Implement hotpluggable setting stubs
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 221.7 KB

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

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

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

Download in other formats: