ConsoleImpl2.cpp@ 7982

Last change on this file since 7982 was 7982, checked in by vboxsync, 17 years ago
Added setting for guest PAE (default off)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 81.2 KB

Line
1	/** $Id: ConsoleImpl2.cpp 7982 2008-04-15 12:32:02Z vboxsync $ */
2	/** @file
3	* VBox Console COM Class implementation
4	*
5	* @remark We've split out the code that the 64-bit VC++ v8 compiler
6	* finds problematic to optimize so we can disable optimizations
7	* and later, perhaps, find a real solution for it.
8	*/
9
10	/*
11	* Copyright (C) 2006-2007 innotek GmbH
12	*
13	* This file is part of VirtualBox Open Source Edition (OSE), as
14	* available from http://www.virtualbox.org. This file is free software;
15	* you can redistribute it and/or modify it under the terms of the GNU
16	* General Public License (GPL) as published by the Free Software
17	* Foundation, in version 2 as it comes in the "COPYING" file of the
18	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20	*/
21
22	/*******************************************************************************
23	* Header Files *
24	*******************************************************************************/
25	#include "ConsoleImpl.h"
26	#include "DisplayImpl.h"
27	#include "VMMDev.h"
28
29	// generated header
30	#include "SchemaDefs.h"
31
32	#include "Logging.h"
33
34	#include <iprt/string.h>
35	#include <iprt/path.h>
36	#include <iprt/dir.h>
37	#include <iprt/param.h>
38
39	#include <VBox/vmapi.h>
40	#include <VBox/err.h>
41	#include <VBox/version.h>
42	#include <VBox/HostServices/VBoxClipboardSvc.h>
43
44
45	/*
46	* VC++ 8 / amd64 has some serious trouble with this function.
47	* As a temporary measure, we'll drop global optimizations.
48	*/
49	#if defined(_MSC_VER) && defined(RT_ARCH_AMD64)
50	# pragma optimize("g", off)
51	#endif
52
53	/**
54	* Construct the VM configuration tree (CFGM).
55	*
56	* This is a callback for VMR3Create() call. It is called from CFGMR3Init()
57	* in the emulation thread (EMT). Any per thread COM/XPCOM initialization
58	* is done here.
59	*
60	* @param pVM VM handle.
61	* @param pvConsole Pointer to the VMPowerUpTask object.
62	* @return VBox status code.
63	*
64	* @note Locks the Console object for writing.
65	*/
66	DECLCALLBACK(int) Console::configConstructor(PVM pVM, void *pvConsole)
67	{
68	LogFlowFuncEnter();
69	/* Note: hardcoded assumption about number of slots; see rom bios */
70	bool afPciDeviceNo[15] = {false};
71
72	#if !defined (VBOX_WITH_XPCOM)
73	{
74	/* initialize COM */
75	HRESULT hrc = CoInitializeEx(NULL,
76	COINIT_MULTITHREADED \| COINIT_DISABLE_OLE1DDE \|
77	COINIT_SPEED_OVER_MEMORY);
78	LogFlow (("Console::configConstructor(): CoInitializeEx()=%08X\n", hrc));
79	AssertComRCReturn (hrc, VERR_GENERAL_FAILURE);
80	}
81	#endif
82
83	AssertReturn (pvConsole, VERR_GENERAL_FAILURE);
84	ComObjPtr <Console> pConsole = static_cast <Console *> (pvConsole);
85
86	AutoCaller autoCaller (pConsole);
87	AssertComRCReturn (autoCaller.rc(), VERR_ACCESS_DENIED);
88
89	/* lock the console because we widely use internal fields and methods */
90	AutoLock alock (pConsole);
91
92	ComPtr <IMachine> pMachine = pConsole->machine();
93
94	int rc;
95	HRESULT hrc;
96	char *psz = NULL;
97	BSTR str = NULL;
98
99	#define STR_CONV() do { rc = RTUtf16ToUtf8(str, &psz); RC_CHECK(); } while (0)
100	#define STR_FREE() do { if (str) { SysFreeString(str); str = NULL; } if (psz) { RTStrFree(psz); psz = NULL; } } while (0)
101	#define RC_CHECK() do { if (VBOX_FAILURE(rc)) { AssertMsgFailed(("rc=%Vrc\n", rc)); STR_FREE(); return rc; } } while (0)
102	#define H() do { if (FAILED(hrc)) { AssertMsgFailed(("hrc=%#x\n", hrc)); STR_FREE(); return VERR_GENERAL_FAILURE; } } while (0)
103
104	/*
105	* Get necessary objects and frequently used parameters.
106	*/
107	ComPtr<IVirtualBox> virtualBox;
108	hrc = pMachine->COMGETTER(Parent)(virtualBox.asOutParam()); H();
109
110	ComPtr<IHost> host;
111	hrc = virtualBox->COMGETTER(Host)(host.asOutParam()); H();
112
113	ComPtr <ISystemProperties> systemProperties;
114	hrc = virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam()); H();
115
116	ComPtr<IBIOSSettings> biosSettings;
117	hrc = pMachine->COMGETTER(BIOSSettings)(biosSettings.asOutParam()); H();
118
119	Guid uuid;
120	hrc = pMachine->COMGETTER(Id)(uuid.asOutParam()); H();
121	PCRTUUID pUuid = uuid.raw();
122
123	ULONG cRamMBs;
124	hrc = pMachine->COMGETTER(MemorySize)(&cRamMBs); H();
125
126
127	/*
128	* Get root node first.
129	* This is the only node in the tree.
130	*/
131	PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
132	Assert(pRoot);
133
134	/*
135	* Set the root level values.
136	*/
137	hrc = pMachine->COMGETTER(Name)(&str); H();
138	STR_CONV();
139	rc = CFGMR3InsertString(pRoot, "Name", psz); RC_CHECK();
140	STR_FREE();
141	rc = CFGMR3InsertBytes(pRoot, "UUID", pUuid, sizeof(*pUuid)); RC_CHECK();
142	rc = CFGMR3InsertInteger(pRoot, "RamSize", cRamMBs * _1M); RC_CHECK();
143	rc = CFGMR3InsertInteger(pRoot, "TimerMillies", 10); RC_CHECK();
144	rc = CFGMR3InsertInteger(pRoot, "RawR3Enabled", 1); /* boolean */ RC_CHECK();
145	rc = CFGMR3InsertInteger(pRoot, "RawR0Enabled", 1); /* boolean */ RC_CHECK();
146	/** @todo Config: RawR0, PATMEnabled and CASMEnabled needs attention later. */
147	rc = CFGMR3InsertInteger(pRoot, "PATMEnabled", 1); /* boolean */ RC_CHECK();
148	rc = CFGMR3InsertInteger(pRoot, "CSAMEnabled", 1); /* boolean */ RC_CHECK();
149
150	/* hardware virtualization extensions */
151	TSBool_T hwVirtExEnabled;
152	BOOL fHWVirtExEnabled;
153	hrc = pMachine->COMGETTER(HWVirtExEnabled)(&hwVirtExEnabled); H();
154	if (hwVirtExEnabled == TSBool_Default)
155	{
156	/* check the default value */
157	hrc = systemProperties->COMGETTER(HWVirtExEnabled)(&fHWVirtExEnabled); H();
158	}
159	else
160	fHWVirtExEnabled = (hwVirtExEnabled == TSBool_True);
161	#ifndef RT_OS_DARWIN /** @todo Implement HWVirtExt on darwin. See #1865. */
162	if (fHWVirtExEnabled)
163	{
164	PCFGMNODE pHWVirtExt;
165	rc = CFGMR3InsertNode(pRoot, "HWVirtExt", &pHWVirtExt); RC_CHECK();
166	rc = CFGMR3InsertInteger(pHWVirtExt, "Enabled", 1); RC_CHECK();
167	}
168	#endif
169
170	/* Physical Address Extension (PAE) */
171	BOOL fEnablePAE = false;
172	hrc = pMachine->COMGETTER(PAEEnabled)(&fEnablePAE); H();
173	rc = CFGMR3InsertInteger(pRoot, "EnablePAE", fEnablePAE); RC_CHECK();
174
175	BOOL fIOAPIC;
176	hrc = biosSettings->COMGETTER(IOAPICEnabled)(&fIOAPIC); H();
177
178	BOOL fPXEDebug;
179	hrc = biosSettings->COMGETTER(PXEDebugEnabled)(&fPXEDebug); H();
180
181	/*
182	* Virtual IDE controller type.
183	*/
184	IDEControllerType_T controllerType;
185	BOOL fPIIX4;
186	hrc = biosSettings->COMGETTER(IDEControllerType)(&controllerType); H();
187	switch (controllerType)
188	{
189	case IDEControllerType_PIIX3:
190	fPIIX4 = FALSE;
191	break;
192	case IDEControllerType_PIIX4:
193	fPIIX4 = TRUE;
194	break;
195	default:
196	AssertMsgFailed(("Invalid IDE controller type '%d'", controllerType));
197	return VERR_INVALID_PARAMETER;
198	}
199
200	/*
201	* PDM config.
202	* Load drivers in VBoxC.[so\|dll]
203	*/
204	PCFGMNODE pPDM;
205	PCFGMNODE pDrivers;
206	PCFGMNODE pMod;
207	rc = CFGMR3InsertNode(pRoot, "PDM", &pPDM); RC_CHECK();
208	rc = CFGMR3InsertNode(pPDM, "Drivers", &pDrivers); RC_CHECK();
209	rc = CFGMR3InsertNode(pDrivers, "VBoxC", &pMod); RC_CHECK();
210	#ifdef VBOX_WITH_XPCOM
211	// VBoxC is located in the components subdirectory
212	char szPathVBoxC[RTPATH_MAX];
213	rc = RTPathAppPrivateArch(szPathVBoxC, RTPATH_MAX - sizeof("/components/VBoxC")); AssertRC(rc);
214	strcat(szPathVBoxC, "/components/VBoxC");
215	rc = CFGMR3InsertString(pMod, "Path", szPathVBoxC); RC_CHECK();
216	#else
217	rc = CFGMR3InsertString(pMod, "Path", "VBoxC"); RC_CHECK();
218	#endif
219
220	/*
221	* Devices
222	*/
223	PCFGMNODE pDevices = NULL; /* /Devices */
224	PCFGMNODE pDev = NULL; /* /Devices/Dev/ */
225	PCFGMNODE pInst = NULL; /* /Devices/Dev/0/ */
226	PCFGMNODE pCfg = NULL; /* /Devices/Dev/.../Config/ */
227	PCFGMNODE pLunL0 = NULL; /* /Devices/Dev/0/LUN#0/ */
228	PCFGMNODE pLunL1 = NULL; /* /Devices/Dev/0/LUN#0/AttachedDriver/ */
229	PCFGMNODE pLunL2 = NULL; /* /Devices/Dev/0/LUN#0/AttachedDriver/Config/ */
230	PCFGMNODE pIdeInst = NULL; /* /Devices/piix3ide/0/ */
231	PCFGMNODE pSataInst = NULL; /* /Devices/ahci/0/ */
232	PCFGMNODE pBiosCfg = NULL; /* /Devices/pcbios/0/Config/ */
233
234	rc = CFGMR3InsertNode(pRoot, "Devices", &pDevices); RC_CHECK();
235
236	/*
237	* PC Arch.
238	*/
239	rc = CFGMR3InsertNode(pDevices, "pcarch", &pDev); RC_CHECK();
240	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
241	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
242	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
243
244	/*
245	* PC Bios.
246	*/
247	rc = CFGMR3InsertNode(pDevices, "pcbios", &pDev); RC_CHECK();
248	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
249	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
250	rc = CFGMR3InsertNode(pInst, "Config", &pBiosCfg); RC_CHECK();
251	rc = CFGMR3InsertInteger(pBiosCfg, "RamSize", cRamMBs * _1M); RC_CHECK();
252	rc = CFGMR3InsertString(pBiosCfg, "HardDiskDevice", "piix3ide"); RC_CHECK();
253	rc = CFGMR3InsertString(pBiosCfg, "FloppyDevice", "i82078"); RC_CHECK();
254	rc = CFGMR3InsertInteger(pBiosCfg, "IOAPIC", fIOAPIC); RC_CHECK();
255	rc = CFGMR3InsertInteger(pBiosCfg, "PXEDebug", fPXEDebug); RC_CHECK();
256	rc = CFGMR3InsertBytes(pBiosCfg, "UUID", pUuid, sizeof(*pUuid)); RC_CHECK();
257
258	DeviceType_T bootDevice;
259	if (SchemaDefs::MaxBootPosition > 9)
260	{
261	AssertMsgFailed (("Too many boot devices %d\n",
262	SchemaDefs::MaxBootPosition));
263	return VERR_INVALID_PARAMETER;
264	}
265
266	for (ULONG pos = 1; pos <= SchemaDefs::MaxBootPosition; pos ++)
267	{
268	hrc = pMachine->GetBootOrder(pos, &bootDevice); H();
269
270	char szParamName[] = "BootDeviceX";
271	szParamName[sizeof (szParamName) - 2] = ((char (pos - 1)) + '0');
272
273	const char *pszBootDevice;
274	switch (bootDevice)
275	{
276	case DeviceType_Null:
277	pszBootDevice = "NONE";
278	break;
279	case DeviceType_HardDisk:
280	pszBootDevice = "IDE";
281	break;
282	case DeviceType_DVD:
283	pszBootDevice = "DVD";
284	break;
285	case DeviceType_Floppy:
286	pszBootDevice = "FLOPPY";
287	break;
288	case DeviceType_Network:
289	pszBootDevice = "LAN";
290	break;
291	default:
292	AssertMsgFailed(("Invalid bootDevice=%d\n", bootDevice));
293	return VERR_INVALID_PARAMETER;
294	}
295	rc = CFGMR3InsertString(pBiosCfg, szParamName, pszBootDevice); RC_CHECK();
296	}
297
298	/*
299	* The time offset
300	*/
301	LONG64 timeOffset;
302	hrc = biosSettings->COMGETTER(TimeOffset)(&timeOffset); H();
303	PCFGMNODE pTMNode;
304	rc = CFGMR3InsertNode(pRoot, "TM", &pTMNode); RC_CHECK();
305	rc = CFGMR3InsertInteger(pTMNode, "UTCOffset", timeOffset * 1000000); RC_CHECK();
306
307	/*
308	* ACPI
309	*/
310	BOOL fACPI;
311	hrc = biosSettings->COMGETTER(ACPIEnabled)(&fACPI); H();
312	if (fACPI)
313	{
314	rc = CFGMR3InsertNode(pDevices, "acpi", &pDev); RC_CHECK();
315	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
316	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
317	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
318	rc = CFGMR3InsertInteger(pCfg, "RamSize", cRamMBs * _1M); RC_CHECK();
319	rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); RC_CHECK();
320	rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 7); RC_CHECK();
321	Assert(!afPciDeviceNo[7]);
322	afPciDeviceNo[7] = true;
323	rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
324
325	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
326	rc = CFGMR3InsertString(pLunL0, "Driver", "ACPIHost"); RC_CHECK();
327	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
328	}
329
330	/*
331	* DMA
332	*/
333	rc = CFGMR3InsertNode(pDevices, "8237A", &pDev); RC_CHECK();
334	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
335	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
336
337	/*
338	* PCI bus.
339	*/
340	rc = CFGMR3InsertNode(pDevices, "pci", &pDev); /* piix3 */ RC_CHECK();
341	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
342	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
343	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
344	rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); RC_CHECK();
345
346	/*
347	* PS/2 keyboard & mouse.
348	*/
349	rc = CFGMR3InsertNode(pDevices, "pckbd", &pDev); RC_CHECK();
350	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
351	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
352	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
353
354	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
355	rc = CFGMR3InsertString(pLunL0, "Driver", "KeyboardQueue"); RC_CHECK();
356	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
357	rc = CFGMR3InsertInteger(pCfg, "QueueSize", 64); RC_CHECK();
358
359	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
360	rc = CFGMR3InsertString(pLunL1, "Driver", "MainKeyboard"); RC_CHECK();
361	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
362	Keyboard *pKeyboard = pConsole->mKeyboard;
363	rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pKeyboard); RC_CHECK();
364
365	rc = CFGMR3InsertNode(pInst, "LUN#1", &pLunL0); RC_CHECK();
366	rc = CFGMR3InsertString(pLunL0, "Driver", "MouseQueue"); RC_CHECK();
367	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
368	rc = CFGMR3InsertInteger(pCfg, "QueueSize", 128); RC_CHECK();
369
370	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
371	rc = CFGMR3InsertString(pLunL1, "Driver", "MainMouse"); RC_CHECK();
372	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
373	Mouse *pMouse = pConsole->mMouse;
374	rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pMouse); RC_CHECK();
375
376	/*
377	* i82078 Floppy drive controller
378	*/
379	ComPtr<IFloppyDrive> floppyDrive;
380	hrc = pMachine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam()); H();
381	BOOL fFloppyEnabled;
382	hrc = floppyDrive->COMGETTER(Enabled)(&fFloppyEnabled); H();
383	if (fFloppyEnabled)
384	{
385	rc = CFGMR3InsertNode(pDevices, "i82078", &pDev); RC_CHECK();
386	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
387	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); RC_CHECK();
388	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
389	rc = CFGMR3InsertInteger(pCfg, "IRQ", 6); RC_CHECK();
390	rc = CFGMR3InsertInteger(pCfg, "DMA", 2); RC_CHECK();
391	rc = CFGMR3InsertInteger(pCfg, "MemMapped", 0 ); RC_CHECK();
392	rc = CFGMR3InsertInteger(pCfg, "IOBase", 0x3f0); RC_CHECK();
393
394	/* Attach the status driver */
395	rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
396	rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
397	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
398	rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapFDLeds[0]); RC_CHECK();
399	rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
400	rc = CFGMR3InsertInteger(pCfg, "Last", 0); RC_CHECK();
401
402	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
403
404	ComPtr<IFloppyImage> floppyImage;
405	hrc = floppyDrive->GetImage(floppyImage.asOutParam()); H();
406	if (floppyImage)
407	{
408	pConsole->meFloppyState = DriveState_ImageMounted;
409	rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
410	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
411	rc = CFGMR3InsertString(pCfg, "Type", "Floppy 1.44"); RC_CHECK();
412	rc = CFGMR3InsertInteger(pCfg, "Mountable", 1); RC_CHECK();
413
414	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
415	rc = CFGMR3InsertString(pLunL1, "Driver", "RawImage"); RC_CHECK();
416	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
417	hrc = floppyImage->COMGETTER(FilePath)(&str); H();
418	STR_CONV();
419	rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
420	STR_FREE();
421	}
422	else
423	{
424	ComPtr<IHostFloppyDrive> hostFloppyDrive;
425	hrc = floppyDrive->GetHostDrive(hostFloppyDrive.asOutParam()); H();
426	if (hostFloppyDrive)
427	{
428	pConsole->meFloppyState = DriveState_HostDriveCaptured;
429	rc = CFGMR3InsertString(pLunL0, "Driver", "HostFloppy"); RC_CHECK();
430	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
431	hrc = hostFloppyDrive->COMGETTER(Name)(&str); H();
432	STR_CONV();
433	rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
434	STR_FREE();
435	}
436	else
437	{
438	pConsole->meFloppyState = DriveState_NotMounted;
439	rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
440	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
441	rc = CFGMR3InsertString(pCfg, "Type", "Floppy 1.44"); RC_CHECK();
442	rc = CFGMR3InsertInteger(pCfg, "Mountable", 1); RC_CHECK();
443	}
444	}
445	}
446
447	/*
448	* i8254 Programmable Interval Timer And Dummy Speaker
449	*/
450	rc = CFGMR3InsertNode(pDevices, "i8254", &pDev); RC_CHECK();
451	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
452	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
453	#ifdef DEBUG
454	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
455	#endif
456
457	/*
458	* i8259 Programmable Interrupt Controller.
459	*/
460	rc = CFGMR3InsertNode(pDevices, "i8259", &pDev); RC_CHECK();
461	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
462	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
463	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
464
465	/*
466	* Advanced Programmable Interrupt Controller.
467	*/
468	rc = CFGMR3InsertNode(pDevices, "apic", &pDev); RC_CHECK();
469	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
470	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
471	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
472	rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); RC_CHECK();
473
474	if (fIOAPIC)
475	{
476	/*
477	* I/O Advanced Programmable Interrupt Controller.
478	*/
479	rc = CFGMR3InsertNode(pDevices, "ioapic", &pDev); RC_CHECK();
480	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
481	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
482	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
483	}
484
485	/*
486	* RTC MC146818.
487	*/
488	rc = CFGMR3InsertNode(pDevices, "mc146818", &pDev); RC_CHECK();
489	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
490	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
491
492	/*
493	* VGA.
494	*/
495	rc = CFGMR3InsertNode(pDevices, "vga", &pDev); RC_CHECK();
496	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
497	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
498	rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 2); RC_CHECK();
499	Assert(!afPciDeviceNo[2]);
500	afPciDeviceNo[2] = true;
501	rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
502	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
503	hrc = pMachine->COMGETTER(VRAMSize)(&cRamMBs); H();
504	rc = CFGMR3InsertInteger(pCfg, "VRamSize", cRamMBs * _1M); RC_CHECK();
505
506	/*
507	* BIOS logo
508	*/
509	BOOL fFadeIn;
510	hrc = biosSettings->COMGETTER(LogoFadeIn)(&fFadeIn); H();
511	rc = CFGMR3InsertInteger(pCfg, "FadeIn", fFadeIn ? 1 : 0); RC_CHECK();
512	BOOL fFadeOut;
513	hrc = biosSettings->COMGETTER(LogoFadeOut)(&fFadeOut); H();
514	rc = CFGMR3InsertInteger(pCfg, "FadeOut", fFadeOut ? 1: 0); RC_CHECK();
515	ULONG logoDisplayTime;
516	hrc = biosSettings->COMGETTER(LogoDisplayTime)(&logoDisplayTime); H();
517	rc = CFGMR3InsertInteger(pCfg, "LogoTime", logoDisplayTime); RC_CHECK();
518	Bstr logoImagePath;
519	hrc = biosSettings->COMGETTER(LogoImagePath)(logoImagePath.asOutParam()); H();
520	rc = CFGMR3InsertString(pCfg, "LogoFile", logoImagePath ? Utf8Str(logoImagePath) : ""); RC_CHECK();
521
522	/*
523	* Boot menu
524	*/
525	BIOSBootMenuMode_T bootMenuMode;
526	int value;
527	biosSettings->COMGETTER(BootMenuMode)(&bootMenuMode);
528	switch (bootMenuMode)
529	{
530	case BIOSBootMenuMode_Disabled:
531	value = 0;
532	break;
533	case BIOSBootMenuMode_MenuOnly:
534	value = 1;
535	break;
536	default:
537	value = 2;
538	}
539	rc = CFGMR3InsertInteger(pCfg, "ShowBootMenu", value); RC_CHECK();
540
541	/* Custom VESA mode list */
542	unsigned cModes = 0;
543	for (unsigned iMode = 1; iMode <= 16; iMode++)
544	{
545	char szExtraDataKey[sizeof("CustomVideoModeXX")];
546	RTStrPrintf(szExtraDataKey, sizeof(szExtraDataKey), "CustomVideoMode%d", iMode);
547	hrc = pMachine->GetExtraData(Bstr(szExtraDataKey), &str); H();
548	if (!str \|\| !*str)
549	break;
550	STR_CONV();
551	rc = CFGMR3InsertString(pCfg, szExtraDataKey, psz);
552	STR_FREE();
553	cModes++;
554	}
555	rc = CFGMR3InsertInteger(pCfg, "CustomVideoModes", cModes);
556
557	/* VESA height reduction */
558	ULONG ulHeightReduction;
559	IFramebuffer *pFramebuffer = pConsole->getDisplay()->getFramebuffer();
560	if (pFramebuffer)
561	{
562	hrc = pFramebuffer->COMGETTER(HeightReduction)(&ulHeightReduction); H();
563	}
564	else
565	{
566	/* If framebuffer is not available, there is no height reduction. */
567	ulHeightReduction = 0;
568	}
569	rc = CFGMR3InsertInteger(pCfg, "HeightReduction", ulHeightReduction); RC_CHECK();
570
571	/* Attach the display. */
572	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
573	rc = CFGMR3InsertString(pLunL0, "Driver", "MainDisplay"); RC_CHECK();
574	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
575	Display *pDisplay = pConsole->mDisplay;
576	rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pDisplay); RC_CHECK();
577
578	/*
579	* IDE (update this when the main interface changes)
580	*/
581	rc = CFGMR3InsertNode(pDevices, "piix3ide", &pDev); /* piix3 */ RC_CHECK();
582	rc = CFGMR3InsertNode(pDev, "0", &pIdeInst); RC_CHECK();
583	rc = CFGMR3InsertInteger(pIdeInst, "Trusted", 1); /* boolean */ RC_CHECK();
584	rc = CFGMR3InsertInteger(pIdeInst, "PCIDeviceNo", 1); RC_CHECK();
585	Assert(!afPciDeviceNo[1]);
586	afPciDeviceNo[1] = true;
587	rc = CFGMR3InsertInteger(pIdeInst, "PCIFunctionNo", 1); RC_CHECK();
588	rc = CFGMR3InsertNode(pIdeInst, "Config", &pCfg); RC_CHECK();
589	rc = CFGMR3InsertInteger(pCfg, "PIIX4", fPIIX4); /* boolean */ RC_CHECK();
590
591	/* Attach the status driver */
592	rc = CFGMR3InsertNode(pIdeInst, "LUN#999", &pLunL0); RC_CHECK();
593	rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
594	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
595	rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapIDELeds[0]);RC_CHECK();
596	rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
597	rc = CFGMR3InsertInteger(pCfg, "Last", 3); RC_CHECK();
598
599	/*
600	* SATA controller
601	*/
602	ComPtr<ISATAController> sataController;
603	hrc = pMachine->COMGETTER(SATAController)(sataController.asOutParam());
604	BOOL enabled = FALSE;
605
606	if (sataController)
607	{
608	hrc = sataController->COMGETTER(Enabled)(&enabled); H();
609
610	if (enabled)
611	{
612	rc = CFGMR3InsertNode(pDevices, "ahci", &pDev); RC_CHECK();
613	rc = CFGMR3InsertNode(pDev, "0", &pSataInst); RC_CHECK();
614	rc = CFGMR3InsertInteger(pSataInst, "Trusted", 1); RC_CHECK();
615	rc = CFGMR3InsertInteger(pSataInst, "PCIDeviceNo", 13); RC_CHECK();
616	Assert(!afPciDeviceNo[13]);
617	afPciDeviceNo[13] = true;
618	rc = CFGMR3InsertInteger(pSataInst, "PCIFunctionNo", 0); RC_CHECK();
619	rc = CFGMR3InsertNode(pSataInst, "Config", &pCfg); RC_CHECK();
620
621	ULONG cPorts = 0;
622	hrc = sataController->COMGETTER(PortCount)(&cPorts); H();
623	rc = CFGMR3InsertInteger(pCfg, "PortCount", cPorts); RC_CHECK();
624
625	/* Needed configuration values for the bios. */
626	rc = CFGMR3InsertString(pBiosCfg, "SataHardDiskDevice", "ahci"); RC_CHECK();
627
628	for (uint32_t i = 0; i < 4; i++)
629	{
630	static const char *s_apszConfig[4] =
631	{ "PrimaryMaster", "PrimarySlave", "SecondaryMaster", "SecondarySlave" };
632	static const char *s_apszBiosConfig[4] =
633	{ "SataPrimaryMasterLUN", "SataPrimarySlaveLUN", "SataSecondaryMasterLUN", "SataSecondarySlaveLUN" };
634
635	LONG lPortNumber = -1;
636	hrc = sataController->GetIDEEmulationPort(i, &lPortNumber); H();
637	rc = CFGMR3InsertInteger(pCfg, s_apszConfig[i], lPortNumber); RC_CHECK();
638	rc = CFGMR3InsertInteger(pBiosCfg, s_apszBiosConfig[i], lPortNumber); RC_CHECK();
639	}
640
641	/* Attach the status driver */
642	rc = CFGMR3InsertNode(pSataInst,"LUN#999", &pLunL0); RC_CHECK();
643	rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
644	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
645	AssertRelease(cPorts <= RT_ELEMENTS(pConsole->mapSATALeds));
646	rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapSATALeds[0]); RC_CHECK();
647	rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
648	rc = CFGMR3InsertInteger(pCfg, "Last", cPorts - 1); RC_CHECK();
649	}
650	}
651
652	/* Attach the harddisks */
653	ComPtr<IHardDiskAttachmentCollection> hdaColl;
654	hrc = pMachine->COMGETTER(HardDiskAttachments)(hdaColl.asOutParam()); H();
655	ComPtr<IHardDiskAttachmentEnumerator> hdaEnum;
656	hrc = hdaColl->Enumerate(hdaEnum.asOutParam()); H();
657
658	BOOL fMore = FALSE;
659	while ( SUCCEEDED(hrc = hdaEnum->HasMore(&fMore))
660	&& fMore)
661	{
662	PCFGMNODE pHardDiskCtl;
663	ComPtr<IHardDiskAttachment> hda;
664	hrc = hdaEnum->GetNext(hda.asOutParam()); H();
665	ComPtr<IHardDisk> hardDisk;
666	hrc = hda->COMGETTER(HardDisk)(hardDisk.asOutParam()); H();
667	StorageBus_T enmBus;
668	hrc = hda->COMGETTER(Bus)(&enmBus); H();
669	LONG lDev;
670	hrc = hda->COMGETTER(Device)(&lDev); H();
671	LONG lChannel;
672	hrc = hda->COMGETTER(Channel)(&lChannel); H();
673
674	int iLUN;
675	switch (enmBus)
676	{
677	case StorageBus_IDE:
678	{
679	if (lChannel >= 2 \|\| lChannel < 0)
680	{
681	AssertMsgFailed(("invalid controller channel number: %d\n", lChannel));
682	return VERR_GENERAL_FAILURE;
683	}
684
685	if (lDev >= 2 \|\| lDev < 0)
686	{
687	AssertMsgFailed(("invalid controller device number: %d\n", lDev));
688	return VERR_GENERAL_FAILURE;
689	}
690	iLUN = 2*lChannel + lDev;
691	pHardDiskCtl = pIdeInst;
692	}
693	break;
694	case StorageBus_SATA:
695	iLUN = lChannel;
696	pHardDiskCtl = enabled ? pSataInst : NULL;
697	break;
698	default:
699	AssertMsgFailed(("invalid disk controller type: %d\n", enmBus));
700	return VERR_GENERAL_FAILURE;
701	}
702
703	/* Can be NULL if SATA controller is not enabled and current hard disk is attached to SATA controller. */
704	if (pHardDiskCtl)
705	{
706	char szLUN[16];
707	RTStrPrintf(szLUN, sizeof(szLUN), "LUN#%d", iLUN);
708	rc = CFGMR3InsertNode(pHardDiskCtl, szLUN, &pLunL0); RC_CHECK();
709	rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
710	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
711	rc = CFGMR3InsertString(pCfg, "Type", "HardDisk"); RC_CHECK();
712	rc = CFGMR3InsertInteger(pCfg, "Mountable", 0); RC_CHECK();
713
714	HardDiskStorageType_T hddType;
715	hardDisk->COMGETTER(StorageType)(&hddType);
716	if (hddType == HardDiskStorageType_VirtualDiskImage)
717	{
718	ComPtr<IVirtualDiskImage> vdiDisk = hardDisk;
719	AssertBreak (!vdiDisk.isNull(), hrc = E_FAIL);
720
721	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
722	rc = CFGMR3InsertString(pLunL1, "Driver", "VBoxHDD"); RC_CHECK();
723	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
724	hrc = vdiDisk->COMGETTER(FilePath)(&str); H();
725	STR_CONV();
726	rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
727	STR_FREE();
728
729	/* Create an inversed tree of parents. */
730	ComPtr<IHardDisk> parentHardDisk = hardDisk;
731	for (PCFGMNODE pParent = pCfg;;)
732	{
733	ComPtr<IHardDisk> curHardDisk;
734	hrc = parentHardDisk->COMGETTER(Parent)(curHardDisk.asOutParam()); H();
735	if (!curHardDisk)
736	break;
737
738	vdiDisk = curHardDisk;
739	AssertBreak (!vdiDisk.isNull(), hrc = E_FAIL);
740
741	PCFGMNODE pCur;
742	rc = CFGMR3InsertNode(pParent, "Parent", &pCur); RC_CHECK();
743	hrc = vdiDisk->COMGETTER(FilePath)(&str); H();
744	STR_CONV();
745	rc = CFGMR3InsertString(pCur, "Path", psz); RC_CHECK();
746	STR_FREE();
747	rc = CFGMR3InsertInteger(pCur, "ReadOnly", 1); RC_CHECK();
748
749	/* next */
750	pParent = pCur;
751	parentHardDisk = curHardDisk;
752	}
753	}
754	else if (hddType == HardDiskStorageType_ISCSIHardDisk)
755	{
756	ComPtr<IISCSIHardDisk> iSCSIDisk = hardDisk;
757	AssertBreak (!iSCSIDisk.isNull(), hrc = E_FAIL);
758
759	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
760	rc = CFGMR3InsertString(pLunL1, "Driver", "iSCSI"); RC_CHECK();
761	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
762
763	/* Set up the iSCSI initiator driver configuration. */
764	hrc = iSCSIDisk->COMGETTER(Target)(&str); H();
765	STR_CONV();
766	rc = CFGMR3InsertString(pCfg, "TargetName", psz); RC_CHECK();
767	STR_FREE();
768
769	// @todo currently there is no Initiator name config.
770	rc = CFGMR3InsertString(pCfg, "InitiatorName", "iqn.2006-02.de.innotek.initiator"); RC_CHECK();
771
772	ULONG64 lun;
773	hrc = iSCSIDisk->COMGETTER(Lun)(&lun); H();
774	rc = CFGMR3InsertInteger(pCfg, "LUN", lun); RC_CHECK();
775
776	hrc = iSCSIDisk->COMGETTER(Server)(&str); H();
777	STR_CONV();
778	USHORT port;
779	hrc = iSCSIDisk->COMGETTER(Port)(&port); H();
780	if (port != 0)
781	{
782	char *pszTN;
783	RTStrAPrintf(&pszTN, "%s:%u", psz, port);
784	rc = CFGMR3InsertString(pCfg, "TargetAddress", pszTN); RC_CHECK();
785	RTStrFree(pszTN);
786	}
787	else
788	{
789	rc = CFGMR3InsertString(pCfg, "TargetAddress", psz); RC_CHECK();
790	}
791	STR_FREE();
792
793	hrc = iSCSIDisk->COMGETTER(UserName)(&str); H();
794	if (str)
795	{
796	STR_CONV();
797	rc = CFGMR3InsertString(pCfg, "InitiatorUsername", psz); RC_CHECK();
798	STR_FREE();
799	}
800
801	hrc = iSCSIDisk->COMGETTER(Password)(&str); H();
802	if (str)
803	{
804	STR_CONV();
805	rc = CFGMR3InsertString(pCfg, "InitiatorSecret", psz); RC_CHECK();
806	STR_FREE();
807	}
808
809	// @todo currently there is no target username config.
810	//rc = CFGMR3InsertString(pCfg, "TargetUsername", ""); RC_CHECK();
811
812	// @todo currently there is no target password config.
813	//rc = CFGMR3InsertString(pCfg, "TargetSecret", ""); RC_CHECK();
814
815	/* The iSCSI initiator needs an attached iSCSI transport driver. */
816	rc = CFGMR3InsertNode(pLunL1, "AttachedDriver", &pLunL2); RC_CHECK();
817	rc = CFGMR3InsertString(pLunL2, "Driver", "iSCSITCP"); RC_CHECK();
818	/* Currently the transport driver has no config options. */
819	}
820	else if (hddType == HardDiskStorageType_VMDKImage)
821	{
822	ComPtr<IVMDKImage> vmdkDisk = hardDisk;
823	AssertBreak (!vmdkDisk.isNull(), hrc = E_FAIL);
824
825	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
826	#if 1 /* Enable new VD container code (and new VMDK), as the bugs are fixed. */
827	rc = CFGMR3InsertString(pLunL1, "Driver", "VD"); RC_CHECK();
828	#else
829	rc = CFGMR3InsertString(pLunL1, "Driver", "VmdkHDD"); RC_CHECK();
830	#endif
831	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
832	hrc = vmdkDisk->COMGETTER(FilePath)(&str); H();
833	STR_CONV();
834	rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
835	STR_FREE();
836	rc = CFGMR3InsertString(pCfg, "Format", "VMDK"); RC_CHECK();
837	}
838	else if (hddType == HardDiskStorageType_CustomHardDisk)
839	{
840	ComPtr<ICustomHardDisk> customHardDisk = hardDisk;
841	AssertBreak (!customHardDisk.isNull(), hrc = E_FAIL);
842
843	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
844	rc = CFGMR3InsertString(pLunL1, "Driver", "VD"); RC_CHECK();
845	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
846	hrc = customHardDisk->COMGETTER(Location)(&str); H();
847	STR_CONV();
848	rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
849	STR_FREE();
850	hrc = customHardDisk->COMGETTER(Format)(&str); H();
851	STR_CONV();
852	rc = CFGMR3InsertString(pCfg, "Format", psz); RC_CHECK();
853	STR_FREE();
854	}
855	else if (hddType == HardDiskStorageType_VHDImage)
856	{
857	ComPtr<IVHDImage> vhdDisk = hardDisk;
858	AssertBreak (!vhdDisk.isNull(), hrc = E_FAIL);
859
860	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
861	rc = CFGMR3InsertString(pLunL1, "Driver", "VD"); RC_CHECK();
862	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
863	hrc = vhdDisk->COMGETTER(FilePath)(&str); H();
864	STR_CONV();
865	rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
866	rc = CFGMR3InsertString(pCfg, "Format", "VHD"); RC_CHECK();
867	STR_FREE();
868	}
869	else
870	AssertFailed();
871	}
872	}
873	H();
874
875	ComPtr<IDVDDrive> dvdDrive;
876	hrc = pMachine->COMGETTER(DVDDrive)(dvdDrive.asOutParam()); H();
877	if (dvdDrive)
878	{
879	// ASSUME: DVD drive is always attached to LUN#2 (i.e. secondary IDE master)
880	rc = CFGMR3InsertNode(pIdeInst, "LUN#2", &pLunL0); RC_CHECK();
881	ComPtr<IHostDVDDrive> hostDvdDrive;
882	hrc = dvdDrive->GetHostDrive(hostDvdDrive.asOutParam()); H();
883	if (hostDvdDrive)
884	{
885	pConsole->meDVDState = DriveState_HostDriveCaptured;
886	rc = CFGMR3InsertString(pLunL0, "Driver", "HostDVD"); RC_CHECK();
887	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
888	hrc = hostDvdDrive->COMGETTER(Name)(&str); H();
889	STR_CONV();
890	rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
891	STR_FREE();
892	BOOL fPassthrough;
893	hrc = dvdDrive->COMGETTER(Passthrough)(&fPassthrough); H();
894	rc = CFGMR3InsertInteger(pCfg, "Passthrough", !!fPassthrough); RC_CHECK();
895	}
896	else
897	{
898	pConsole->meDVDState = DriveState_NotMounted;
899	rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
900	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
901	rc = CFGMR3InsertString(pCfg, "Type", "DVD"); RC_CHECK();
902	rc = CFGMR3InsertInteger(pCfg, "Mountable", 1); RC_CHECK();
903
904	ComPtr<IDVDImage> dvdImage;
905	hrc = dvdDrive->GetImage(dvdImage.asOutParam()); H();
906	if (dvdImage)
907	{
908	pConsole->meDVDState = DriveState_ImageMounted;
909	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
910	rc = CFGMR3InsertString(pLunL1, "Driver", "MediaISO"); RC_CHECK();
911	rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
912	hrc = dvdImage->COMGETTER(FilePath)(&str); H();
913	STR_CONV();
914	rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
915	STR_FREE();
916	}
917	}
918	}
919
920	/*
921	* Network adapters
922	*/
923	PCFGMNODE pDevPCNet = NULL; /* PCNet-type devices */
924	rc = CFGMR3InsertNode(pDevices, "pcnet", &pDevPCNet); RC_CHECK();
925	#ifdef VBOX_WITH_E1000
926	PCFGMNODE pDevE1000 = NULL; /* E1000-type devices */
927	rc = CFGMR3InsertNode(pDevices, "e1000", &pDevE1000); RC_CHECK();
928	#endif
929	for (ULONG ulInstance = 0; ulInstance < SchemaDefs::NetworkAdapterCount; ulInstance++)
930	{
931	ComPtr<INetworkAdapter> networkAdapter;
932	hrc = pMachine->GetNetworkAdapter(ulInstance, networkAdapter.asOutParam()); H();
933	BOOL fEnabled = FALSE;
934	hrc = networkAdapter->COMGETTER(Enabled)(&fEnabled); H();
935	if (!fEnabled)
936	continue;
937
938	/*
939	* The virtual hardware type. Create appropriate device first.
940	*/
941	NetworkAdapterType_T adapterType;
942	hrc = networkAdapter->COMGETTER(AdapterType)(&adapterType); H();
943	switch (adapterType)
944	{
945	case NetworkAdapterType_Am79C970A:
946	case NetworkAdapterType_Am79C973:
947	pDev = pDevPCNet;
948	break;
949	#ifdef VBOX_WITH_E1000
950	case NetworkAdapterType_I82540EM:
951	pDev = pDevE1000;
952	break;
953	#endif
954	default:
955	AssertMsgFailed(("Invalid network adapter type '%d' for slot '%d'",
956	adapterType, ulInstance));
957	return VERR_GENERAL_FAILURE;
958	}
959
960	char szInstance[4]; Assert(ulInstance <= 999);
961	RTStrPrintf(szInstance, sizeof(szInstance), "%lu", ulInstance);
962	rc = CFGMR3InsertNode(pDev, szInstance, &pInst); RC_CHECK();
963	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
964	/* the first network card gets the PCI ID 3, the next 3 gets 8..10. */
965	const unsigned iPciDeviceNo = !ulInstance ? 3 : ulInstance - 1 + 8;
966	rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", iPciDeviceNo); RC_CHECK();
967	Assert(!afPciDeviceNo[iPciDeviceNo]);
968	afPciDeviceNo[iPciDeviceNo] = true;
969	rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
970	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
971
972	/*
973	* The virtual hardware type. PCNet supports two types.
974	*/
975	switch (adapterType)
976	{
977	case NetworkAdapterType_Am79C970A:
978	rc = CFGMR3InsertInteger(pCfg, "Am79C973", 0); RC_CHECK();
979	break;
980	case NetworkAdapterType_Am79C973:
981	rc = CFGMR3InsertInteger(pCfg, "Am79C973", 1); RC_CHECK();
982	break;
983	}
984
985	/*
986	* Get the MAC address and convert it to binary representation
987	*/
988	Bstr macAddr;
989	hrc = networkAdapter->COMGETTER(MACAddress)(macAddr.asOutParam()); H();
990	Assert(macAddr);
991	Utf8Str macAddrUtf8 = macAddr;
992	char macStr = (char)macAddrUtf8.raw();
993	Assert(strlen(macStr) == 12);
994	PDMMAC Mac;
995	memset(&Mac, 0, sizeof(Mac));
996	char pMac = (char)&Mac;
997	for (uint32_t i = 0; i < 6; i++)
998	{
999	char c1 = *macStr++ - '0';
1000	if (c1 > 9)
1001	c1 -= 7;
1002	char c2 = *macStr++ - '0';
1003	if (c2 > 9)
1004	c2 -= 7;
1005	*pMac++ = ((c1 & 0x0f) << 4) \| (c2 & 0x0f);
1006	}
1007	rc = CFGMR3InsertBytes(pCfg, "MAC", &Mac, sizeof(Mac)); RC_CHECK();
1008
1009	/*
1010	* Check if the cable is supposed to be unplugged
1011	*/
1012	BOOL fCableConnected;
1013	hrc = networkAdapter->COMGETTER(CableConnected)(&fCableConnected); H();
1014	rc = CFGMR3InsertInteger(pCfg, "CableConnected", fCableConnected ? 1 : 0); RC_CHECK();
1015
1016	/*
1017	* Line speed to report from custom drivers
1018	*/
1019	ULONG ulLineSpeed;
1020	hrc = networkAdapter->COMGETTER(LineSpeed)(&ulLineSpeed); H();
1021	rc = CFGMR3InsertInteger(pCfg, "LineSpeed", ulLineSpeed); RC_CHECK();
1022
1023	/*
1024	* Attach the status driver.
1025	*/
1026	rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
1027	rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
1028	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1029	rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapNetworkLeds[ulInstance]); RC_CHECK();
1030
1031	/*
1032	* Enable the packet sniffer if requested.
1033	*/
1034	BOOL fSniffer;
1035	hrc = networkAdapter->COMGETTER(TraceEnabled)(&fSniffer); H();
1036	if (fSniffer)
1037	{
1038	/* insert the sniffer filter driver. */
1039	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1040	rc = CFGMR3InsertString(pLunL0, "Driver", "NetSniffer"); RC_CHECK();
1041	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1042	hrc = networkAdapter->COMGETTER(TraceFile)(&str); H();
1043	if (str) /* check convention for indicating default file. */
1044	{
1045	STR_CONV();
1046	rc = CFGMR3InsertString(pCfg, "File", psz); RC_CHECK();
1047	STR_FREE();
1048	}
1049	}
1050
1051	NetworkAttachmentType_T networkAttachment;
1052	hrc = networkAdapter->COMGETTER(AttachmentType)(&networkAttachment); H();
1053	switch (networkAttachment)
1054	{
1055	case NetworkAttachmentType_Null:
1056	break;
1057
1058	case NetworkAttachmentType_NAT:
1059	{
1060	if (fSniffer)
1061	{
1062	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
1063	}
1064	else
1065	{
1066	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1067	}
1068	rc = CFGMR3InsertString(pLunL0, "Driver", "NAT"); RC_CHECK();
1069	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1070	/* (Port forwarding goes here.) */
1071
1072	/* Configure TFTP prefix and boot filename. */
1073	hrc = virtualBox->COMGETTER(HomeFolder)(&str); H();
1074	STR_CONV();
1075	if (psz && *psz)
1076	{
1077	char *pszTFTPPrefix = NULL;
1078	RTStrAPrintf(&pszTFTPPrefix, "%s%c%s", psz, RTPATH_DELIMITER, "TFTP");
1079	rc = CFGMR3InsertString(pCfg, "TFTPPrefix", pszTFTPPrefix); RC_CHECK();
1080	RTStrFree(pszTFTPPrefix);
1081	}
1082	STR_FREE();
1083	hrc = pMachine->COMGETTER(Name)(&str); H();
1084	STR_CONV();
1085	char *pszBootFile = NULL;
1086	RTStrAPrintf(&pszBootFile, "%s.pxe", psz);
1087	STR_FREE();
1088	rc = CFGMR3InsertString(pCfg, "BootFile", pszBootFile); RC_CHECK();
1089	RTStrFree(pszBootFile);
1090	break;
1091	}
1092
1093	case NetworkAttachmentType_HostInterface:
1094	{
1095	/*
1096	* Perform the attachment if required (don't return on error!)
1097	*/
1098	hrc = pConsole->attachToHostInterface(networkAdapter);
1099	if (SUCCEEDED(hrc))
1100	{
1101	#ifdef VBOX_WITH_UNIXY_TAP_NETWORKING
1102	Assert (pConsole->maTapFD[ulInstance] >= 0);
1103	if (pConsole->maTapFD[ulInstance] >= 0)
1104	{
1105	if (fSniffer)
1106	{
1107	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
1108	}
1109	else
1110	{
1111	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1112	}
1113	rc = CFGMR3InsertString(pLunL0, "Driver", "HostInterface"); RC_CHECK();
1114	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1115	# if defined(RT_OS_SOLARIS)
1116	/* Device name/number is required for Solaris as we need it for TAP PPA. */
1117	Bstr tapDeviceName;
1118	networkAdapter->COMGETTER(HostInterface)(tapDeviceName.asOutParam());
1119	if (!tapDeviceName.isEmpty())
1120	rc = CFGMR3InsertString(pCfg, "Device", Utf8Str(tapDeviceName)); RC_CHECK();
1121
1122	/* TAP setup application/script */
1123	Bstr tapSetupApp;
1124	networkAdapter->COMGETTER(TAPSetupApplication)(tapSetupApp.asOutParam());
1125	if (!tapSetupApp.isEmpty())
1126	rc = CFGMR3InsertString(pCfg, "TAPSetupApplication", Utf8Str(tapSetupApp)); RC_CHECK();
1127
1128	/* TAP terminate application/script */
1129	Bstr tapTerminateApp;
1130	networkAdapter->COMGETTER(TAPTerminateApplication)(tapTerminateApp.asOutParam());
1131	if (!tapTerminateApp.isEmpty())
1132	rc = CFGMR3InsertString(pCfg, "TAPTerminateApplication", Utf8Str(tapTerminateApp)); RC_CHECK();
1133
1134	/* "FileHandle" must NOT be inserted here, it is done in DrvTAP.cpp */
1135
1136	# ifdef VBOX_WITH_CROSSBOW
1137	/* Crossbow: needs the MAC address for setting up TAP. */
1138	rc = CFGMR3InsertBytes(pCfg, "MAC", &Mac, sizeof(Mac)); RC_CHECK();
1139	# endif
1140	# else
1141	rc = CFGMR3InsertInteger(pCfg, "FileHandle", pConsole->maTapFD[ulInstance]); RC_CHECK();
1142	# endif
1143	}
1144	#elif defined(RT_OS_WINDOWS)
1145	if (fSniffer)
1146	{
1147	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
1148	}
1149	else
1150	{
1151	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1152	}
1153	Bstr hostInterfaceName;
1154	hrc = networkAdapter->COMGETTER(HostInterface)(hostInterfaceName.asOutParam()); H();
1155	ComPtr<IHostNetworkInterfaceCollection> coll;
1156	hrc = host->COMGETTER(NetworkInterfaces)(coll.asOutParam()); H();
1157	ComPtr<IHostNetworkInterface> hostInterface;
1158	rc = coll->FindByName(hostInterfaceName, hostInterface.asOutParam());
1159	if (!SUCCEEDED(rc))
1160	{
1161	AssertMsgFailed(("Cannot get GUID for host interface '%ls'\n", hostInterfaceName));
1162	hrc = networkAdapter->Detach(); H();
1163	}
1164	else
1165	{
1166	rc = CFGMR3InsertString(pLunL0, "Driver", "HostInterface"); RC_CHECK();
1167	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1168	rc = CFGMR3InsertString(pCfg, "HostInterfaceName", Utf8Str(hostInterfaceName)); RC_CHECK();
1169	Guid hostIFGuid;
1170	hrc = hostInterface->COMGETTER(Id)(hostIFGuid.asOutParam()); H();
1171	char szDriverGUID[256] = {0};
1172	/* add curly brackets */
1173	szDriverGUID[0] = '{';
1174	strcpy(szDriverGUID + 1, hostIFGuid.toString().raw());
1175	strcat(szDriverGUID, "}");
1176	rc = CFGMR3InsertBytes(pCfg, "GUID", szDriverGUID, sizeof(szDriverGUID)); RC_CHECK();
1177	}
1178	#else
1179	# error "Port me"
1180	#endif
1181	}
1182	else
1183	{
1184	switch (hrc)
1185	{
1186	#ifdef RT_OS_LINUX
1187	case VERR_ACCESS_DENIED:
1188	return VMSetError(pVM, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
1189	"Failed to open '/dev/net/tun' for read/write access. Please check the "
1190	"permissions of that node. Either run 'chmod 0666 /dev/net/tun' or "
1191	"change the group of that node and make yourself a member of that group. Make "
1192	"sure that these changes are permanent, especially if you are "
1193	"using udev"));
1194	#endif /* RT_OS_LINUX */
1195	default:
1196	AssertMsgFailed(("Could not attach to host interface! Bad!\n"));
1197	return VMSetError(pVM, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
1198	"Failed to initialize Host Interface Networking"));
1199	}
1200	}
1201	break;
1202	}
1203
1204	case NetworkAttachmentType_Internal:
1205	{
1206	hrc = networkAdapter->COMGETTER(InternalNetwork)(&str); H();
1207	STR_CONV();
1208	if (psz && *psz)
1209	{
1210	if (fSniffer)
1211	{
1212	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
1213	}
1214	else
1215	{
1216	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1217	}
1218	rc = CFGMR3InsertString(pLunL0, "Driver", "IntNet"); RC_CHECK();
1219	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1220	rc = CFGMR3InsertString(pCfg, "Network", psz); RC_CHECK();
1221	}
1222	STR_FREE();
1223	break;
1224	}
1225
1226	default:
1227	AssertMsgFailed(("should not get here!\n"));
1228	break;
1229	}
1230	}
1231
1232	/*
1233	* Serial (UART) Ports
1234	*/
1235	rc = CFGMR3InsertNode(pDevices, "serial", &pDev); RC_CHECK();
1236	for (ULONG ulInstance = 0; ulInstance < SchemaDefs::SerialPortCount; ulInstance++)
1237	{
1238	ComPtr<ISerialPort> serialPort;
1239	hrc = pMachine->GetSerialPort (ulInstance, serialPort.asOutParam()); H();
1240	BOOL fEnabled = FALSE;
1241	if (serialPort)
1242	hrc = serialPort->COMGETTER(Enabled)(&fEnabled); H();
1243	if (!fEnabled)
1244	continue;
1245
1246	char szInstance[4]; Assert(ulInstance <= 999);
1247	RTStrPrintf(szInstance, sizeof(szInstance), "%lu", ulInstance);
1248
1249	rc = CFGMR3InsertNode(pDev, szInstance, &pInst); RC_CHECK();
1250	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
1251
1252	ULONG ulIRQ, ulIOBase;
1253	PortMode_T HostMode;
1254	Bstr path;
1255	BOOL fServer;
1256	hrc = serialPort->COMGETTER(HostMode)(&HostMode); H();
1257	hrc = serialPort->COMGETTER(IRQ)(&ulIRQ); H();
1258	hrc = serialPort->COMGETTER(IOBase)(&ulIOBase); H();
1259	hrc = serialPort->COMGETTER(Path)(path.asOutParam()); H();
1260	hrc = serialPort->COMGETTER(Server)(&fServer); H();
1261	rc = CFGMR3InsertInteger(pCfg, "IRQ", ulIRQ); RC_CHECK();
1262	rc = CFGMR3InsertInteger(pCfg, "IOBase", ulIOBase); RC_CHECK();
1263	if (HostMode != PortMode_Disconnected)
1264	{
1265	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1266	if (HostMode == PortMode_HostPipe)
1267	{
1268	rc = CFGMR3InsertString(pLunL0, "Driver", "Char"); RC_CHECK();
1269	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
1270	rc = CFGMR3InsertString(pLunL1, "Driver", "NamedPipe"); RC_CHECK();
1271	rc = CFGMR3InsertNode(pLunL1, "Config", &pLunL2); RC_CHECK();
1272	rc = CFGMR3InsertString(pLunL2, "Location", Utf8Str(path)); RC_CHECK();
1273	rc = CFGMR3InsertInteger(pLunL2, "IsServer", fServer); RC_CHECK();
1274	}
1275	else if (HostMode == PortMode_HostDevice)
1276	{
1277	rc = CFGMR3InsertString(pLunL0, "Driver", "Host Serial"); RC_CHECK();
1278	rc = CFGMR3InsertNode(pLunL0, "Config", &pLunL1); RC_CHECK();
1279	rc = CFGMR3InsertString(pLunL1, "DevicePath", Utf8Str(path)); RC_CHECK();
1280	}
1281	}
1282	}
1283
1284	/*
1285	* Parallel (LPT) Ports
1286	*/
1287	rc = CFGMR3InsertNode(pDevices, "parallel", &pDev); RC_CHECK();
1288	for (ULONG ulInstance = 0; ulInstance < SchemaDefs::ParallelPortCount; ulInstance++)
1289	{
1290	ComPtr<IParallelPort> parallelPort;
1291	hrc = pMachine->GetParallelPort (ulInstance, parallelPort.asOutParam()); H();
1292	BOOL fEnabled = FALSE;
1293	if (parallelPort)
1294	hrc = parallelPort->COMGETTER(Enabled)(&fEnabled); H();
1295	if (!fEnabled)
1296	continue;
1297
1298	char szInstance[4]; Assert(ulInstance <= 999);
1299	RTStrPrintf(szInstance, sizeof(szInstance), "%lu", ulInstance);
1300
1301	rc = CFGMR3InsertNode(pDev, szInstance, &pInst); RC_CHECK();
1302	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
1303
1304	ULONG ulIRQ, ulIOBase;
1305	Bstr DevicePath;
1306	hrc = parallelPort->COMGETTER(IRQ)(&ulIRQ); H();
1307	hrc = parallelPort->COMGETTER(IOBase)(&ulIOBase); H();
1308	hrc = parallelPort->COMGETTER(Path)(DevicePath.asOutParam()); H();
1309	rc = CFGMR3InsertInteger(pCfg, "IRQ", ulIRQ); RC_CHECK();
1310	rc = CFGMR3InsertInteger(pCfg, "IOBase", ulIOBase); RC_CHECK();
1311	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1312	rc = CFGMR3InsertString(pLunL0, "Driver", "HostParallel"); RC_CHECK();
1313	rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
1314	rc = CFGMR3InsertString(pLunL1, "DevicePath", Utf8Str(DevicePath)); RC_CHECK();
1315	}
1316
1317	/*
1318	* VMM Device
1319	*/
1320	rc = CFGMR3InsertNode(pDevices, "VMMDev", &pDev); RC_CHECK();
1321	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
1322	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
1323	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
1324	rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 4); RC_CHECK();
1325	Assert(!afPciDeviceNo[4]);
1326	afPciDeviceNo[4] = true;
1327	rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
1328
1329	/* the VMM device's Main driver */
1330	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1331	rc = CFGMR3InsertString(pLunL0, "Driver", "MainVMMDev"); RC_CHECK();
1332	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1333	VMMDev *pVMMDev = pConsole->mVMMDev;
1334	rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pVMMDev); RC_CHECK();
1335
1336	/*
1337	* Attach the status driver.
1338	*/
1339	rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
1340	rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
1341	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1342	rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapSharedFolderLed); RC_CHECK();
1343	rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
1344	rc = CFGMR3InsertInteger(pCfg, "Last", 0); RC_CHECK();
1345
1346	/*
1347	* Audio Sniffer Device
1348	*/
1349	rc = CFGMR3InsertNode(pDevices, "AudioSniffer", &pDev); RC_CHECK();
1350	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
1351	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
1352
1353	/* the Audio Sniffer device's Main driver */
1354	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1355	rc = CFGMR3InsertString(pLunL0, "Driver", "MainAudioSniffer"); RC_CHECK();
1356	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1357	AudioSniffer *pAudioSniffer = pConsole->mAudioSniffer;
1358	rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pAudioSniffer); RC_CHECK();
1359
1360	/*
1361	* AC'97 ICH / SoundBlaster16 audio
1362	*/
1363	ComPtr<IAudioAdapter> audioAdapter;
1364	hrc = pMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam()); H();
1365	if (audioAdapter)
1366	hrc = audioAdapter->COMGETTER(Enabled)(&enabled); H();
1367
1368	if (enabled)
1369	{
1370	AudioControllerType_T audioController;
1371	hrc = audioAdapter->COMGETTER(AudioController)(&audioController); H();
1372	switch (audioController)
1373	{
1374	case AudioControllerType_AC97:
1375	{
1376	/* default: ICH AC97 */
1377	rc = CFGMR3InsertNode(pDevices, "ichac97", &pDev); RC_CHECK();
1378	rc = CFGMR3InsertNode(pDev, "0", &pInst);
1379	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
1380	rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 5); RC_CHECK();
1381	Assert(!afPciDeviceNo[5]);
1382	afPciDeviceNo[5] = true;
1383	rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
1384	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
1385	break;
1386	}
1387	case AudioControllerType_SB16:
1388	{
1389	/* legacy SoundBlaster16 */
1390	rc = CFGMR3InsertNode(pDevices, "sb16", &pDev); RC_CHECK();
1391	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
1392	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
1393	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
1394	rc = CFGMR3InsertInteger(pCfg, "IRQ", 5); RC_CHECK();
1395	rc = CFGMR3InsertInteger(pCfg, "DMA", 1); RC_CHECK();
1396	rc = CFGMR3InsertInteger(pCfg, "DMA16", 5); RC_CHECK();
1397	rc = CFGMR3InsertInteger(pCfg, "Port", 0x220); RC_CHECK();
1398	rc = CFGMR3InsertInteger(pCfg, "Version", 0x0405); RC_CHECK();
1399	break;
1400	}
1401	}
1402
1403	/* the Audio driver */
1404	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1405	rc = CFGMR3InsertString(pLunL0, "Driver", "AUDIO"); RC_CHECK();
1406	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1407
1408	AudioDriverType_T audioDriver;
1409	hrc = audioAdapter->COMGETTER(AudioDriver)(&audioDriver); H();
1410	switch (audioDriver)
1411	{
1412	case AudioDriverType_Null:
1413	{
1414	rc = CFGMR3InsertString(pCfg, "AudioDriver", "null"); RC_CHECK();
1415	break;
1416	}
1417	#ifdef RT_OS_WINDOWS
1418	#ifdef VBOX_WITH_WINMM
1419	case AudioDriverType_WinMM:
1420	{
1421	rc = CFGMR3InsertString(pCfg, "AudioDriver", "winmm"); RC_CHECK();
1422	break;
1423	}
1424	#endif
1425	case AudioDriverType_DirectSound:
1426	{
1427	rc = CFGMR3InsertString(pCfg, "AudioDriver", "dsound"); RC_CHECK();
1428	break;
1429	}
1430	#endif /* RT_OS_WINDOWS */
1431	#ifdef RT_OS_SOLARIS
1432	case AudioDriverType_SolAudio:
1433	{
1434	rc = CFGMR3InsertString(pCfg, "AudioDriver", "solaudio"); RC_CHECK();
1435	break;
1436	}
1437	#endif
1438	#ifdef RT_OS_LINUX
1439	case AudioDriverType_OSS:
1440	{
1441	rc = CFGMR3InsertString(pCfg, "AudioDriver", "oss"); RC_CHECK();
1442	break;
1443	}
1444	# ifdef VBOX_WITH_ALSA
1445	case AudioDriverType_ALSA:
1446	{
1447	rc = CFGMR3InsertString(pCfg, "AudioDriver", "alsa"); RC_CHECK();
1448	break;
1449	}
1450	# endif
1451	# ifdef VBOX_WITH_PULSE
1452	case AudioDriverType_Pulse:
1453	{
1454	rc = CFGMR3InsertString(pCfg, "AudioDriver", "pulse"); RC_CHECK();
1455	break;
1456	}
1457	# endif
1458	#endif /* RT_OS_LINUX */
1459	#ifdef RT_OS_DARWIN
1460	case AudioDriverType_CoreAudio:
1461	{
1462	rc = CFGMR3InsertString(pCfg, "AudioDriver", "coreaudio"); RC_CHECK();
1463	break;
1464	}
1465	#endif
1466	}
1467	hrc = pMachine->COMGETTER(Name)(&str); H();
1468	STR_CONV();
1469	rc = CFGMR3InsertString(pCfg, "StreamName", psz); RC_CHECK();
1470	STR_FREE();
1471	}
1472
1473	/*
1474	* The USB Controller.
1475	*/
1476	ComPtr<IUSBController> USBCtlPtr;
1477	hrc = pMachine->COMGETTER(USBController)(USBCtlPtr.asOutParam());
1478	if (USBCtlPtr)
1479	{
1480	BOOL fEnabled;
1481	hrc = USBCtlPtr->COMGETTER(Enabled)(&fEnabled); H();
1482	if (fEnabled)
1483	{
1484	rc = CFGMR3InsertNode(pDevices, "usb-ohci", &pDev); RC_CHECK();
1485	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
1486	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
1487	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
1488	rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 6); RC_CHECK();
1489	Assert(!afPciDeviceNo[6]);
1490	afPciDeviceNo[6] = true;
1491	rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
1492
1493	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1494	rc = CFGMR3InsertString(pLunL0, "Driver", "VUSBRootHub"); RC_CHECK();
1495	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1496
1497	/*
1498	* Attach the status driver.
1499	*/
1500	rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
1501	rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
1502	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1503	rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapUSBLed);RC_CHECK();
1504	rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
1505	rc = CFGMR3InsertInteger(pCfg, "Last", 0); RC_CHECK();
1506
1507	#ifdef VBOX_WITH_EHCI
1508	hrc = USBCtlPtr->COMGETTER(EnabledEhci)(&fEnabled); H();
1509	if (fEnabled)
1510	{
1511	rc = CFGMR3InsertNode(pDevices, "usb-ehci", &pDev); RC_CHECK();
1512	rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
1513	rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
1514	rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
1515	rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 11); RC_CHECK();
1516	Assert(!afPciDeviceNo[11]);
1517	afPciDeviceNo[11] = true;
1518	rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
1519
1520	rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1521	rc = CFGMR3InsertString(pLunL0, "Driver", "VUSBRootHub"); RC_CHECK();
1522	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1523
1524	/*
1525	* Attach the status driver.
1526	*/
1527	rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
1528	rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
1529	rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1530	rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapUSBLed);RC_CHECK();
1531	rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
1532	rc = CFGMR3InsertInteger(pCfg, "Last", 0); RC_CHECK();
1533	}
1534	else
1535	#endif
1536	{
1537	/*
1538	* Enable the 2.0 -> 1.1 device morphing of proxied devies to keep windows quiet.
1539	*/
1540	rc = CFGMR3InsertNode(pRoot, "USB", &pCfg); RC_CHECK();
1541	rc = CFGMR3InsertNode(pCfg, "USBProxy", &pCfg); RC_CHECK();
1542	rc = CFGMR3InsertNode(pCfg, "GlobalConfig", &pCfg); RC_CHECK();
1543	rc = CFGMR3InsertInteger(pCfg, "Force11Device", true); RC_CHECK();
1544	// The following breaks stuff, but it makes MSDs work in vista. (I include it here so
1545	// that it's documented somewhere.) Users needing it can use:
1546	// VBoxManage setextradata "myvm" "VBoxInternal/USB/USBProxy/GlobalConfig/Force11PacketSize" 1
1547	//rc = CFGMR3InsertInteger(pCfg, "Force11PacketSize", true); RC_CHECK();
1548	}
1549	}
1550	}
1551
1552	/*
1553	* Clipboard
1554	*/
1555	{
1556	ClipboardMode_T mode = ClipboardMode_Disabled;
1557	hrc = pMachine->COMGETTER(ClipboardMode) (&mode); H();
1558
1559	if (mode != ClipboardMode_Disabled)
1560	{
1561	/* Load the service */
1562	rc = pConsole->mVMMDev->hgcmLoadService ("VBoxSharedClipboard", "VBoxSharedClipboard");
1563
1564	if (VBOX_FAILURE (rc))
1565	{
1566	LogRel(("VBoxSharedClipboard is not available. rc = %Vrc\n", rc));
1567	/* That is not a fatal failure. */
1568	rc = VINF_SUCCESS;
1569	}
1570	else
1571	{
1572	/* Setup the service. */
1573	VBOXHGCMSVCPARM parm;
1574
1575	parm.type = VBOX_HGCM_SVC_PARM_32BIT;
1576
1577	switch (mode)
1578	{
1579	default:
1580	case ClipboardMode_Disabled:
1581	{
1582	LogRel(("VBoxSharedClipboard mode: Off\n"));
1583	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_OFF;
1584	break;
1585	}
1586	case ClipboardMode_GuestToHost:
1587	{
1588	LogRel(("VBoxSharedClipboard mode: Guest to Host\n"));
1589	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST;
1590	break;
1591	}
1592	case ClipboardMode_HostToGuest:
1593	{
1594	LogRel(("VBoxSharedClipboard mode: Host to Guest\n"));
1595	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST;
1596	break;
1597	}
1598	case ClipboardMode_Bidirectional:
1599	{
1600	LogRel(("VBoxSharedClipboard mode: Bidirectional\n"));
1601	parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL;
1602	break;
1603	}
1604	}
1605
1606	pConsole->mVMMDev->hgcmHostCall ("VBoxSharedClipboard", VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE, 1, &parm);
1607
1608	Log(("Set VBoxSharedClipboard mode\n"));
1609	}
1610	}
1611	}
1612
1613	/*
1614	* CFGM overlay handling.
1615	*
1616	* Here we check the extra data entries for CFGM values
1617	* and create the nodes and insert the values on the fly. Existing
1618	* values will be removed and reinserted. If a value is a valid number,
1619	* it will be inserted as a number, otherwise as a string.
1620	*
1621	* We first perform a run on global extra data, then on the machine
1622	* extra data to support global settings with local overrides.
1623	*
1624	*/
1625	Bstr strExtraDataKey;
1626	bool fGlobalExtraData = true;
1627	for (;;)
1628	{
1629	Bstr strNextExtraDataKey;
1630	Bstr strExtraDataValue;
1631
1632	/* get the next key */
1633	if (fGlobalExtraData)
1634	hrc = virtualBox->GetNextExtraDataKey(strExtraDataKey, strNextExtraDataKey.asOutParam(),
1635	strExtraDataValue.asOutParam());
1636	else
1637	hrc = pMachine->GetNextExtraDataKey(strExtraDataKey, strNextExtraDataKey.asOutParam(),
1638	strExtraDataValue.asOutParam());
1639
1640	/* stop if for some reason there's nothing more to request */
1641	if (FAILED(hrc) \|\| !strNextExtraDataKey)
1642	{
1643	/* if we're out of global keys, continue with machine, otherwise we're done */
1644	if (fGlobalExtraData)
1645	{
1646	fGlobalExtraData = false;
1647	strExtraDataKey.setNull();
1648	continue;
1649	}
1650	break;
1651	}
1652
1653	strExtraDataKey = strNextExtraDataKey;
1654	Utf8Str strExtraDataKeyUtf8 = Utf8Str(strExtraDataKey);
1655
1656	/* we only care about keys starting with "VBoxInternal/" */
1657	if (strncmp(strExtraDataKeyUtf8.raw(), "VBoxInternal/", 13) != 0)
1658	continue;
1659	char pszExtraDataKey = (char)strExtraDataKeyUtf8.raw() + 13;
1660
1661	/* the key will be in the format "Node1/Node2/Value" or simply "Value". */
1662	PCFGMNODE pNode;
1663	char *pszCFGMValueName = strrchr(pszExtraDataKey, '/');
1664	if (pszCFGMValueName)
1665	{
1666	/* terminate the node and advance to the value */
1667	*pszCFGMValueName = '\0';
1668	pszCFGMValueName++;
1669
1670	/* does the node already exist? */
1671	pNode = CFGMR3GetChild(pRoot, pszExtraDataKey);
1672	if (pNode)
1673	{
1674	/* the value might already exist, remove it to be safe */
1675	CFGMR3RemoveValue(pNode, pszCFGMValueName);
1676	}
1677	else
1678	{
1679	/* create the node */
1680	rc = CFGMR3InsertNode(pRoot, pszExtraDataKey, &pNode);
1681	AssertMsgRC(rc, ("failed to insert node '%s'\n", pszExtraDataKey));
1682	if (VBOX_FAILURE(rc) \|\| !pNode)
1683	continue;
1684	}
1685	}
1686	else
1687	{
1688	pNode = pRoot;
1689	pszCFGMValueName = pszExtraDataKey;
1690	pszExtraDataKey--;
1691
1692	/* the value might already exist, remove it to be safe */
1693	CFGMR3RemoveValue(pNode, pszCFGMValueName);
1694	}
1695
1696	/* now let's have a look at the value */
1697	Utf8Str strCFGMValueUtf8 = Utf8Str(strExtraDataValue);
1698	const char *pszCFGMValue = strCFGMValueUtf8.raw();
1699	/* empty value means remove value which we've already done */
1700	if (pszCFGMValue && *pszCFGMValue)
1701	{
1702	/* if it's a valid number, we'll insert it as such, otherwise string */
1703	uint64_t u64Value;
1704	char *pszNext = NULL;
1705	if ( RTStrToUInt64Ex(pszCFGMValue, &pszNext, 0, &u64Value) == VINF_SUCCESS
1706	&& (!pszNext \|\| pszNext == '\0') / check if the _whole_ string is a valid number */
1707	)
1708	{
1709	rc = CFGMR3InsertInteger(pNode, pszCFGMValueName, u64Value);
1710	}
1711	else
1712	{
1713	rc = CFGMR3InsertString(pNode, pszCFGMValueName, pszCFGMValue);
1714	}
1715	AssertMsgRC(rc, ("failed to insert CFGM value '%s' to key '%s'\n", pszCFGMValue, pszExtraDataKey));
1716	}
1717	}
1718
1719	#undef H
1720	#undef RC_CHECK
1721	#undef STR_FREE
1722	#undef STR_CONV
1723
1724	/* Register VM state change handler */
1725	int rc2 = VMR3AtStateRegister (pVM, Console::vmstateChangeCallback, pConsole);
1726	AssertRC (rc2);
1727	if (VBOX_SUCCESS (rc))
1728	rc = rc2;
1729
1730	/* Register VM runtime error handler */
1731	rc2 = VMR3AtRuntimeErrorRegister (pVM, Console::setVMRuntimeErrorCallback, pConsole);
1732	AssertRC (rc2);
1733	if (VBOX_SUCCESS (rc))
1734	rc = rc2;
1735
1736	/* Save the VM pointer in the machine object */
1737	pConsole->mpVM = pVM;
1738
1739	LogFlowFunc (("vrc = %Vrc\n", rc));
1740	LogFlowFuncLeave();
1741
1742	return rc;
1743	}
1744
1745

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

source: vbox/trunk/src/VBox/Main/ConsoleImpl2.cpp@ 7982

Download in other formats: