VirtualBox

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

Last change on this file since 61572 was 61320, checked in by vboxsync, 9 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette