VirtualBox

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

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

Main: fixed two format specifiers in Log/Assert statements

  • 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 61117 2016-05-23 09:10:42Z vboxsync $ */
2/** @file
3 * VBox Console COM Class implementation - VM Configuration Bits.
4 *
5 * @remark We've split out the code that the 64-bit VC++ v8 compiler finds
6 * problematic to optimize so we can disable optimizations and later,
7 * perhaps, find a real solution for it (like rewriting the code and
8 * to stop resemble a tonne of spaghetti).
9 */
10
11/*
12 * Copyright (C) 2006-2016 Oracle Corporation
13 *
14 * This file is part of VirtualBox Open Source Edition (OSE), as
15 * available from http://www.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 to 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#if defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD) || defined(VBOX_WITH_SOLARIS_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 /*
2908 * The VRDE audio backend driver. This one always is there
2909 * and therefore is hardcoded here.
2910 */
2911 InsertConfigNode(pInst, "LUN#1", &pLunL1);
2912 InsertConfigString(pLunL1, "Driver", "AUDIO");
2913
2914 InsertConfigNode(pLunL1, "AttachedDriver", &pLunL1);
2915 InsertConfigString(pLunL1, "Driver", "AudioVRDE");
2916
2917 InsertConfigNode(pLunL1, "Config", &pCfg);
2918 InsertConfigString(pCfg, "AudioDriver", "AudioVRDE");
2919 InsertConfigString(pCfg, "StreamName", bstr);
2920 InsertConfigInteger(pCfg, "Object", (uintptr_t)mAudioVRDE);
2921 InsertConfigInteger(pCfg, "ObjectVRDPServer", (uintptr_t)mConsoleVRDPServer);
2922
2923 /** @todo Add audio video recording driver here. */
2924 }
2925
2926 /*
2927 * Shared Clipboard.
2928 */
2929 {
2930 ClipboardMode_T mode = ClipboardMode_Disabled;
2931 hrc = pMachine->COMGETTER(ClipboardMode)(&mode); H();
2932
2933 if (/* mode != ClipboardMode_Disabled */ true)
2934 {
2935 /* Load the service */
2936 rc = pVMMDev->hgcmLoadService("VBoxSharedClipboard", "VBoxSharedClipboard");
2937 if (RT_FAILURE(rc))
2938 {
2939 LogRel(("Shared clipboard is not available, rc=%Rrc\n", rc));
2940 /* That is not a fatal failure. */
2941 rc = VINF_SUCCESS;
2942 }
2943 else
2944 {
2945 LogRel(("Shared clipboard service loaded\n"));
2946
2947 i_changeClipboardMode(mode);
2948
2949 /* Setup the service. */
2950 VBOXHGCMSVCPARM parm;
2951 parm.type = VBOX_HGCM_SVC_PARM_32BIT;
2952 parm.setUInt32(!i_useHostClipboard());
2953 pVMMDev->hgcmHostCall("VBoxSharedClipboard",
2954 VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS, 1, &parm);
2955 }
2956 }
2957 }
2958
2959 /*
2960 * HGCM HostChannel.
2961 */
2962 {
2963 Bstr value;
2964 hrc = pMachine->GetExtraData(Bstr("HGCM/HostChannel").raw(),
2965 value.asOutParam());
2966
2967 if ( hrc == S_OK
2968 && value == "1")
2969 {
2970 rc = pVMMDev->hgcmLoadService("VBoxHostChannel", "VBoxHostChannel");
2971 if (RT_FAILURE(rc))
2972 {
2973 LogRel(("VBoxHostChannel is not available, rc=%Rrc\n", rc));
2974 /* That is not a fatal failure. */
2975 rc = VINF_SUCCESS;
2976 }
2977 }
2978 }
2979
2980#ifdef VBOX_WITH_DRAG_AND_DROP
2981 /*
2982 * Drag and Drop.
2983 */
2984 {
2985 DnDMode_T enmMode = DnDMode_Disabled;
2986 hrc = pMachine->COMGETTER(DnDMode)(&enmMode); H();
2987
2988 /* Load the service */
2989 rc = pVMMDev->hgcmLoadService("VBoxDragAndDropSvc", "VBoxDragAndDropSvc");
2990 if (RT_FAILURE(rc))
2991 {
2992 LogRel(("Drag and drop service is not available, rc=%Rrc\n", rc));
2993 /* That is not a fatal failure. */
2994 rc = VINF_SUCCESS;
2995 }
2996 else
2997 {
2998 HGCMSVCEXTHANDLE hDummy;
2999 rc = HGCMHostRegisterServiceExtension(&hDummy, "VBoxDragAndDropSvc",
3000 &GuestDnD::notifyDnDDispatcher,
3001 GuestDnDInst());
3002 if (RT_FAILURE(rc))
3003 Log(("Cannot register VBoxDragAndDropSvc extension, rc=%Rrc\n", rc));
3004 else
3005 {
3006 LogRel(("Drag and drop service loaded\n"));
3007 rc = i_changeDnDMode(enmMode);
3008 }
3009 }
3010 }
3011#endif /* VBOX_WITH_DRAG_AND_DROP */
3012
3013#ifdef VBOX_WITH_CROGL
3014 /*
3015 * crOpenGL.
3016 */
3017 {
3018 BOOL fEnabled3D = false;
3019 hrc = pMachine->COMGETTER(Accelerate3DEnabled)(&fEnabled3D); H();
3020
3021 if ( fEnabled3D
3022# ifdef VBOX_WITH_VMSVGA3D
3023 && enmGraphicsController == GraphicsControllerType_VBoxVGA
3024# endif
3025 )
3026 {
3027 BOOL fSupports3D = VBoxOglIs3DAccelerationSupported();
3028 if (!fSupports3D)
3029 return VMR3SetError(pUVM, VERR_NOT_AVAILABLE, RT_SRC_POS,
3030 N_("This VM was configured to use 3D acceleration. However, the "
3031 "3D support of the host is not working properly and the "
3032 "VM cannot be started. To fix this problem, either "
3033 "fix the host 3D support (update the host graphics driver?) "
3034 "or disable 3D acceleration in the VM settings"));
3035
3036 /* Load the service. */
3037 rc = pVMMDev->hgcmLoadService("VBoxSharedCrOpenGL", "VBoxSharedCrOpenGL");
3038 if (RT_FAILURE(rc))
3039 {
3040 LogRel(("Failed to load Shared OpenGL service, rc=%Rrc\n", rc));
3041 /* That is not a fatal failure. */
3042 rc = VINF_SUCCESS;
3043 }
3044 else
3045 {
3046 LogRel(("Shared OpenGL service loaded -- 3D enabled\n"));
3047
3048 /* Setup the service. */
3049 VBOXHGCMSVCPARM parm;
3050 parm.type = VBOX_HGCM_SVC_PARM_PTR;
3051
3052 parm.u.pointer.addr = (IConsole *)(Console *)this;
3053 parm.u.pointer.size = sizeof(IConsole *);
3054
3055 rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SET_CONSOLE,
3056 SHCRGL_CPARMS_SET_CONSOLE, &parm);
3057 if (!RT_SUCCESS(rc))
3058 AssertMsgFailed(("SHCRGL_HOST_FN_SET_CONSOLE failed with %Rrc\n", rc));
3059
3060 parm.u.pointer.addr = pVM;
3061 parm.u.pointer.size = sizeof(pVM);
3062 rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL",
3063 SHCRGL_HOST_FN_SET_VM, SHCRGL_CPARMS_SET_VM, &parm);
3064 if (!RT_SUCCESS(rc))
3065 AssertMsgFailed(("SHCRGL_HOST_FN_SET_VM failed with %Rrc\n", rc));
3066 }
3067 }
3068 }
3069#endif
3070
3071#ifdef VBOX_WITH_GUEST_PROPS
3072 /*
3073 * Guest property service.
3074 */
3075 rc = i_configGuestProperties(this, pUVM);
3076#endif /* VBOX_WITH_GUEST_PROPS defined */
3077
3078#ifdef VBOX_WITH_GUEST_CONTROL
3079 /*
3080 * Guest control service.
3081 */
3082 rc = i_configGuestControl(this);
3083#endif /* VBOX_WITH_GUEST_CONTROL defined */
3084
3085 /*
3086 * ACPI
3087 */
3088 BOOL fACPI;
3089 hrc = biosSettings->COMGETTER(ACPIEnabled)(&fACPI); H();
3090 if (fACPI)
3091 {
3092 /* Always show the CPU leafs when we have multiple VCPUs or when the IO-APIC is enabled.
3093 * The Windows SMP kernel needs a CPU leaf or else its idle loop will burn cpu cycles; the
3094 * intelppm driver refuses to register an idle state handler.
3095 * Always show CPU leafs for OS X guests. */
3096 BOOL fShowCpu = fOsXGuest;
3097 if (cCpus > 1 || fIOAPIC)
3098 fShowCpu = true;
3099
3100 BOOL fCpuHotPlug;
3101 hrc = pMachine->COMGETTER(CPUHotPlugEnabled)(&fCpuHotPlug); H();
3102
3103 InsertConfigNode(pDevices, "acpi", &pDev);
3104 InsertConfigNode(pDev, "0", &pInst);
3105 InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
3106 InsertConfigNode(pInst, "Config", &pCfg);
3107 hrc = pBusMgr->assignPCIDevice("acpi", pInst); H();
3108
3109 InsertConfigInteger(pCfg, "RamSize", cbRam);
3110 InsertConfigInteger(pCfg, "RamHoleSize", cbRamHole);
3111 InsertConfigInteger(pCfg, "NumCPUs", cCpus);
3112
3113 InsertConfigInteger(pCfg, "IOAPIC", fIOAPIC);
3114 InsertConfigInteger(pCfg, "FdcEnabled", fFdcEnabled);
3115 InsertConfigInteger(pCfg, "HpetEnabled", fHPETEnabled);
3116 InsertConfigInteger(pCfg, "SmcEnabled", fSmcEnabled);
3117 InsertConfigInteger(pCfg, "ShowRtc", fShowRtc);
3118 if (fOsXGuest && !llBootNics.empty())
3119 {
3120 BootNic aNic = llBootNics.front();
3121 uint32_t u32NicPCIAddr = (aNic.mPCIAddress.miDevice << 16) | aNic.mPCIAddress.miFn;
3122 InsertConfigInteger(pCfg, "NicPciAddress", u32NicPCIAddr);
3123 }
3124 if (fOsXGuest && fAudioEnabled)
3125 {
3126 PCIBusAddress Address;
3127 if (pBusMgr->findPCIAddress("hda", 0, Address))
3128 {
3129 uint32_t u32AudioPCIAddr = (Address.miDevice << 16) | Address.miFn;
3130 InsertConfigInteger(pCfg, "AudioPciAddress", u32AudioPCIAddr);
3131 }
3132 }
3133 InsertConfigInteger(pCfg, "IocPciAddress", uIocPCIAddress);
3134 if (chipsetType == ChipsetType_ICH9)
3135 {
3136 InsertConfigInteger(pCfg, "McfgBase", uMcfgBase);
3137 InsertConfigInteger(pCfg, "McfgLength", cbMcfgLength);
3138 }
3139 InsertConfigInteger(pCfg, "HostBusPciAddress", uHbcPCIAddress);
3140 InsertConfigInteger(pCfg, "ShowCpu", fShowCpu);
3141 InsertConfigInteger(pCfg, "CpuHotPlug", fCpuHotPlug);
3142
3143 InsertConfigInteger(pCfg, "Serial0IoPortBase", auSerialIoPortBase[0]);
3144 InsertConfigInteger(pCfg, "Serial0Irq", auSerialIrq[0]);
3145
3146 InsertConfigInteger(pCfg, "Serial1IoPortBase", auSerialIoPortBase[1]);
3147 InsertConfigInteger(pCfg, "Serial1Irq", auSerialIrq[1]);
3148
3149 if (auSerialIoPortBase[2])
3150 {
3151 InsertConfigInteger(pCfg, "Serial2IoPortBase", auSerialIoPortBase[2]);
3152 InsertConfigInteger(pCfg, "Serial2Irq", auSerialIrq[2]);
3153 }
3154
3155 if (auSerialIoPortBase[3])
3156 {
3157 InsertConfigInteger(pCfg, "Serial3IoPortBase", auSerialIoPortBase[3]);
3158 InsertConfigInteger(pCfg, "Serial3Irq", auSerialIrq[3]);
3159 }
3160
3161 InsertConfigInteger(pCfg, "Parallel0IoPortBase", auParallelIoPortBase[0]);
3162 InsertConfigInteger(pCfg, "Parallel0Irq", auParallelIrq[0]);
3163
3164 InsertConfigInteger(pCfg, "Parallel1IoPortBase", auParallelIoPortBase[1]);
3165 InsertConfigInteger(pCfg, "Parallel1Irq", auParallelIrq[1]);
3166
3167 InsertConfigNode(pInst, "LUN#0", &pLunL0);
3168 InsertConfigString(pLunL0, "Driver", "ACPIHost");
3169 InsertConfigNode(pLunL0, "Config", &pCfg);
3170
3171 /* Attach the dummy CPU drivers */
3172 for (ULONG iCpuCurr = 1; iCpuCurr < cCpus; iCpuCurr++)
3173 {
3174 BOOL fCpuAttached = true;
3175
3176 if (fCpuHotPlug)
3177 {
3178 hrc = pMachine->GetCPUStatus(iCpuCurr, &fCpuAttached); H();
3179 }
3180
3181 if (fCpuAttached)
3182 {
3183 InsertConfigNode(pInst, Utf8StrFmt("LUN#%u", iCpuCurr).c_str(), &pLunL0);
3184 InsertConfigString(pLunL0, "Driver", "ACPICpu");
3185 InsertConfigNode(pLunL0, "Config", &pCfg);
3186 }
3187 }
3188 }
3189
3190 /*
3191 * Configure DBGF (Debug(ger) Facility) and DBGC (Debugger Console).
3192 */
3193 {
3194 PCFGMNODE pDbgf;
3195 InsertConfigNode(pRoot, "DBGF", &pDbgf);
3196
3197 /* Paths to search for debug info and such things. */
3198 hrc = pMachine->COMGETTER(SettingsFilePath)(bstr.asOutParam()); H();
3199 Utf8Str strSettingsPath(bstr);
3200 bstr.setNull();
3201 strSettingsPath.stripFilename();
3202 strSettingsPath.append("/");
3203
3204 char szHomeDir[RTPATH_MAX + 1];
3205 int rc2 = RTPathUserHome(szHomeDir, sizeof(szHomeDir) - 1);
3206 if (RT_FAILURE(rc2))
3207 szHomeDir[0] = '\0';
3208 RTPathEnsureTrailingSeparator(szHomeDir, sizeof(szHomeDir));
3209
3210
3211 Utf8Str strPath;
3212 strPath.append(strSettingsPath).append("debug/;");
3213 strPath.append(strSettingsPath).append(";");
3214 strPath.append(szHomeDir);
3215
3216 InsertConfigString(pDbgf, "Path", strPath.c_str());
3217
3218 /* Tracing configuration. */
3219 BOOL fTracingEnabled;
3220 hrc = pMachine->COMGETTER(TracingEnabled)(&fTracingEnabled); H();
3221 if (fTracingEnabled)
3222 InsertConfigInteger(pDbgf, "TracingEnabled", 1);
3223
3224 hrc = pMachine->COMGETTER(TracingConfig)(bstr.asOutParam()); H();
3225 if (fTracingEnabled)
3226 InsertConfigString(pDbgf, "TracingConfig", bstr);
3227
3228 BOOL fAllowTracingToAccessVM;
3229 hrc = pMachine->COMGETTER(AllowTracingToAccessVM)(&fAllowTracingToAccessVM); H();
3230 if (fAllowTracingToAccessVM)
3231 InsertConfigInteger(pPDM, "AllowTracingToAccessVM", 1);
3232
3233 /* Debugger console config. */
3234 PCFGMNODE pDbgc;
3235 InsertConfigNode(pRoot, "DBGC", &pDbgc);
3236
3237 hrc = virtualBox->COMGETTER(HomeFolder)(bstr.asOutParam()); H();
3238 Utf8Str strVBoxHome = bstr;
3239 bstr.setNull();
3240 if (strVBoxHome.isNotEmpty())
3241 strVBoxHome.append("/");
3242 else
3243 {
3244 strVBoxHome = szHomeDir;
3245 strVBoxHome.append("/.vbox");
3246 }
3247
3248 Utf8Str strFile(strVBoxHome);
3249 strFile.append("dbgc-history");
3250 InsertConfigString(pDbgc, "HistoryFile", strFile);
3251
3252 strFile = strSettingsPath;
3253 strFile.append("dbgc-init");
3254 InsertConfigString(pDbgc, "LocalInitScript", strFile);
3255
3256 strFile = strVBoxHome;
3257 strFile.append("dbgc-init");
3258 InsertConfigString(pDbgc, "GlobalInitScript", strFile);
3259 }
3260 }
3261 catch (ConfigError &x)
3262 {
3263 // InsertConfig threw something:
3264 return x.m_vrc;
3265 }
3266 catch (HRESULT hrcXcpt)
3267 {
3268 AssertLogRelMsgFailedReturn(("hrc=%Rhrc\n", hrcXcpt), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR);
3269 }
3270
3271#ifdef VBOX_WITH_EXTPACK
3272 /*
3273 * Call the extension pack hooks if everything went well thus far.
3274 */
3275 if (RT_SUCCESS(rc))
3276 {
3277 pAlock->release();
3278 rc = mptrExtPackManager->i_callAllVmConfigureVmmHooks(this, pVM);
3279 pAlock->acquire();
3280 }
3281#endif
3282
3283 /*
3284 * Apply the CFGM overlay.
3285 */
3286 if (RT_SUCCESS(rc))
3287 rc = i_configCfgmOverlay(pRoot, virtualBox, pMachine);
3288
3289 /*
3290 * Dump all extradata API settings tweaks, both global and per VM.
3291 */
3292 if (RT_SUCCESS(rc))
3293 rc = i_configDumpAPISettingsTweaks(virtualBox, pMachine);
3294
3295#undef H
3296
3297 pAlock->release(); /* Avoid triggering the lock order inversion check. */
3298
3299 /*
3300 * Register VM state change handler.
3301 */
3302 int rc2 = VMR3AtStateRegister(pUVM, Console::i_vmstateChangeCallback, this);
3303 AssertRC(rc2);
3304 if (RT_SUCCESS(rc))
3305 rc = rc2;
3306
3307 /*
3308 * Register VM runtime error handler.
3309 */
3310 rc2 = VMR3AtRuntimeErrorRegister(pUVM, Console::i_setVMRuntimeErrorCallback, this);
3311 AssertRC(rc2);
3312 if (RT_SUCCESS(rc))
3313 rc = rc2;
3314
3315 pAlock->acquire();
3316
3317 LogFlowFunc(("vrc = %Rrc\n", rc));
3318 LogFlowFuncLeave();
3319
3320 return rc;
3321}
3322
3323/**
3324 * Applies the CFGM overlay as specified by VBoxInternal/XXX extra data
3325 * values.
3326 *
3327 * @returns VBox status code.
3328 * @param pRoot The root of the configuration tree.
3329 * @param pVirtualBox Pointer to the IVirtualBox interface.
3330 * @param pMachine Pointer to the IMachine interface.
3331 */
3332/* static */
3333int Console::i_configCfgmOverlay(PCFGMNODE pRoot, IVirtualBox *pVirtualBox, IMachine *pMachine)
3334{
3335 /*
3336 * CFGM overlay handling.
3337 *
3338 * Here we check the extra data entries for CFGM values
3339 * and create the nodes and insert the values on the fly. Existing
3340 * values will be removed and reinserted. CFGM is typed, so by default
3341 * we will guess whether it's a string or an integer (byte arrays are
3342 * not currently supported). It's possible to override this autodetection
3343 * by adding "string:", "integer:" or "bytes:" (future).
3344 *
3345 * We first perform a run on global extra data, then on the machine
3346 * extra data to support global settings with local overrides.
3347 */
3348 int rc = VINF_SUCCESS;
3349 try
3350 {
3351 /** @todo add support for removing nodes and byte blobs. */
3352 /*
3353 * Get the next key
3354 */
3355 SafeArray<BSTR> aGlobalExtraDataKeys;
3356 SafeArray<BSTR> aMachineExtraDataKeys;
3357 HRESULT hrc = pVirtualBox->GetExtraDataKeys(ComSafeArrayAsOutParam(aGlobalExtraDataKeys));
3358 AssertMsg(SUCCEEDED(hrc), ("VirtualBox::GetExtraDataKeys failed with %Rhrc\n", hrc));
3359
3360 // remember the no. of global values so we can call the correct method below
3361 size_t cGlobalValues = aGlobalExtraDataKeys.size();
3362
3363 hrc = pMachine->GetExtraDataKeys(ComSafeArrayAsOutParam(aMachineExtraDataKeys));
3364 AssertMsg(SUCCEEDED(hrc), ("Machine::GetExtraDataKeys failed with %Rhrc\n", hrc));
3365
3366 // build a combined list from global keys...
3367 std::list<Utf8Str> llExtraDataKeys;
3368
3369 for (size_t i = 0; i < aGlobalExtraDataKeys.size(); ++i)
3370 llExtraDataKeys.push_back(Utf8Str(aGlobalExtraDataKeys[i]));
3371 // ... and machine keys
3372 for (size_t i = 0; i < aMachineExtraDataKeys.size(); ++i)
3373 llExtraDataKeys.push_back(Utf8Str(aMachineExtraDataKeys[i]));
3374
3375 size_t i2 = 0;
3376 for (std::list<Utf8Str>::const_iterator it = llExtraDataKeys.begin();
3377 it != llExtraDataKeys.end();
3378 ++it, ++i2)
3379 {
3380 const Utf8Str &strKey = *it;
3381
3382 /*
3383 * We only care about keys starting with "VBoxInternal/" (skip "G:" or "M:")
3384 */
3385 if (!strKey.startsWith("VBoxInternal/"))
3386 continue;
3387
3388 const char *pszExtraDataKey = strKey.c_str() + sizeof("VBoxInternal/") - 1;
3389
3390 // get the value
3391 Bstr bstrExtraDataValue;
3392 if (i2 < cGlobalValues)
3393 // this is still one of the global values:
3394 hrc = pVirtualBox->GetExtraData(Bstr(strKey).raw(),
3395 bstrExtraDataValue.asOutParam());
3396 else
3397 hrc = pMachine->GetExtraData(Bstr(strKey).raw(),
3398 bstrExtraDataValue.asOutParam());
3399 if (FAILED(hrc))
3400 LogRel(("Warning: Cannot get extra data key %s, rc = %Rhrc\n", strKey.c_str(), hrc));
3401
3402 /*
3403 * The key will be in the format "Node1/Node2/Value" or simply "Value".
3404 * Split the two and get the node, delete the value and create the node
3405 * if necessary.
3406 */
3407 PCFGMNODE pNode;
3408 const char *pszCFGMValueName = strrchr(pszExtraDataKey, '/');
3409 if (pszCFGMValueName)
3410 {
3411 /* terminate the node and advance to the value (Utf8Str might not
3412 offically like this but wtf) */
3413 *(char*)pszCFGMValueName = '\0';
3414 ++pszCFGMValueName;
3415
3416 /* does the node already exist? */
3417 pNode = CFGMR3GetChild(pRoot, pszExtraDataKey);
3418 if (pNode)
3419 CFGMR3RemoveValue(pNode, pszCFGMValueName);
3420 else
3421 {
3422 /* create the node */
3423 rc = CFGMR3InsertNode(pRoot, pszExtraDataKey, &pNode);
3424 if (RT_FAILURE(rc))
3425 {
3426 AssertLogRelMsgRC(rc, ("failed to insert node '%s'\n", pszExtraDataKey));
3427 continue;
3428 }
3429 Assert(pNode);
3430 }
3431 }
3432 else
3433 {
3434 /* root value (no node path). */
3435 pNode = pRoot;
3436 pszCFGMValueName = pszExtraDataKey;
3437 pszExtraDataKey--;
3438 CFGMR3RemoveValue(pNode, pszCFGMValueName);
3439 }
3440
3441 /*
3442 * Now let's have a look at the value.
3443 * Empty strings means that we should remove the value, which we've
3444 * already done above.
3445 */
3446 Utf8Str strCFGMValueUtf8(bstrExtraDataValue);
3447 if (!strCFGMValueUtf8.isEmpty())
3448 {
3449 uint64_t u64Value;
3450
3451 /* check for type prefix first. */
3452 if (!strncmp(strCFGMValueUtf8.c_str(), RT_STR_TUPLE("string:")))
3453 InsertConfigString(pNode, pszCFGMValueName, strCFGMValueUtf8.c_str() + sizeof("string:") - 1);
3454 else if (!strncmp(strCFGMValueUtf8.c_str(), RT_STR_TUPLE("integer:")))
3455 {
3456 rc = RTStrToUInt64Full(strCFGMValueUtf8.c_str() + sizeof("integer:") - 1, 0, &u64Value);
3457 if (RT_SUCCESS(rc))
3458 rc = CFGMR3InsertInteger(pNode, pszCFGMValueName, u64Value);
3459 }
3460 else if (!strncmp(strCFGMValueUtf8.c_str(), RT_STR_TUPLE("bytes:")))
3461 {
3462 char const *pszBase64 = strCFGMValueUtf8.c_str() + sizeof("bytes:") - 1;
3463 ssize_t cbValue = RTBase64DecodedSize(pszBase64, NULL);
3464 if (cbValue > 0)
3465 {
3466 void *pvBytes = RTMemTmpAlloc(cbValue);
3467 if (pvBytes)
3468 {
3469 rc = RTBase64Decode(pszBase64, pvBytes, cbValue, NULL, NULL);
3470 if (RT_SUCCESS(rc))
3471 rc = CFGMR3InsertBytes(pNode, pszCFGMValueName, pvBytes, cbValue);
3472 RTMemTmpFree(pvBytes);
3473 }
3474 else
3475 rc = VERR_NO_TMP_MEMORY;
3476 }
3477 else if (cbValue == 0)
3478 rc = CFGMR3InsertBytes(pNode, pszCFGMValueName, NULL, 0);
3479 else
3480 rc = VERR_INVALID_BASE64_ENCODING;
3481 }
3482 /* auto detect type. */
3483 else if (RT_SUCCESS(RTStrToUInt64Full(strCFGMValueUtf8.c_str(), 0, &u64Value)))
3484 rc = CFGMR3InsertInteger(pNode, pszCFGMValueName, u64Value);
3485 else
3486 InsertConfigString(pNode, pszCFGMValueName, strCFGMValueUtf8);
3487 AssertLogRelMsgRCBreak(rc, ("failed to insert CFGM value '%s' to key '%s'\n",
3488 strCFGMValueUtf8.c_str(), pszExtraDataKey));
3489 }
3490 }
3491 }
3492 catch (ConfigError &x)
3493 {
3494 // InsertConfig threw something:
3495 return x.m_vrc;
3496 }
3497 return rc;
3498}
3499
3500/**
3501 * Dumps the API settings tweaks as specified by VBoxInternal2/XXX extra data
3502 * values.
3503 *
3504 * @returns VBox status code.
3505 * @param pVirtualBox Pointer to the IVirtualBox interface.
3506 * @param pMachine Pointer to the IMachine interface.
3507 */
3508/* static */
3509int Console::i_configDumpAPISettingsTweaks(IVirtualBox *pVirtualBox, IMachine *pMachine)
3510{
3511 {
3512 SafeArray<BSTR> aGlobalExtraDataKeys;
3513 HRESULT hrc = pVirtualBox->GetExtraDataKeys(ComSafeArrayAsOutParam(aGlobalExtraDataKeys));
3514 AssertMsg(SUCCEEDED(hrc), ("VirtualBox::GetExtraDataKeys failed with %Rhrc\n", hrc));
3515 bool hasKey = false;
3516 for (size_t i = 0; i < aGlobalExtraDataKeys.size(); i++)
3517 {
3518 Utf8Str strKey(aGlobalExtraDataKeys[i]);
3519 if (!strKey.startsWith("VBoxInternal2/"))
3520 continue;
3521
3522 Bstr bstrValue;
3523 hrc = pVirtualBox->GetExtraData(Bstr(strKey).raw(),
3524 bstrValue.asOutParam());
3525 if (FAILED(hrc))
3526 continue;
3527 if (!hasKey)
3528 LogRel(("Global extradata API settings:\n"));
3529 LogRel((" %s=\"%ls\"\n", strKey.c_str(), bstrValue.raw()));
3530 hasKey = true;
3531 }
3532 }
3533
3534 {
3535 SafeArray<BSTR> aMachineExtraDataKeys;
3536 HRESULT hrc = pMachine->GetExtraDataKeys(ComSafeArrayAsOutParam(aMachineExtraDataKeys));
3537 AssertMsg(SUCCEEDED(hrc), ("Machine::GetExtraDataKeys failed with %Rhrc\n", hrc));
3538 bool hasKey = false;
3539 for (size_t i = 0; i < aMachineExtraDataKeys.size(); i++)
3540 {
3541 Utf8Str strKey(aMachineExtraDataKeys[i]);
3542 if (!strKey.startsWith("VBoxInternal2/"))
3543 continue;
3544
3545 Bstr bstrValue;
3546 hrc = pMachine->GetExtraData(Bstr(strKey).raw(),
3547 bstrValue.asOutParam());
3548 if (FAILED(hrc))
3549 continue;
3550 if (!hasKey)
3551 LogRel(("Per-VM extradata API settings:\n"));
3552 LogRel((" %s=\"%ls\"\n", strKey.c_str(), bstrValue.raw()));
3553 hasKey = true;
3554 }
3555 }
3556
3557 return VINF_SUCCESS;
3558}
3559
3560int Console::i_configGraphicsController(PCFGMNODE pDevices,
3561 const GraphicsControllerType_T enmGraphicsController,
3562 BusAssignmentManager *pBusMgr,
3563 const ComPtr<IMachine> &ptrMachine,
3564 const ComPtr<IBIOSSettings> &ptrBiosSettings,
3565 bool fHMEnabled)
3566{
3567 // InsertConfig* throws
3568 try
3569 {
3570 PCFGMNODE pDev, pInst, pCfg, pLunL0;
3571 HRESULT hrc;
3572 Bstr bstr;
3573 const char *pcszDevice = "vga";
3574
3575#define H() AssertLogRelMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR)
3576 InsertConfigNode(pDevices, pcszDevice, &pDev);
3577 InsertConfigNode(pDev, "0", &pInst);
3578 InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
3579
3580 hrc = pBusMgr->assignPCIDevice(pcszDevice, pInst); H();
3581 InsertConfigNode(pInst, "Config", &pCfg);
3582 ULONG cVRamMBs;
3583 hrc = ptrMachine->COMGETTER(VRAMSize)(&cVRamMBs); H();
3584 InsertConfigInteger(pCfg, "VRamSize", cVRamMBs * _1M);
3585 ULONG cMonitorCount;
3586 hrc = ptrMachine->COMGETTER(MonitorCount)(&cMonitorCount); H();
3587 InsertConfigInteger(pCfg, "MonitorCount", cMonitorCount);
3588#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
3589 InsertConfigInteger(pCfg, "R0Enabled", fHMEnabled);
3590#else
3591 NOREF(fHMEnabled);
3592#endif
3593
3594 i_attachStatusDriver(pInst, &mapCrOglLed, 0, 0, NULL, NULL, 0);
3595
3596#ifdef VBOX_WITH_VMSVGA
3597 if (enmGraphicsController == GraphicsControllerType_VMSVGA)
3598 {
3599 InsertConfigInteger(pCfg, "VMSVGAEnabled", true);
3600#ifdef VBOX_WITH_VMSVGA3D
3601 IFramebuffer *pFramebuffer = NULL;
3602 hrc = i_getDisplay()->QueryFramebuffer(0, &pFramebuffer);
3603 if (SUCCEEDED(hrc) && pFramebuffer)
3604 {
3605 LONG64 winId = 0;
3606 /* @todo deal with multimonitor setup */
3607 Assert(cMonitorCount == 1);
3608 hrc = pFramebuffer->COMGETTER(WinId)(&winId);
3609 InsertConfigInteger(pCfg, "HostWindowId", winId);
3610 pFramebuffer->Release();
3611 }
3612 BOOL f3DEnabled;
3613 hrc = ptrMachine->COMGETTER(Accelerate3DEnabled)(&f3DEnabled); H();
3614 InsertConfigInteger(pCfg, "VMSVGA3dEnabled", f3DEnabled);
3615#else
3616 LogRel(("VMSVGA3d not available in this build!\n"));
3617#endif
3618 }
3619#endif
3620
3621 /* Custom VESA mode list */
3622 unsigned cModes = 0;
3623 for (unsigned iMode = 1; iMode <= 16; ++iMode)
3624 {
3625 char szExtraDataKey[sizeof("CustomVideoModeXX")];
3626 RTStrPrintf(szExtraDataKey, sizeof(szExtraDataKey), "CustomVideoMode%u", iMode);
3627 hrc = ptrMachine->GetExtraData(Bstr(szExtraDataKey).raw(), bstr.asOutParam()); H();
3628 if (bstr.isEmpty())
3629 break;
3630 InsertConfigString(pCfg, szExtraDataKey, bstr);
3631 ++cModes;
3632 }
3633 InsertConfigInteger(pCfg, "CustomVideoModes", cModes);
3634
3635 /* VESA height reduction */
3636 ULONG ulHeightReduction;
3637 IFramebuffer *pFramebuffer = NULL;
3638 hrc = i_getDisplay()->QueryFramebuffer(0, &pFramebuffer);
3639 if (SUCCEEDED(hrc) && pFramebuffer)
3640 {
3641 hrc = pFramebuffer->COMGETTER(HeightReduction)(&ulHeightReduction); H();
3642 pFramebuffer->Release();
3643 pFramebuffer = NULL;
3644 }
3645 else
3646 {
3647 /* If framebuffer is not available, there is no height reduction. */
3648 ulHeightReduction = 0;
3649 }
3650 InsertConfigInteger(pCfg, "HeightReduction", ulHeightReduction);
3651
3652 /*
3653 * BIOS logo
3654 */
3655 BOOL fFadeIn;
3656 hrc = ptrBiosSettings->COMGETTER(LogoFadeIn)(&fFadeIn); H();
3657 InsertConfigInteger(pCfg, "FadeIn", fFadeIn ? 1 : 0);
3658 BOOL fFadeOut;
3659 hrc = ptrBiosSettings->COMGETTER(LogoFadeOut)(&fFadeOut); H();
3660 InsertConfigInteger(pCfg, "FadeOut", fFadeOut ? 1: 0);
3661 ULONG logoDisplayTime;
3662 hrc = ptrBiosSettings->COMGETTER(LogoDisplayTime)(&logoDisplayTime); H();
3663 InsertConfigInteger(pCfg, "LogoTime", logoDisplayTime);
3664 Bstr logoImagePath;
3665 hrc = ptrBiosSettings->COMGETTER(LogoImagePath)(logoImagePath.asOutParam()); H();
3666 InsertConfigString(pCfg, "LogoFile", Utf8Str(!logoImagePath.isEmpty() ? logoImagePath : "") );
3667
3668 /*
3669 * Boot menu
3670 */
3671 BIOSBootMenuMode_T eBootMenuMode;
3672 int iShowBootMenu;
3673 hrc = ptrBiosSettings->COMGETTER(BootMenuMode)(&eBootMenuMode); H();
3674 switch (eBootMenuMode)
3675 {
3676 case BIOSBootMenuMode_Disabled: iShowBootMenu = 0; break;
3677 case BIOSBootMenuMode_MenuOnly: iShowBootMenu = 1; break;
3678 default: iShowBootMenu = 2; break;
3679 }
3680 InsertConfigInteger(pCfg, "ShowBootMenu", iShowBootMenu);
3681
3682 /* Attach the display. */
3683 InsertConfigNode(pInst, "LUN#0", &pLunL0);
3684 InsertConfigString(pLunL0, "Driver", "MainDisplay");
3685 InsertConfigNode(pLunL0, "Config", &pCfg);
3686 Display *pDisplay = mDisplay;
3687 InsertConfigInteger(pCfg, "Object", (uintptr_t)pDisplay);
3688 }
3689 catch (ConfigError &x)
3690 {
3691 // InsertConfig threw something:
3692 return x.m_vrc;
3693 }
3694
3695#undef H
3696
3697 return VINF_SUCCESS;
3698}
3699
3700
3701/**
3702 * Ellipsis to va_list wrapper for calling setVMRuntimeErrorCallback.
3703 */
3704void Console::i_setVMRuntimeErrorCallbackF(uint32_t fFlags, const char *pszErrorId, const char *pszFormat, ...)
3705{
3706 va_list va;
3707 va_start(va, pszFormat);
3708 i_setVMRuntimeErrorCallback(NULL, this, fFlags, pszErrorId, pszFormat, va);
3709 va_end(va);
3710}
3711
3712/* XXX introduce RT format specifier */
3713static uint64_t formatDiskSize(uint64_t u64Size, const char **pszUnit)
3714{
3715 if (u64Size > INT64_C(5000)*_1G)
3716 {
3717 *pszUnit = "TB";
3718 return u64Size / _1T;
3719 }
3720 else if (u64Size > INT64_C(5000)*_1M)
3721 {
3722 *pszUnit = "GB";
3723 return u64Size / _1G;
3724 }
3725 else
3726 {
3727 *pszUnit = "MB";
3728 return u64Size / _1M;
3729 }
3730}
3731
3732int Console::i_configMediumAttachment(const char *pcszDevice,
3733 unsigned uInstance,
3734 StorageBus_T enmBus,
3735 bool fUseHostIOCache,
3736 bool fBuiltinIOCache,
3737 bool fSetupMerge,
3738 unsigned uMergeSource,
3739 unsigned uMergeTarget,
3740 IMediumAttachment *pMediumAtt,
3741 MachineState_T aMachineState,
3742 HRESULT *phrc,
3743 bool fAttachDetach,
3744 bool fForceUnmount,
3745 bool fHotplug,
3746 PUVM pUVM,
3747 DeviceType_T *paLedDevType,
3748 PCFGMNODE *ppLunL0)
3749{
3750 // InsertConfig* throws
3751 try
3752 {
3753 int rc = VINF_SUCCESS;
3754 HRESULT hrc;
3755 Bstr bstr;
3756 PCFGMNODE pCtlInst = NULL;
3757
3758// #define RC_CHECK() AssertMsgReturn(RT_SUCCESS(rc), ("rc=%Rrc\n", rc), rc)
3759#define H() AssertLogRelMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR)
3760
3761 LONG lDev;
3762 hrc = pMediumAtt->COMGETTER(Device)(&lDev); H();
3763 LONG lPort;
3764 hrc = pMediumAtt->COMGETTER(Port)(&lPort); H();
3765 DeviceType_T lType;
3766 hrc = pMediumAtt->COMGETTER(Type)(&lType); H();
3767 BOOL fNonRotational;
3768 hrc = pMediumAtt->COMGETTER(NonRotational)(&fNonRotational); H();
3769 BOOL fDiscard;
3770 hrc = pMediumAtt->COMGETTER(Discard)(&fDiscard); H();
3771
3772 unsigned uLUN;
3773 PCFGMNODE pLunL0 = NULL;
3774 hrc = Console::i_convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN); H();
3775
3776 /* Determine the base path for the device instance. */
3777 if (enmBus != StorageBus_USB)
3778 pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%u/", pcszDevice, uInstance);
3779 else
3780 {
3781 /* If we hotplug a USB device create a new CFGM tree. */
3782 if (!fHotplug)
3783 pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "USB/%s/", pcszDevice);
3784 else
3785 pCtlInst = CFGMR3CreateTree(pUVM);
3786 }
3787 AssertReturn(pCtlInst, VERR_INTERNAL_ERROR);
3788
3789 if (enmBus == StorageBus_USB)
3790 {
3791 PCFGMNODE pCfg = NULL;
3792
3793 /* Create correct instance. */
3794 if (!fHotplug)
3795 {
3796 if (!fAttachDetach)
3797 InsertConfigNode(pCtlInst, Utf8StrFmt("%d", lPort).c_str(), &pCtlInst);
3798 else
3799 pCtlInst = CFGMR3GetChildF(pCtlInst, "%d/", lPort);
3800 }
3801
3802 if (!fAttachDetach)
3803 InsertConfigNode(pCtlInst, "Config", &pCfg);
3804
3805 uInstance = lPort; /* Overwrite uInstance with the correct one. */
3806
3807 if (!fHotplug && !fAttachDetach)
3808 {
3809 char aszUuid[RTUUID_STR_LENGTH + 1];
3810 USBStorageDevice UsbMsd = USBStorageDevice();
3811
3812 memset(aszUuid, 0, sizeof(aszUuid));
3813 rc = RTUuidCreate(&UsbMsd.mUuid);
3814 AssertRCReturn(rc, rc);
3815 rc = RTUuidToStr(&UsbMsd.mUuid, aszUuid, sizeof(aszUuid));
3816 AssertRCReturn(rc, rc);
3817
3818 UsbMsd.iPort = uInstance;
3819
3820 InsertConfigString(pCtlInst, "UUID", aszUuid);
3821 mUSBStorageDevices.push_back(UsbMsd);
3822
3823 /** @todo: No LED after hotplugging. */
3824 /* Attach the status driver */
3825 Assert(cLedUsb >= 8);
3826 i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedUsb], 0, 7,
3827 &mapMediumAttachments, pcszDevice, 0);
3828 paLedDevType = &maStorageDevType[iLedUsb];
3829 }
3830 }
3831
3832 /* First check if the LUN already exists. */
3833 pLunL0 = CFGMR3GetChildF(pCtlInst, "LUN#%u", uLUN);
3834 if (pLunL0)
3835 {
3836 if (fAttachDetach)
3837 {
3838 if (lType != DeviceType_HardDisk)
3839 {
3840 /* Unmount existing media only for floppy and DVD drives. */
3841 PPDMIBASE pBase;
3842 if (enmBus == StorageBus_USB)
3843 rc = PDMR3UsbQueryLun(pUVM, pcszDevice, uInstance, uLUN, &pBase);
3844 else
3845 rc = PDMR3QueryLun(pUVM, pcszDevice, uInstance, uLUN, &pBase);
3846 if (RT_FAILURE(rc))
3847 {
3848 if (rc == VERR_PDM_LUN_NOT_FOUND || rc == VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN)
3849 rc = VINF_SUCCESS;
3850 AssertRC(rc);
3851 }
3852 else
3853 {
3854 PPDMIMOUNT pIMount = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMOUNT);
3855 AssertReturn(pIMount, VERR_INVALID_POINTER);
3856
3857 /* Unmount the media (but do not eject the medium!) */
3858 rc = pIMount->pfnUnmount(pIMount, fForceUnmount, false /*=fEject*/);
3859 if (rc == VERR_PDM_MEDIA_NOT_MOUNTED)
3860 rc = VINF_SUCCESS;
3861 /* for example if the medium is locked */
3862 else if (RT_FAILURE(rc))
3863 return rc;
3864 }
3865 }
3866
3867 if (enmBus == StorageBus_USB)
3868 rc = PDMR3UsbDriverDetach(pUVM, pcszDevice, uInstance, uLUN, NULL, 0,
3869 fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG);
3870 else
3871 rc = PDMR3DeviceDetach(pUVM, pcszDevice, uInstance, uLUN, fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG);
3872 if (rc == VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN)
3873 rc = VINF_SUCCESS;
3874 AssertRCReturn(rc, rc);
3875
3876 CFGMR3RemoveNode(pLunL0);
3877 }
3878 else
3879 AssertFailedReturn(VERR_INTERNAL_ERROR);
3880 }
3881
3882 InsertConfigNode(pCtlInst, Utf8StrFmt("LUN#%u", uLUN).c_str(), &pLunL0);
3883 if (ppLunL0)
3884 *ppLunL0 = pLunL0;
3885
3886 PCFGMNODE pCfg = CFGMR3GetChild(pCtlInst, "Config");
3887 if (pCfg)
3888 {
3889 if (!strcmp(pcszDevice, "piix3ide"))
3890 {
3891 PCFGMNODE pDrive = CFGMR3GetChild(pCfg, g_apszIDEDrives[uLUN]);
3892 if (!pDrive)
3893 InsertConfigNode(pCfg, g_apszIDEDrives[uLUN], &pDrive);
3894 /* Don't use the RemoveConfigValue wrapper above, as we don't
3895 * know if the leaf is present or not. */
3896 CFGMR3RemoveValue(pDrive, "NonRotationalMedium");
3897 InsertConfigInteger(pDrive, "NonRotationalMedium", !!fNonRotational);
3898 }
3899 else if (!strcmp(pcszDevice, "ahci"))
3900 {
3901 Utf8Str strPort = Utf8StrFmt("Port%u", uLUN);
3902 PCFGMNODE pDrive = CFGMR3GetChild(pCfg, strPort.c_str());
3903 if (!pDrive)
3904 InsertConfigNode(pCfg, strPort.c_str(), &pDrive);
3905 /* Don't use the RemoveConfigValue wrapper above, as we don't
3906 * know if the leaf is present or not. */
3907 CFGMR3RemoveValue(pDrive, "NonRotationalMedium");
3908 InsertConfigInteger(pDrive, "NonRotationalMedium", !!fNonRotational);
3909 }
3910 }
3911
3912 Utf8Str devicePath = Utf8StrFmt("%s/%u/LUN#%u", pcszDevice, uInstance, uLUN);
3913 mapMediumAttachments[devicePath] = pMediumAtt;
3914
3915 /* SCSI has a another driver between device and block. */
3916 if (enmBus == StorageBus_SCSI || enmBus == StorageBus_SAS || enmBus == StorageBus_USB)
3917 {
3918 InsertConfigString(pLunL0, "Driver", "SCSI");
3919 PCFGMNODE pL1Cfg = NULL;
3920 InsertConfigNode(pLunL0, "Config", &pL1Cfg);
3921 InsertConfigInteger(pL1Cfg, "NonRotationalMedium", !!fNonRotational);
3922
3923 InsertConfigNode(pLunL0, "AttachedDriver", &pLunL0);
3924 }
3925
3926 ComPtr<IMedium> pMedium;
3927 hrc = pMediumAtt->COMGETTER(Medium)(pMedium.asOutParam()); H();
3928
3929 /*
3930 * 1. Only check this for hard disk images.
3931 * 2. Only check during VM creation and not later, especially not during
3932 * taking an online snapshot!
3933 */
3934 if ( lType == DeviceType_HardDisk
3935 && ( aMachineState == MachineState_Starting
3936 || aMachineState == MachineState_Restoring))
3937 {
3938 /*
3939 * Some sanity checks.
3940 */
3941 ComPtr<IMediumFormat> pMediumFormat;
3942 hrc = pMedium->COMGETTER(MediumFormat)(pMediumFormat.asOutParam()); H();
3943 ULONG uCaps = 0;
3944 com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
3945 hrc = pMediumFormat->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap)); H();
3946
3947 for (ULONG j = 0; j < mediumFormatCap.size(); j++)
3948 uCaps |= mediumFormatCap[j];
3949
3950 if (uCaps & MediumFormatCapabilities_File)
3951 {
3952 Bstr strFile;
3953 hrc = pMedium->COMGETTER(Location)(strFile.asOutParam()); H();
3954 Utf8Str utfFile = Utf8Str(strFile);
3955 Bstr strSnap;
3956 ComPtr<IMachine> pMachine = i_machine();
3957 hrc = pMachine->COMGETTER(SnapshotFolder)(strSnap.asOutParam()); H();
3958 Utf8Str utfSnap = Utf8Str(strSnap);
3959 RTFSTYPE enmFsTypeFile = RTFSTYPE_UNKNOWN;
3960 RTFSTYPE enmFsTypeSnap = RTFSTYPE_UNKNOWN;
3961 int rc2 = RTFsQueryType(utfFile.c_str(), &enmFsTypeFile);
3962 AssertMsgRCReturn(rc2, ("Querying the file type of '%s' failed!\n", utfFile.c_str()), rc2);
3963 /* Ignore the error code. On error, the file system type is still 'unknown' so
3964 * none of the following paths are taken. This can happen for new VMs which
3965 * still don't have a snapshot folder. */
3966 (void)RTFsQueryType(utfSnap.c_str(), &enmFsTypeSnap);
3967 if (!mfSnapshotFolderDiskTypeShown)
3968 {
3969 LogRel(("File system of '%s' (snapshots) is %s\n",
3970 utfSnap.c_str(), RTFsTypeName(enmFsTypeSnap)));
3971 mfSnapshotFolderDiskTypeShown = true;
3972 }
3973 LogRel(("File system of '%s' is %s\n", utfFile.c_str(), RTFsTypeName(enmFsTypeFile)));
3974 LONG64 i64Size;
3975 hrc = pMedium->COMGETTER(LogicalSize)(&i64Size); H();
3976#ifdef RT_OS_WINDOWS
3977 if ( enmFsTypeFile == RTFSTYPE_FAT
3978 && i64Size >= _4G)
3979 {
3980 const char *pszUnit;
3981 uint64_t u64Print = formatDiskSize((uint64_t)i64Size, &pszUnit);
3982 i_setVMRuntimeErrorCallbackF(0, "FatPartitionDetected",
3983 N_("The medium '%ls' has a logical size of %RU64%s "
3984 "but the file system the medium is located on seems "
3985 "to be FAT(32) which cannot handle files bigger than 4GB.\n"
3986 "We strongly recommend to put all your virtual disk images and "
3987 "the snapshot folder onto an NTFS partition"),
3988 strFile.raw(), u64Print, pszUnit);
3989 }
3990#else /* !RT_OS_WINDOWS */
3991 if ( enmFsTypeFile == RTFSTYPE_FAT
3992 || enmFsTypeFile == RTFSTYPE_EXT
3993 || enmFsTypeFile == RTFSTYPE_EXT2
3994 || enmFsTypeFile == RTFSTYPE_EXT3
3995 || enmFsTypeFile == RTFSTYPE_EXT4)
3996 {
3997 RTFILE file;
3998 rc = RTFileOpen(&file, utfFile.c_str(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
3999 if (RT_SUCCESS(rc))
4000 {
4001 RTFOFF maxSize;
4002 /* Careful: This function will work only on selected local file systems! */
4003 rc = RTFileGetMaxSizeEx(file, &maxSize);
4004 RTFileClose(file);
4005 if ( RT_SUCCESS(rc)
4006 && maxSize > 0
4007 && i64Size > (LONG64)maxSize)
4008 {
4009 const char *pszUnitSiz;
4010 const char *pszUnitMax;
4011 uint64_t u64PrintSiz = formatDiskSize((LONG64)i64Size, &pszUnitSiz);
4012 uint64_t u64PrintMax = formatDiskSize(maxSize, &pszUnitMax);
4013 i_setVMRuntimeErrorCallbackF(0, "FatPartitionDetected", /* <= not exact but ... */
4014 N_("The medium '%ls' has a logical size of %RU64%s "
4015 "but the file system the medium is located on can "
4016 "only handle files up to %RU64%s in theory.\n"
4017 "We strongly recommend to put all your virtual disk "
4018 "images and the snapshot folder onto a proper "
4019 "file system (e.g. ext3) with a sufficient size"),
4020 strFile.raw(), u64PrintSiz, pszUnitSiz, u64PrintMax, pszUnitMax);
4021 }
4022 }
4023 }
4024#endif /* !RT_OS_WINDOWS */
4025
4026 /*
4027 * Snapshot folder:
4028 * Here we test only for a FAT partition as we had to create a dummy file otherwise
4029 */
4030 if ( enmFsTypeSnap == RTFSTYPE_FAT
4031 && i64Size >= _4G
4032 && !mfSnapshotFolderSizeWarningShown)
4033 {
4034 const char *pszUnit;
4035 uint64_t u64Print = formatDiskSize(i64Size, &pszUnit);
4036 i_setVMRuntimeErrorCallbackF(0, "FatPartitionDetected",
4037#ifdef RT_OS_WINDOWS
4038 N_("The snapshot folder of this VM '%ls' seems to be located on "
4039 "a FAT(32) file system. The logical size of the medium '%ls' "
4040 "(%RU64%s) is bigger than the maximum file size this file "
4041 "system can handle (4GB).\n"
4042 "We strongly recommend to put all your virtual disk images and "
4043 "the snapshot folder onto an NTFS partition"),
4044#else
4045 N_("The snapshot folder of this VM '%ls' seems to be located on "
4046 "a FAT(32) file system. The logical size of the medium '%ls' "
4047 "(%RU64%s) is bigger than the maximum file size this file "
4048 "system can handle (4GB).\n"
4049 "We strongly recommend to put all your virtual disk images and "
4050 "the snapshot folder onto a proper file system (e.g. ext3)"),
4051#endif
4052 strSnap.raw(), strFile.raw(), u64Print, pszUnit);
4053 /* Show this particular warning only once */
4054 mfSnapshotFolderSizeWarningShown = true;
4055 }
4056
4057#ifdef RT_OS_LINUX
4058 /*
4059 * Ext4 bug: Check if the host I/O cache is disabled and the disk image is located
4060 * on an ext4 partition. Later we have to check the Linux kernel version!
4061 * This bug apparently applies to the XFS file system as well.
4062 * Linux 2.6.36 is known to be fixed (tested with 2.6.36-rc4).
4063 */
4064
4065 char szOsRelease[128];
4066 rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szOsRelease, sizeof(szOsRelease));
4067 bool fKernelHasODirectBug = RT_FAILURE(rc)
4068 || (RTStrVersionCompare(szOsRelease, "2.6.36-rc4") < 0);
4069
4070 if ( (uCaps & MediumFormatCapabilities_Asynchronous)
4071 && !fUseHostIOCache
4072 && fKernelHasODirectBug)
4073 {
4074 if ( enmFsTypeFile == RTFSTYPE_EXT4
4075 || enmFsTypeFile == RTFSTYPE_XFS)
4076 {
4077 i_setVMRuntimeErrorCallbackF(0, "Ext4PartitionDetected",
4078 N_("The host I/O cache for at least one controller is disabled "
4079 "and the medium '%ls' for this VM "
4080 "is located on an %s partition. There is a known Linux "
4081 "kernel bug which can lead to the corruption of the virtual "
4082 "disk image under these conditions.\n"
4083 "Either enable the host I/O cache permanently in the VM "
4084 "settings or put the disk image and the snapshot folder "
4085 "onto a different file system.\n"
4086 "The host I/O cache will now be enabled for this medium"),
4087 strFile.raw(), enmFsTypeFile == RTFSTYPE_EXT4 ? "ext4" : "xfs");
4088 fUseHostIOCache = true;
4089 }
4090 else if ( ( enmFsTypeSnap == RTFSTYPE_EXT4
4091 || enmFsTypeSnap == RTFSTYPE_XFS)
4092 && !mfSnapshotFolderExt4WarningShown)
4093 {
4094 i_setVMRuntimeErrorCallbackF(0, "Ext4PartitionDetected",
4095 N_("The host I/O cache for at least one controller is disabled "
4096 "and the snapshot folder for this VM "
4097 "is located on an %s partition. There is a known Linux "
4098 "kernel bug which can lead to the corruption of the virtual "
4099 "disk image under these conditions.\n"
4100 "Either enable the host I/O cache permanently in the VM "
4101 "settings or put the disk image and the snapshot folder "
4102 "onto a different file system.\n"
4103 "The host I/O cache will now be enabled for this medium"),
4104 enmFsTypeSnap == RTFSTYPE_EXT4 ? "ext4" : "xfs");
4105 fUseHostIOCache = true;
4106 mfSnapshotFolderExt4WarningShown = true;
4107 }
4108 }
4109#endif
4110 }
4111 }
4112
4113 if (pMedium)
4114 {
4115 BOOL fHostDrive;
4116 hrc = pMedium->COMGETTER(HostDrive)(&fHostDrive); H();
4117 if ( ( lType == DeviceType_DVD
4118 || lType == DeviceType_Floppy)
4119 && !fHostDrive)
4120 {
4121 /*
4122 * Informative logging.
4123 */
4124 Bstr strFile;
4125 hrc = pMedium->COMGETTER(Location)(strFile.asOutParam()); H();
4126 Utf8Str utfFile = Utf8Str(strFile);
4127 RTFSTYPE enmFsTypeFile = RTFSTYPE_UNKNOWN;
4128 (void)RTFsQueryType(utfFile.c_str(), &enmFsTypeFile);
4129 LogRel(("File system of '%s' (%s) is %s\n",
4130 utfFile.c_str(), lType == DeviceType_DVD ? "DVD" : "Floppy",
4131 RTFsTypeName(enmFsTypeFile)));
4132 }
4133 }
4134
4135 BOOL fPassthrough;
4136 hrc = pMediumAtt->COMGETTER(Passthrough)(&fPassthrough); H();
4137
4138 ComObjPtr<IBandwidthGroup> pBwGroup;
4139 Bstr strBwGroup;
4140 hrc = pMediumAtt->COMGETTER(BandwidthGroup)(pBwGroup.asOutParam()); H();
4141
4142 if (!pBwGroup.isNull())
4143 {
4144 hrc = pBwGroup->COMGETTER(Name)(strBwGroup.asOutParam()); H();
4145 }
4146
4147 rc = i_configMedium(pLunL0,
4148 !!fPassthrough,
4149 lType,
4150 fUseHostIOCache,
4151 fBuiltinIOCache,
4152 fSetupMerge,
4153 uMergeSource,
4154 uMergeTarget,
4155 strBwGroup.isEmpty() ? NULL : Utf8Str(strBwGroup).c_str(),
4156 !!fDiscard,
4157 pMedium,
4158 aMachineState,
4159 phrc);
4160 if (RT_FAILURE(rc))
4161 return rc;
4162
4163 if (fAttachDetach)
4164 {
4165 /* Attach the new driver. */
4166 if (enmBus == StorageBus_USB)
4167 {
4168 if (fHotplug)
4169 {
4170 USBStorageDevice UsbMsd = USBStorageDevice();
4171 RTUuidCreate(&UsbMsd.mUuid);
4172 UsbMsd.iPort = uInstance;
4173 rc = PDMR3UsbCreateEmulatedDevice(pUVM, pcszDevice, pCtlInst, &UsbMsd.mUuid, NULL);
4174 if (RT_SUCCESS(rc))
4175 mUSBStorageDevices.push_back(UsbMsd);
4176 }
4177 else
4178 rc = PDMR3UsbDriverAttach(pUVM, pcszDevice, uInstance, uLUN,
4179 fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG, NULL /*ppBase*/);
4180 }
4181 else
4182 rc = PDMR3DeviceAttach(pUVM, pcszDevice, uInstance, uLUN,
4183 fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG, NULL /*ppBase*/);
4184 AssertRCReturn(rc, rc);
4185
4186 /*
4187 * Make the secret key helper interface known to the VD driver if it is attached,
4188 * so we can get notified about missing keys.
4189 */
4190 PPDMIBASE pIBase = NULL;
4191 rc = PDMR3QueryDriverOnLun(pUVM, pcszDevice, uInstance, uLUN, "VD", &pIBase);
4192 if (RT_SUCCESS(rc) && pIBase)
4193 {
4194 PPDMIMEDIA pIMedium = (PPDMIMEDIA)pIBase->pfnQueryInterface(pIBase, PDMIMEDIA_IID);
4195 if (pIMedium)
4196 {
4197 rc = pIMedium->pfnSetSecKeyIf(pIMedium, mpIfSecKey, mpIfSecKeyHlp);
4198 Assert(RT_SUCCESS(rc) || rc == VERR_NOT_SUPPORTED);
4199 }
4200 }
4201
4202 /* There is no need to handle removable medium mounting, as we
4203 * unconditionally replace everthing including the block driver level.
4204 * This means the new medium will be picked up automatically. */
4205 }
4206
4207 if (paLedDevType)
4208 paLedDevType[uLUN] = lType;
4209
4210 /* Dump the changed LUN if possible, dump the complete device otherwise */
4211 if ( aMachineState != MachineState_Starting
4212 && aMachineState != MachineState_Restoring)
4213 CFGMR3Dump(pLunL0 ? pLunL0 : pCtlInst);
4214 }
4215 catch (ConfigError &x)
4216 {
4217 // InsertConfig threw something:
4218 return x.m_vrc;
4219 }
4220
4221#undef H
4222
4223 return VINF_SUCCESS;
4224}
4225
4226int Console::i_configMedium(PCFGMNODE pLunL0,
4227 bool fPassthrough,
4228 DeviceType_T enmType,
4229 bool fUseHostIOCache,
4230 bool fBuiltinIOCache,
4231 bool fSetupMerge,
4232 unsigned uMergeSource,
4233 unsigned uMergeTarget,
4234 const char *pcszBwGroup,
4235 bool fDiscard,
4236 IMedium *pMedium,
4237 MachineState_T aMachineState,
4238 HRESULT *phrc)
4239{
4240 // InsertConfig* throws
4241 try
4242 {
4243 int rc = VINF_SUCCESS;
4244 HRESULT hrc;
4245 Bstr bstr;
4246 PCFGMNODE pLunL1 = NULL;
4247 PCFGMNODE pCfg = NULL;
4248
4249#define H() \
4250 AssertMsgReturnStmt(SUCCEEDED(hrc), ("hrc=%Rhrc\n", hrc), if (phrc) *phrc = hrc, Global::vboxStatusCodeFromCOM(hrc))
4251
4252
4253 BOOL fHostDrive = FALSE;
4254 MediumType_T mediumType = MediumType_Normal;
4255 if (pMedium)
4256 {
4257 hrc = pMedium->COMGETTER(HostDrive)(&fHostDrive); H();
4258 hrc = pMedium->COMGETTER(Type)(&mediumType); H();
4259 }
4260
4261 if (fHostDrive)
4262 {
4263 Assert(pMedium);
4264 if (enmType == DeviceType_DVD)
4265 {
4266 InsertConfigString(pLunL0, "Driver", "HostDVD");
4267 InsertConfigNode(pLunL0, "Config", &pCfg);
4268
4269 hrc = pMedium->COMGETTER(Location)(bstr.asOutParam()); H();
4270 InsertConfigString(pCfg, "Path", bstr);
4271
4272 InsertConfigInteger(pCfg, "Passthrough", fPassthrough);
4273 }
4274 else if (enmType == DeviceType_Floppy)
4275 {
4276 InsertConfigString(pLunL0, "Driver", "HostFloppy");
4277 InsertConfigNode(pLunL0, "Config", &pCfg);
4278
4279 hrc = pMedium->COMGETTER(Location)(bstr.asOutParam()); H();
4280 InsertConfigString(pCfg, "Path", bstr);
4281 }
4282 }
4283 else
4284 {
4285#if 0 /* Enable for I/O debugging */
4286 InsertConfigNode(pLunL0, "AttachedDriver", &pLunL0);
4287 InsertConfigString(pLunL0, "Driver", "DiskIntegrity");
4288 InsertConfigNode(pLunL0, "Config", &pCfg);
4289 InsertConfigInteger(pCfg, "CheckConsistency", 0);
4290 InsertConfigInteger(pCfg, "CheckDoubleCompletions", 1);
4291#endif
4292
4293 InsertConfigString(pLunL0, "Driver", "VD");
4294 InsertConfigNode(pLunL0, "Config", &pCfg);
4295 switch (enmType)
4296 {
4297 case DeviceType_DVD:
4298 InsertConfigString(pCfg, "Type", "DVD");
4299 InsertConfigInteger(pCfg, "Mountable", 1);
4300 break;
4301 case DeviceType_Floppy:
4302 InsertConfigString(pCfg, "Type", "Floppy 1.44");
4303 InsertConfigInteger(pCfg, "Mountable", 1);
4304 break;
4305 case DeviceType_HardDisk:
4306 default:
4307 InsertConfigString(pCfg, "Type", "HardDisk");
4308 InsertConfigInteger(pCfg, "Mountable", 0);
4309 }
4310
4311 if ( pMedium
4312 && ( enmType == DeviceType_DVD
4313 || enmType == DeviceType_Floppy)
4314 )
4315 {
4316 // if this medium represents an ISO image and this image is inaccessible,
4317 // the ignore it instead of causing a failure; this can happen when we
4318 // restore a VM state and the ISO has disappeared, e.g. because the Guest
4319 // Additions were mounted and the user upgraded VirtualBox. Previously
4320 // we failed on startup, but that's not good because the only way out then
4321 // would be to discard the VM state...
4322 MediumState_T mediumState;
4323 hrc = pMedium->RefreshState(&mediumState); H();
4324 if (mediumState == MediumState_Inaccessible)
4325 {
4326 Bstr loc;
4327 hrc = pMedium->COMGETTER(Location)(loc.asOutParam()); H();
4328 i_setVMRuntimeErrorCallbackF(0, "DvdOrFloppyImageInaccessible",
4329 "The image file '%ls' is inaccessible and is being ignored. "
4330 "Please select a different image file for the virtual %s drive.",
4331 loc.raw(),
4332 enmType == DeviceType_DVD ? "DVD" : "floppy");
4333 pMedium = NULL;
4334 }
4335 }
4336
4337 if (pMedium)
4338 {
4339 /* Start with length of parent chain, as the list is reversed */
4340 unsigned uImage = 0;
4341 IMedium *pTmp = pMedium;
4342 while (pTmp)
4343 {
4344 uImage++;
4345 hrc = pTmp->COMGETTER(Parent)(&pTmp); H();
4346 }
4347 /* Index of last image */
4348 uImage--;
4349
4350# ifdef VBOX_WITH_EXTPACK
4351 static const Utf8Str strExtPackPuel("Oracle VM VirtualBox Extension Pack");
4352 static const char *s_pszVDPlugin = "VDPluginCrypt";
4353 if (mptrExtPackManager->i_isExtPackUsable(strExtPackPuel.c_str()))
4354 {
4355 /* Configure loading the VDPlugin. */
4356 PCFGMNODE pCfgPlugins = NULL;
4357 PCFGMNODE pCfgPlugin = NULL;
4358 Utf8Str strPlugin;
4359 hrc = mptrExtPackManager->i_getLibraryPathForExtPack(s_pszVDPlugin, &strExtPackPuel, &strPlugin);
4360 // Don't fail, this is optional!
4361 if (SUCCEEDED(hrc))
4362 {
4363 InsertConfigNode(pCfg, "Plugins", &pCfgPlugins);
4364 InsertConfigNode(pCfgPlugins, s_pszVDPlugin, &pCfgPlugin);
4365 InsertConfigString(pCfgPlugin, "Path", strPlugin.c_str());
4366 }
4367 }
4368# endif
4369
4370 hrc = pMedium->COMGETTER(Location)(bstr.asOutParam()); H();
4371 InsertConfigString(pCfg, "Path", bstr);
4372
4373 hrc = pMedium->COMGETTER(Format)(bstr.asOutParam()); H();
4374 InsertConfigString(pCfg, "Format", bstr);
4375
4376 if (mediumType == MediumType_Readonly)
4377 InsertConfigInteger(pCfg, "ReadOnly", 1);
4378 else if (enmType == DeviceType_Floppy)
4379 InsertConfigInteger(pCfg, "MaybeReadOnly", 1);
4380
4381 /* Start without exclusive write access to the images. */
4382 /** @todo Live Migration: I don't quite like this, we risk screwing up when
4383 * we're resuming the VM if some 3rd dude have any of the VDIs open
4384 * with write sharing denied. However, if the two VMs are sharing a
4385 * image it really is necessary....
4386 *
4387 * So, on the "lock-media" command, the target teleporter should also
4388 * make DrvVD undo TempReadOnly. It gets interesting if we fail after
4389 * that. Grumble. */
4390 if ( enmType == DeviceType_HardDisk
4391 && ( aMachineState == MachineState_TeleportingIn
4392 || aMachineState == MachineState_FaultTolerantSyncing))
4393 InsertConfigInteger(pCfg, "TempReadOnly", 1);
4394
4395 /* Flag for opening the medium for sharing between VMs. This
4396 * is done at the moment only for the first (and only) medium
4397 * in the chain, as shared media can have no diffs. */
4398 if (mediumType == MediumType_Shareable)
4399 InsertConfigInteger(pCfg, "Shareable", 1);
4400
4401 if (!fUseHostIOCache)
4402 {
4403 InsertConfigInteger(pCfg, "UseNewIo", 1);
4404 /*
4405 * Activate the builtin I/O cache for harddisks only.
4406 * It caches writes only which doesn't make sense for DVD drives
4407 * and just increases the overhead.
4408 */
4409 if ( fBuiltinIOCache
4410 && (enmType == DeviceType_HardDisk))
4411 InsertConfigInteger(pCfg, "BlockCache", 1);
4412 }
4413
4414 if (fSetupMerge)
4415 {
4416 InsertConfigInteger(pCfg, "SetupMerge", 1);
4417 if (uImage == uMergeSource)
4418 InsertConfigInteger(pCfg, "MergeSource", 1);
4419 else if (uImage == uMergeTarget)
4420 InsertConfigInteger(pCfg, "MergeTarget", 1);
4421 }
4422
4423 if (pcszBwGroup)
4424 InsertConfigString(pCfg, "BwGroup", pcszBwGroup);
4425
4426 if (fDiscard)
4427 InsertConfigInteger(pCfg, "Discard", 1);
4428
4429 /* Pass all custom parameters. */
4430 bool fHostIP = true;
4431 bool fEncrypted = false;
4432 hrc = i_configMediumProperties(pCfg, pMedium, &fHostIP, &fEncrypted); H();
4433
4434 /* Create an inverted list of parents. */
4435 uImage--;
4436 IMedium *pParentMedium = pMedium;
4437 for (PCFGMNODE pParent = pCfg;; uImage--)
4438 {
4439 hrc = pParentMedium->COMGETTER(Parent)(&pMedium); H();
4440 if (!pMedium)
4441 break;
4442
4443 PCFGMNODE pCur;
4444 InsertConfigNode(pParent, "Parent", &pCur);
4445 hrc = pMedium->COMGETTER(Location)(bstr.asOutParam()); H();
4446 InsertConfigString(pCur, "Path", bstr);
4447
4448 hrc = pMedium->COMGETTER(Format)(bstr.asOutParam()); H();
4449 InsertConfigString(pCur, "Format", bstr);
4450
4451 if (fSetupMerge)
4452 {
4453 if (uImage == uMergeSource)
4454 InsertConfigInteger(pCur, "MergeSource", 1);
4455 else if (uImage == uMergeTarget)
4456 InsertConfigInteger(pCur, "MergeTarget", 1);
4457 }
4458
4459 /* Configure medium properties. */
4460 hrc = i_configMediumProperties(pCur, pMedium, &fHostIP, &fEncrypted); H();
4461
4462 /* next */
4463 pParent = pCur;
4464 pParentMedium = pMedium;
4465 }
4466
4467 /* Custom code: put marker to not use host IP stack to driver
4468 * configuration node. Simplifies life of DrvVD a bit. */
4469 if (!fHostIP)
4470 InsertConfigInteger(pCfg, "HostIPStack", 0);
4471
4472 if (fEncrypted)
4473 m_cDisksEncrypted++;
4474 }
4475 else
4476 {
4477 /* Set empty drive flag for DVD or floppy without media. */
4478 if ( enmType == DeviceType_DVD
4479 || enmType == DeviceType_Floppy)
4480 InsertConfigInteger(pCfg, "EmptyDrive", 1);
4481 }
4482 }
4483#undef H
4484 }
4485 catch (ConfigError &x)
4486 {
4487 // InsertConfig threw something:
4488 return x.m_vrc;
4489 }
4490
4491 return VINF_SUCCESS;
4492}
4493
4494/**
4495 * Adds the medium properties to the CFGM tree.
4496 *
4497 * @returns VBox status code.
4498 * @param pCur The current CFGM node.
4499 * @param pMedium The medium object to configure.
4500 * @param pfHostIP Where to return the value of the \"HostIPStack\" property if found.
4501 * @param pfEncrypted Where to return whether the medium is encrypted.
4502 */
4503int Console::i_configMediumProperties(PCFGMNODE pCur, IMedium *pMedium, bool *pfHostIP, bool *pfEncrypted)
4504{
4505 /* Pass all custom parameters. */
4506 SafeArray<BSTR> aNames;
4507 SafeArray<BSTR> aValues;
4508 HRESULT hrc = pMedium->GetProperties(NULL, ComSafeArrayAsOutParam(aNames),
4509 ComSafeArrayAsOutParam(aValues));
4510
4511 if ( SUCCEEDED(hrc)
4512 && aNames.size() != 0)
4513 {
4514 PCFGMNODE pVDC;
4515 InsertConfigNode(pCur, "VDConfig", &pVDC);
4516 for (size_t ii = 0; ii < aNames.size(); ++ii)
4517 {
4518 if (aValues[ii] && *aValues[ii])
4519 {
4520 Utf8Str name = aNames[ii];
4521 Utf8Str value = aValues[ii];
4522 size_t offSlash = name.find("/", 0);
4523 if ( offSlash != name.npos
4524 && !name.startsWith("Special/"))
4525 {
4526 com::Utf8Str strFilter;
4527 com::Utf8Str strKey;
4528
4529 hrc = strFilter.assignEx(name, 0, offSlash);
4530 if (FAILED(hrc))
4531 break;
4532
4533 hrc = strKey.assignEx(name, offSlash + 1, name.length() - offSlash - 1); /* Skip slash */
4534 if (FAILED(hrc))
4535 break;
4536
4537 PCFGMNODE pCfgFilterConfig = CFGMR3GetChild(pVDC, strFilter.c_str());
4538 if (!pCfgFilterConfig)
4539 InsertConfigNode(pVDC, strFilter.c_str(), &pCfgFilterConfig);
4540
4541 InsertConfigString(pCfgFilterConfig, strKey.c_str(), value);
4542 }
4543 else
4544 {
4545 InsertConfigString(pVDC, name.c_str(), value);
4546 if ( name.compare("HostIPStack") == 0
4547 && value.compare("0") == 0)
4548 *pfHostIP = false;
4549 }
4550
4551 if ( name.compare("CRYPT/KeyId") == 0
4552 && pfEncrypted)
4553 *pfEncrypted = true;
4554 }
4555 }
4556 }
4557
4558 return hrc;
4559}
4560
4561
4562#ifdef RT_OS_WINDOWS
4563DECLINLINE(bool) IsNdis6(void)
4564{
4565 LogFlowFunc(("entry\n"));
4566 HANDLE hFile = CreateFile(L"\\\\.\\VBoxNetLwf",
4567 0,
4568 FILE_SHARE_READ | FILE_SHARE_WRITE,
4569 NULL,
4570 OPEN_EXISTING,
4571 0,
4572 NULL);
4573 bool fNdis6 = hFile != INVALID_HANDLE_VALUE;
4574 if (fNdis6)
4575 CloseHandle(hFile);
4576 else
4577 LogFunc(("CreateFile failed with 0x%x\n", GetLastError()));
4578 LogFlowFunc(("return %s\n", fNdis6 ? "true" : "false"));
4579 return fNdis6;
4580}
4581#endif /* RT_OS_WINDOWS */
4582
4583
4584/**
4585 * Construct the Network configuration tree
4586 *
4587 * @returns VBox status code.
4588 *
4589 * @param pszDevice The PDM device name.
4590 * @param uInstance The PDM device instance.
4591 * @param uLun The PDM LUN number of the drive.
4592 * @param aNetworkAdapter The network adapter whose attachment needs to be changed
4593 * @param pCfg Configuration node for the device
4594 * @param pLunL0 To store the pointer to the LUN#0.
4595 * @param pInst The instance CFGM node
4596 * @param fAttachDetach To determine if the network attachment should
4597 * be attached/detached after/before
4598 * configuration.
4599 * @param fIgnoreConnectFailure
4600 * True if connection failures should be ignored
4601 * (makes only sense for bridged/host-only networks).
4602 *
4603 * @note Locks this object for writing.
4604 * @thread EMT
4605 */
4606int Console::i_configNetwork(const char *pszDevice,
4607 unsigned uInstance,
4608 unsigned uLun,
4609 INetworkAdapter *aNetworkAdapter,
4610 PCFGMNODE pCfg,
4611 PCFGMNODE pLunL0,
4612 PCFGMNODE pInst,
4613 bool fAttachDetach,
4614 bool fIgnoreConnectFailure)
4615{
4616 AutoCaller autoCaller(this);
4617 AssertComRCReturn(autoCaller.rc(), VERR_ACCESS_DENIED);
4618
4619 // InsertConfig* throws
4620 try
4621 {
4622 int rc = VINF_SUCCESS;
4623 HRESULT hrc;
4624 Bstr bstr;
4625
4626#define H() AssertLogRelMsgReturn(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR)
4627
4628 /*
4629 * Locking the object before doing VMR3* calls is quite safe here, since
4630 * we're on EMT. Write lock is necessary because we indirectly modify the
4631 * meAttachmentType member.
4632 */
4633 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4634
4635 ComPtr<IMachine> pMachine = i_machine();
4636
4637 ComPtr<IVirtualBox> virtualBox;
4638 hrc = pMachine->COMGETTER(Parent)(virtualBox.asOutParam()); H();
4639
4640 ComPtr<IHost> host;
4641 hrc = virtualBox->COMGETTER(Host)(host.asOutParam()); H();
4642
4643 BOOL fSniffer;
4644 hrc = aNetworkAdapter->COMGETTER(TraceEnabled)(&fSniffer); H();
4645
4646 NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
4647 hrc = aNetworkAdapter->COMGETTER(PromiscModePolicy)(&enmPromiscModePolicy); H();
4648 const char *pszPromiscuousGuestPolicy;
4649 switch (enmPromiscModePolicy)
4650 {
4651 case NetworkAdapterPromiscModePolicy_Deny: pszPromiscuousGuestPolicy = "deny"; break;
4652 case NetworkAdapterPromiscModePolicy_AllowNetwork: pszPromiscuousGuestPolicy = "allow-network"; break;
4653 case NetworkAdapterPromiscModePolicy_AllowAll: pszPromiscuousGuestPolicy = "allow-all"; break;
4654 default: AssertFailedReturn(VERR_INTERNAL_ERROR_4);
4655 }
4656
4657 if (fAttachDetach)
4658 {
4659 rc = PDMR3DeviceDetach(mpUVM, pszDevice, uInstance, uLun, 0 /*fFlags*/);
4660 if (rc == VINF_PDM_NO_DRIVER_ATTACHED_TO_LUN)
4661 rc = VINF_SUCCESS;
4662 AssertLogRelRCReturn(rc, rc);
4663
4664 /* nuke anything which might have been left behind. */
4665 CFGMR3RemoveNode(CFGMR3GetChildF(pInst, "LUN#%u", uLun));
4666 }
4667
4668#ifdef VBOX_WITH_NETSHAPER
4669 ComObjPtr<IBandwidthGroup> pBwGroup;
4670 Bstr strBwGroup;
4671 hrc = aNetworkAdapter->COMGETTER(BandwidthGroup)(pBwGroup.asOutParam()); H();
4672
4673 if (!pBwGroup.isNull())
4674 {
4675 hrc = pBwGroup->COMGETTER(Name)(strBwGroup.asOutParam()); H();
4676 }
4677#endif /* VBOX_WITH_NETSHAPER */
4678
4679 Utf8Str strNetDriver;
4680
4681
4682 InsertConfigNode(pInst, "LUN#0", &pLunL0);
4683
4684#ifdef VBOX_WITH_NETSHAPER
4685 if (!strBwGroup.isEmpty())
4686 {
4687 InsertConfigString(pLunL0, "Driver", "NetShaper");
4688 InsertConfigNode(pLunL0, "Config", &pCfg);
4689 InsertConfigString(pCfg, "BwGroup", strBwGroup);
4690 InsertConfigNode(pLunL0, "AttachedDriver", &pLunL0);
4691 }
4692#endif /* VBOX_WITH_NETSHAPER */
4693
4694 if (fSniffer)
4695 {
4696 InsertConfigString(pLunL0, "Driver", "NetSniffer");
4697 InsertConfigNode(pLunL0, "Config", &pCfg);
4698 hrc = aNetworkAdapter->COMGETTER(TraceFile)(bstr.asOutParam()); H();
4699 if (!bstr.isEmpty()) /* check convention for indicating default file. */
4700 InsertConfigString(pCfg, "File", bstr);
4701 InsertConfigNode(pLunL0, "AttachedDriver", &pLunL0);
4702 }
4703
4704
4705 Bstr networkName, trunkName, trunkType;
4706 NetworkAttachmentType_T eAttachmentType;
4707 hrc = aNetworkAdapter->COMGETTER(AttachmentType)(&eAttachmentType); H();
4708 switch (eAttachmentType)
4709 {
4710 case NetworkAttachmentType_Null:
4711 break;
4712
4713 case NetworkAttachmentType_NAT:
4714 {
4715 ComPtr<INATEngine> natEngine;
4716 hrc = aNetworkAdapter->COMGETTER(NATEngine)(natEngine.asOutParam()); H();
4717 InsertConfigString(pLunL0, "Driver", "NAT");
4718 InsertConfigNode(pLunL0, "Config", &pCfg);
4719
4720 /* Configure TFTP prefix and boot filename. */
4721 hrc = virtualBox->COMGETTER(HomeFolder)(bstr.asOutParam()); H();
4722 if (!bstr.isEmpty())
4723 InsertConfigString(pCfg, "TFTPPrefix", Utf8StrFmt("%ls%c%s", bstr.raw(), RTPATH_DELIMITER, "TFTP"));
4724 hrc = pMachine->COMGETTER(Name)(bstr.asOutParam()); H();
4725 InsertConfigString(pCfg, "BootFile", Utf8StrFmt("%ls.pxe", bstr.raw()));
4726
4727 hrc = natEngine->COMGETTER(Network)(bstr.asOutParam()); H();
4728 if (!bstr.isEmpty())
4729 InsertConfigString(pCfg, "Network", bstr);
4730 else
4731 {
4732 ULONG uSlot;
4733 hrc = aNetworkAdapter->COMGETTER(Slot)(&uSlot); H();
4734 InsertConfigString(pCfg, "Network", Utf8StrFmt("10.0.%d.0/24", uSlot+2));
4735 }
4736 hrc = natEngine->COMGETTER(HostIP)(bstr.asOutParam()); H();
4737 if (!bstr.isEmpty())
4738 InsertConfigString(pCfg, "BindIP", bstr);
4739 ULONG mtu = 0;
4740 ULONG sockSnd = 0;
4741 ULONG sockRcv = 0;
4742 ULONG tcpSnd = 0;
4743 ULONG tcpRcv = 0;
4744 hrc = natEngine->GetNetworkSettings(&mtu, &sockSnd, &sockRcv, &tcpSnd, &tcpRcv); H();
4745 if (mtu)
4746 InsertConfigInteger(pCfg, "SlirpMTU", mtu);
4747 if (sockRcv)
4748 InsertConfigInteger(pCfg, "SockRcv", sockRcv);
4749 if (sockSnd)
4750 InsertConfigInteger(pCfg, "SockSnd", sockSnd);
4751 if (tcpRcv)
4752 InsertConfigInteger(pCfg, "TcpRcv", tcpRcv);
4753 if (tcpSnd)
4754 InsertConfigInteger(pCfg, "TcpSnd", tcpSnd);
4755 hrc = natEngine->COMGETTER(TFTPPrefix)(bstr.asOutParam()); H();
4756 if (!bstr.isEmpty())
4757 {
4758 RemoveConfigValue(pCfg, "TFTPPrefix");
4759 InsertConfigString(pCfg, "TFTPPrefix", bstr);
4760 }
4761 hrc = natEngine->COMGETTER(TFTPBootFile)(bstr.asOutParam()); H();
4762 if (!bstr.isEmpty())
4763 {
4764 RemoveConfigValue(pCfg, "BootFile");
4765 InsertConfigString(pCfg, "BootFile", bstr);
4766 }
4767 hrc = natEngine->COMGETTER(TFTPNextServer)(bstr.asOutParam()); H();
4768 if (!bstr.isEmpty())
4769 InsertConfigString(pCfg, "NextServer", bstr);
4770 BOOL fDNSFlag;
4771 hrc = natEngine->COMGETTER(DNSPassDomain)(&fDNSFlag); H();
4772 InsertConfigInteger(pCfg, "PassDomain", fDNSFlag);
4773 hrc = natEngine->COMGETTER(DNSProxy)(&fDNSFlag); H();
4774 InsertConfigInteger(pCfg, "DNSProxy", fDNSFlag);
4775 hrc = natEngine->COMGETTER(DNSUseHostResolver)(&fDNSFlag); H();
4776 InsertConfigInteger(pCfg, "UseHostResolver", fDNSFlag);
4777
4778 ULONG aliasMode;
4779 hrc = natEngine->COMGETTER(AliasMode)(&aliasMode); H();
4780 InsertConfigInteger(pCfg, "AliasMode", aliasMode);
4781
4782 /* port-forwarding */
4783 SafeArray<BSTR> pfs;
4784 hrc = natEngine->COMGETTER(Redirects)(ComSafeArrayAsOutParam(pfs)); H();
4785 PCFGMNODE pPF = NULL; /* /Devices/Dev/.../Config/PF#0/ */
4786 for (unsigned int i = 0; i < pfs.size(); ++i)
4787 {
4788 uint16_t port = 0;
4789 BSTR r = pfs[i];
4790 Utf8Str utf = Utf8Str(r);
4791 Utf8Str strName;
4792 Utf8Str strProto;
4793 Utf8Str strHostPort;
4794 Utf8Str strHostIP;
4795 Utf8Str strGuestPort;
4796 Utf8Str strGuestIP;
4797 size_t pos, ppos;
4798 pos = ppos = 0;
4799#define ITERATE_TO_NEXT_TERM(res, str, pos, ppos) \
4800 { \
4801 pos = str.find(",", ppos); \
4802 if (pos == Utf8Str::npos) \
4803 { \
4804 Log(( #res " extracting from %s is failed\n", str.c_str())); \
4805 continue; \
4806 } \
4807 res = str.substr(ppos, pos - ppos); \
4808 Log2((#res " %s pos:%d, ppos:%d\n", res.c_str(), pos, ppos)); \
4809 ppos = pos + 1; \
4810 } /* no do { ... } while because of 'continue' */
4811 ITERATE_TO_NEXT_TERM(strName, utf, pos, ppos);
4812 ITERATE_TO_NEXT_TERM(strProto, utf, pos, ppos);
4813 ITERATE_TO_NEXT_TERM(strHostIP, utf, pos, ppos);
4814 ITERATE_TO_NEXT_TERM(strHostPort, utf, pos, ppos);
4815 ITERATE_TO_NEXT_TERM(strGuestIP, utf, pos, ppos);
4816 strGuestPort = utf.substr(ppos, utf.length() - ppos);
4817#undef ITERATE_TO_NEXT_TERM
4818
4819 uint32_t proto = strProto.toUInt32();
4820 bool fValid = true;
4821 switch (proto)
4822 {
4823 case NATProtocol_UDP:
4824 strProto = "UDP";
4825 break;
4826 case NATProtocol_TCP:
4827 strProto = "TCP";
4828 break;
4829 default:
4830 fValid = false;
4831 }
4832 /* continue with next rule if no valid proto was passed */
4833 if (!fValid)
4834 continue;
4835
4836 if (strName.isEmpty())
4837 VMSetError(VMR3GetVM(mpUVM), VERR_CFGM_NO_NODE, RT_SRC_POS,
4838 N_("NAT redirection rule without a name"));
4839
4840 InsertConfigNode(pCfg, strName.c_str(), &pPF);
4841 InsertConfigString(pPF, "Protocol", strProto);
4842
4843 if (!strHostIP.isEmpty())
4844 InsertConfigString(pPF, "BindIP", strHostIP);
4845
4846 if (!strGuestIP.isEmpty())
4847 InsertConfigString(pPF, "GuestIP", strGuestIP);
4848
4849 port = RTStrToUInt16(strHostPort.c_str());
4850 if (port)
4851 InsertConfigInteger(pPF, "HostPort", port);
4852
4853 port = RTStrToUInt16(strGuestPort.c_str());
4854 if (port)
4855 InsertConfigInteger(pPF, "GuestPort", port);
4856 }
4857 break;
4858 }
4859
4860 case NetworkAttachmentType_Bridged:
4861 {
4862#if (defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD)) && !defined(VBOX_WITH_NETFLT)
4863 hrc = i_attachToTapInterface(aNetworkAdapter);
4864 if (FAILED(hrc))
4865 {
4866 switch (hrc)
4867 {
4868 case VERR_ACCESS_DENIED:
4869 return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
4870 "Failed to open '/dev/net/tun' for read/write access. Please check the "
4871 "permissions of that node. Either run 'chmod 0666 /dev/net/tun' or "
4872 "change the group of that node and make yourself a member of that group. Make "
4873 "sure that these changes are permanent, especially if you are "
4874 "using udev"));
4875 default:
4876 AssertMsgFailed(("Could not attach to host interface! Bad!\n"));
4877 return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
4878 "Failed to initialize Host Interface Networking"));
4879 }
4880 }
4881
4882 Assert((intptr_t)maTapFD[uInstance] >= 0);
4883 if ((intptr_t)maTapFD[uInstance] >= 0)
4884 {
4885 InsertConfigString(pLunL0, "Driver", "HostInterface");
4886 InsertConfigNode(pLunL0, "Config", &pCfg);
4887 InsertConfigInteger(pCfg, "FileHandle", (intptr_t)maTapFD[uInstance]);
4888 }
4889
4890#elif defined(VBOX_WITH_NETFLT)
4891 /*
4892 * This is the new VBoxNetFlt+IntNet stuff.
4893 */
4894 Bstr BridgedIfName;
4895 hrc = aNetworkAdapter->COMGETTER(BridgedInterface)(BridgedIfName.asOutParam());
4896 if (FAILED(hrc))
4897 {
4898 LogRel(("NetworkAttachmentType_Bridged: COMGETTER(BridgedInterface) failed, hrc (0x%x)\n", hrc));
4899 H();
4900 }
4901
4902 Utf8Str BridgedIfNameUtf8(BridgedIfName);
4903 const char *pszBridgedIfName = BridgedIfNameUtf8.c_str();
4904
4905# if defined(RT_OS_DARWIN)
4906 /* The name is on the form 'ifX: long name', chop it off at the colon. */
4907 char szTrunk[8];
4908 RTStrCopy(szTrunk, sizeof(szTrunk), pszBridgedIfName);
4909 char *pszColon = (char *)memchr(szTrunk, ':', sizeof(szTrunk));
4910// Quick fix for @bugref{5633}
4911// if (!pszColon)
4912// {
4913// /*
4914// * Dynamic changing of attachment causes an attempt to configure
4915// * network with invalid host adapter (as it is must be changed before
4916// * the attachment), calling Detach here will cause a deadlock.
4917// * See @bugref{4750}.
4918// * hrc = aNetworkAdapter->Detach(); H();
4919// */
4920// return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
4921// N_("Malformed host interface networking name '%ls'"),
4922// BridgedIfName.raw());
4923// }
4924 if (pszColon)
4925 *pszColon = '\0';
4926 const char *pszTrunk = szTrunk;
4927
4928# elif defined(RT_OS_SOLARIS)
4929 /* The name is on the form format 'ifX[:1] - long name, chop it off at space. */
4930 char szTrunk[256];
4931 strlcpy(szTrunk, pszBridgedIfName, sizeof(szTrunk));
4932 char *pszSpace = (char *)memchr(szTrunk, ' ', sizeof(szTrunk));
4933
4934 /*
4935 * Currently don't bother about malformed names here for the sake of people using
4936 * VBoxManage and setting only the NIC name from there. If there is a space we
4937 * chop it off and proceed, otherwise just use whatever we've got.
4938 */
4939 if (pszSpace)
4940 *pszSpace = '\0';
4941
4942 /* Chop it off at the colon (zone naming eg: e1000g:1 we need only the e1000g) */
4943 char *pszColon = (char *)memchr(szTrunk, ':', sizeof(szTrunk));
4944 if (pszColon)
4945 *pszColon = '\0';
4946
4947 const char *pszTrunk = szTrunk;
4948
4949# elif defined(RT_OS_WINDOWS)
4950 ComPtr<IHostNetworkInterface> hostInterface;
4951 hrc = host->FindHostNetworkInterfaceByName(BridgedIfName.raw(),
4952 hostInterface.asOutParam());
4953 if (!SUCCEEDED(hrc))
4954 {
4955 AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: FindByName failed, rc=%Rhrc (0x%x)", hrc, hrc));
4956 return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
4957 N_("Nonexistent host networking interface, name '%ls'"),
4958 BridgedIfName.raw());
4959 }
4960
4961 HostNetworkInterfaceType_T eIfType;
4962 hrc = hostInterface->COMGETTER(InterfaceType)(&eIfType);
4963 if (FAILED(hrc))
4964 {
4965 LogRel(("NetworkAttachmentType_Bridged: COMGETTER(InterfaceType) failed, hrc (0x%x)\n", hrc));
4966 H();
4967 }
4968
4969 if (eIfType != HostNetworkInterfaceType_Bridged)
4970 {
4971 return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
4972 N_("Interface ('%ls') is not a Bridged Adapter interface"),
4973 BridgedIfName.raw());
4974 }
4975
4976 hrc = hostInterface->COMGETTER(Id)(bstr.asOutParam());
4977 if (FAILED(hrc))
4978 {
4979 LogRel(("NetworkAttachmentType_Bridged: COMGETTER(Id) failed, hrc (0x%x)\n", hrc));
4980 H();
4981 }
4982 Guid hostIFGuid(bstr);
4983
4984 INetCfg *pNc;
4985 ComPtr<INetCfgComponent> pAdaptorComponent;
4986 LPWSTR pszApp;
4987
4988 hrc = VBoxNetCfgWinQueryINetCfg(&pNc, FALSE, L"VirtualBox", 10, &pszApp);
4989 Assert(hrc == S_OK);
4990 if (hrc != S_OK)
4991 {
4992 LogRel(("NetworkAttachmentType_Bridged: Failed to get NetCfg, hrc=%Rhrc (0x%x)\n", hrc, hrc));
4993 H();
4994 }
4995
4996 /* get the adapter's INetCfgComponent*/
4997 hrc = VBoxNetCfgWinGetComponentByGuid(pNc, &GUID_DEVCLASS_NET, (GUID*)hostIFGuid.raw(),
4998 pAdaptorComponent.asOutParam());
4999 if (hrc != S_OK)
5000 {
5001 VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /*fHasWriteLock*/);
5002 LogRel(("NetworkAttachmentType_Bridged: VBoxNetCfgWinGetComponentByGuid failed, hrc (0x%x)\n", hrc));
5003 H();
5004 }
5005#define VBOX_WIN_BINDNAME_PREFIX "\\DEVICE\\"
5006 char szTrunkName[INTNET_MAX_TRUNK_NAME];
5007 char *pszTrunkName = szTrunkName;
5008 wchar_t * pswzBindName;
5009 hrc = pAdaptorComponent->GetBindName(&pswzBindName);
5010 Assert(hrc == S_OK);
5011 if (hrc == S_OK)
5012 {
5013 int cwBindName = (int)wcslen(pswzBindName) + 1;
5014 int cbFullBindNamePrefix = sizeof(VBOX_WIN_BINDNAME_PREFIX);
5015 if (sizeof(szTrunkName) > cbFullBindNamePrefix + cwBindName)
5016 {
5017 strcpy(szTrunkName, VBOX_WIN_BINDNAME_PREFIX);
5018 pszTrunkName += cbFullBindNamePrefix-1;
5019 if (!WideCharToMultiByte(CP_ACP, 0, pswzBindName, cwBindName, pszTrunkName,
5020 sizeof(szTrunkName) - cbFullBindNamePrefix + 1, NULL, NULL))
5021 {
5022 DWORD err = GetLastError();
5023 hrc = HRESULT_FROM_WIN32(err);
5024 AssertMsgFailed(("hrc=%Rhrc %#x\n", hrc, hrc));
5025 AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: WideCharToMultiByte failed, hr=%Rhrc (0x%x) err=%u\n",
5026 hrc, hrc, err));
5027 }
5028 }
5029 else
5030 {
5031 AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: insufficient szTrunkName buffer space\n"));
5032 /** @todo set appropriate error code */
5033 hrc = E_FAIL;
5034 }
5035
5036 if (hrc != S_OK)
5037 {
5038 AssertFailed();
5039 CoTaskMemFree(pswzBindName);
5040 VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /*fHasWriteLock*/);
5041 H();
5042 }
5043
5044 /* we're not freeing the bind name since we'll use it later for detecting wireless*/
5045 }
5046 else
5047 {
5048 VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /*fHasWriteLock*/);
5049 AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: VBoxNetCfgWinGetComponentByGuid failed, hrc (0x%x)",
5050 hrc));
5051 H();
5052 }
5053
5054 const char *pszTrunk = szTrunkName;
5055 /* we're not releasing the INetCfg stuff here since we use it later to figure out whether it is wireless */
5056
5057# elif defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD)
5058# if defined(RT_OS_FREEBSD)
5059 /*
5060 * If we bridge to a tap interface open it the `old' direct way.
5061 * This works and performs better than bridging a physical
5062 * interface via the current FreeBSD vboxnetflt implementation.
5063 */
5064 if (!strncmp(pszBridgedIfName, RT_STR_TUPLE("tap"))) {
5065 hrc = i_attachToTapInterface(aNetworkAdapter);
5066 if (FAILED(hrc))
5067 {
5068 switch (hrc)
5069 {
5070 case VERR_ACCESS_DENIED:
5071 return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
5072 "Failed to open '/dev/%s' for read/write access. Please check the "
5073 "permissions of that node, and that the net.link.tap.user_open "
5074 "sysctl is set. Either run 'chmod 0666 /dev/%s' or "
5075 "change the group of that node to vboxusers and make yourself "
5076 "a member of that group. Make sure that these changes are permanent."),
5077 pszBridgedIfName, pszBridgedIfName);
5078 default:
5079 AssertMsgFailed(("Could not attach to tap interface! Bad!\n"));
5080 return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
5081 "Failed to initialize Host Interface Networking"));
5082 }
5083 }
5084
5085 Assert((intptr_t)maTapFD[uInstance] >= 0);
5086 if ((intptr_t)maTapFD[uInstance] >= 0)
5087 {
5088 InsertConfigString(pLunL0, "Driver", "HostInterface");
5089 InsertConfigNode(pLunL0, "Config", &pCfg);
5090 InsertConfigInteger(pCfg, "FileHandle", (intptr_t)maTapFD[uInstance]);
5091 }
5092 break;
5093 }
5094# endif
5095 /** @todo Check for malformed names. */
5096 const char *pszTrunk = pszBridgedIfName;
5097
5098 /* Issue a warning if the interface is down */
5099 {
5100 int iSock = socket(AF_INET, SOCK_DGRAM, 0);
5101 if (iSock >= 0)
5102 {
5103 struct ifreq Req;
5104 RT_ZERO(Req);
5105 RTStrCopy(Req.ifr_name, sizeof(Req.ifr_name), pszBridgedIfName);
5106 if (ioctl(iSock, SIOCGIFFLAGS, &Req) >= 0)
5107 if ((Req.ifr_flags & IFF_UP) == 0)
5108 i_setVMRuntimeErrorCallbackF(0, "BridgedInterfaceDown",
5109 N_("Bridged interface %s is down. Guest will not be able to use this interface"),
5110 pszBridgedIfName);
5111
5112 close(iSock);
5113 }
5114 }
5115
5116# else
5117# error "PORTME (VBOX_WITH_NETFLT)"
5118# endif
5119
5120 InsertConfigString(pLunL0, "Driver", "IntNet");
5121 InsertConfigNode(pLunL0, "Config", &pCfg);
5122 InsertConfigString(pCfg, "Trunk", pszTrunk);
5123 InsertConfigInteger(pCfg, "TrunkType", kIntNetTrunkType_NetFlt);
5124 InsertConfigInteger(pCfg, "IgnoreConnectFailure", (uint64_t)fIgnoreConnectFailure);
5125 InsertConfigString(pCfg, "IfPolicyPromisc", pszPromiscuousGuestPolicy);
5126 char szNetwork[INTNET_MAX_NETWORK_NAME];
5127
5128#if defined(RT_OS_SOLARIS) || defined(RT_OS_DARWIN)
5129 /*
5130 * 'pszTrunk' contains just the interface name required in ring-0, while 'pszBridgedIfName' contains
5131 * interface name + optional description. We must not pass any description to the VM as it can differ
5132 * for the same interface name, eg: "nge0 - ethernet" (GUI) vs "nge0" (VBoxManage).
5133 */
5134 RTStrPrintf(szNetwork, sizeof(szNetwork), "HostInterfaceNetworking-%s", pszTrunk);
5135#else
5136 RTStrPrintf(szNetwork, sizeof(szNetwork), "HostInterfaceNetworking-%s", pszBridgedIfName);
5137#endif
5138 InsertConfigString(pCfg, "Network", szNetwork);
5139 networkName = Bstr(szNetwork);
5140 trunkName = Bstr(pszTrunk);
5141 trunkType = Bstr(TRUNKTYPE_NETFLT);
5142
5143# if defined(RT_OS_DARWIN)
5144 /** @todo Come up with a better deal here. Problem is that IHostNetworkInterface is completely useless here. */
5145 if ( strstr(pszBridgedIfName, "Wireless")
5146 || strstr(pszBridgedIfName, "AirPort" ))
5147 InsertConfigInteger(pCfg, "SharedMacOnWire", true);
5148# elif defined(RT_OS_LINUX)
5149 int iSock = socket(AF_INET, SOCK_DGRAM, 0);
5150 if (iSock >= 0)
5151 {
5152 struct iwreq WRq;
5153
5154 RT_ZERO(WRq);
5155 strncpy(WRq.ifr_name, pszBridgedIfName, IFNAMSIZ);
5156 bool fSharedMacOnWire = ioctl(iSock, SIOCGIWNAME, &WRq) >= 0;
5157 close(iSock);
5158 if (fSharedMacOnWire)
5159 {
5160 InsertConfigInteger(pCfg, "SharedMacOnWire", true);
5161 Log(("Set SharedMacOnWire\n"));
5162 }
5163 else
5164 Log(("Failed to get wireless name\n"));
5165 }
5166 else
5167 Log(("Failed to open wireless socket\n"));
5168# elif defined(RT_OS_FREEBSD)
5169 int iSock = socket(AF_INET, SOCK_DGRAM, 0);
5170 if (iSock >= 0)
5171 {
5172 struct ieee80211req WReq;
5173 uint8_t abData[32];
5174
5175 RT_ZERO(WReq);
5176 strncpy(WReq.i_name, pszBridgedIfName, sizeof(WReq.i_name));
5177 WReq.i_type = IEEE80211_IOC_SSID;
5178 WReq.i_val = -1;
5179 WReq.i_data = abData;
5180 WReq.i_len = sizeof(abData);
5181
5182 bool fSharedMacOnWire = ioctl(iSock, SIOCG80211, &WReq) >= 0;
5183 close(iSock);
5184 if (fSharedMacOnWire)
5185 {
5186 InsertConfigInteger(pCfg, "SharedMacOnWire", true);
5187 Log(("Set SharedMacOnWire\n"));
5188 }
5189 else
5190 Log(("Failed to get wireless name\n"));
5191 }
5192 else
5193 Log(("Failed to open wireless socket\n"));
5194# elif defined(RT_OS_WINDOWS)
5195# define DEVNAME_PREFIX L"\\\\.\\"
5196 /* we are getting the medium type via IOCTL_NDIS_QUERY_GLOBAL_STATS Io Control
5197 * there is a pretty long way till there though since we need to obtain the symbolic link name
5198 * for the adapter device we are going to query given the device Guid */
5199
5200
5201 /* prepend the "\\\\.\\" to the bind name to obtain the link name */
5202
5203 wchar_t FileName[MAX_PATH];
5204 wcscpy(FileName, DEVNAME_PREFIX);
5205 wcscpy((wchar_t*)(((char*)FileName) + sizeof(DEVNAME_PREFIX) - sizeof(FileName[0])), pswzBindName);
5206
5207 /* open the device */
5208 HANDLE hDevice = CreateFile(FileName,
5209 GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
5210 NULL,
5211 OPEN_EXISTING,
5212 FILE_ATTRIBUTE_NORMAL,
5213 NULL);
5214
5215 if (hDevice != INVALID_HANDLE_VALUE)
5216 {
5217 bool fSharedMacOnWire = false;
5218
5219 /* now issue the OID_GEN_PHYSICAL_MEDIUM query */
5220 DWORD Oid = OID_GEN_PHYSICAL_MEDIUM;
5221 NDIS_PHYSICAL_MEDIUM PhMedium;
5222 DWORD cbResult;
5223 if (DeviceIoControl(hDevice,
5224 IOCTL_NDIS_QUERY_GLOBAL_STATS,
5225 &Oid,
5226 sizeof(Oid),
5227 &PhMedium,
5228 sizeof(PhMedium),
5229 &cbResult,
5230 NULL))
5231 {
5232 /* that was simple, now examine PhMedium */
5233 if ( PhMedium == NdisPhysicalMediumWirelessWan
5234 || PhMedium == NdisPhysicalMediumWirelessLan
5235 || PhMedium == NdisPhysicalMediumNative802_11
5236 || PhMedium == NdisPhysicalMediumBluetooth)
5237 fSharedMacOnWire = true;
5238 }
5239 else
5240 {
5241 int winEr = GetLastError();
5242 LogRel(("Console::configNetwork: DeviceIoControl failed, err (0x%x), ignoring\n", winEr));
5243 Assert(winEr == ERROR_INVALID_PARAMETER || winEr == ERROR_NOT_SUPPORTED || winEr == ERROR_BAD_COMMAND);
5244 }
5245 CloseHandle(hDevice);
5246
5247 if (fSharedMacOnWire)
5248 {
5249 Log(("this is a wireless adapter"));
5250 InsertConfigInteger(pCfg, "SharedMacOnWire", true);
5251 Log(("Set SharedMacOnWire\n"));
5252 }
5253 else
5254 Log(("this is NOT a wireless adapter"));
5255 }
5256 else
5257 {
5258 int winEr = GetLastError();
5259 AssertLogRelMsgFailed(("Console::configNetwork: CreateFile failed, err (0x%x), ignoring\n", winEr));
5260 }
5261
5262 CoTaskMemFree(pswzBindName);
5263
5264 pAdaptorComponent.setNull();
5265 /* release the pNc finally */
5266 VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /*fHasWriteLock*/);
5267# else
5268 /** @todo PORTME: wireless detection */
5269# endif
5270
5271# if defined(RT_OS_SOLARIS)
5272# if 0 /* bird: this is a bit questionable and might cause more trouble than its worth. */
5273 /* Zone access restriction, don't allow snooping the global zone. */
5274 zoneid_t ZoneId = getzoneid();
5275 if (ZoneId != GLOBAL_ZONEID)
5276 {
5277 InsertConfigInteger(pCfg, "IgnoreAllPromisc", true);
5278 }
5279# endif
5280# endif
5281
5282#elif defined(RT_OS_WINDOWS) /* not defined NetFlt */
5283 /* NOTHING TO DO HERE */
5284#elif defined(RT_OS_LINUX)
5285/// @todo aleksey: is there anything to be done here?
5286#elif defined(RT_OS_FREEBSD)
5287/** @todo FreeBSD: Check out this later (HIF networking). */
5288#else
5289# error "Port me"
5290#endif
5291 break;
5292 }
5293
5294 case NetworkAttachmentType_Internal:
5295 {
5296 hrc = aNetworkAdapter->COMGETTER(InternalNetwork)(bstr.asOutParam()); H();
5297 if (!bstr.isEmpty())
5298 {
5299 InsertConfigString(pLunL0, "Driver", "IntNet");
5300 InsertConfigNode(pLunL0, "Config", &pCfg);
5301 InsertConfigString(pCfg, "Network", bstr);
5302 InsertConfigInteger(pCfg, "TrunkType", kIntNetTrunkType_WhateverNone);
5303 InsertConfigString(pCfg, "IfPolicyPromisc", pszPromiscuousGuestPolicy);
5304 networkName = bstr;
5305 trunkType = Bstr(TRUNKTYPE_WHATEVER);
5306 }
5307 break;
5308 }
5309
5310 case NetworkAttachmentType_HostOnly:
5311 {
5312 InsertConfigString(pLunL0, "Driver", "IntNet");
5313 InsertConfigNode(pLunL0, "Config", &pCfg);
5314
5315 Bstr HostOnlyName;
5316 hrc = aNetworkAdapter->COMGETTER(HostOnlyInterface)(HostOnlyName.asOutParam());
5317 if (FAILED(hrc))
5318 {
5319 LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(HostOnlyInterface) failed, hrc (0x%x)\n", hrc));
5320 H();
5321 }
5322
5323 Utf8Str HostOnlyNameUtf8(HostOnlyName);
5324 const char *pszHostOnlyName = HostOnlyNameUtf8.c_str();
5325 ComPtr<IHostNetworkInterface> hostInterface;
5326 rc = host->FindHostNetworkInterfaceByName(HostOnlyName.raw(),
5327 hostInterface.asOutParam());
5328 if (!SUCCEEDED(rc))
5329 {
5330 LogRel(("NetworkAttachmentType_HostOnly: FindByName failed, rc (0x%x)\n", rc));
5331 return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
5332 N_("Nonexistent host networking interface, name '%ls'"),
5333 HostOnlyName.raw());
5334 }
5335
5336 char szNetwork[INTNET_MAX_NETWORK_NAME];
5337 RTStrPrintf(szNetwork, sizeof(szNetwork), "HostInterfaceNetworking-%s", pszHostOnlyName);
5338
5339#if defined(RT_OS_WINDOWS)
5340# ifndef VBOX_WITH_NETFLT
5341 hrc = E_NOTIMPL;
5342 LogRel(("NetworkAttachmentType_HostOnly: Not Implemented\n"));
5343 H();
5344# else /* defined VBOX_WITH_NETFLT*/
5345 /** @todo r=bird: Put this in a function. */
5346
5347 HostNetworkInterfaceType_T eIfType;
5348 hrc = hostInterface->COMGETTER(InterfaceType)(&eIfType);
5349 if (FAILED(hrc))
5350 {
5351 LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(InterfaceType) failed, hrc (0x%x)\n", hrc));
5352 H();
5353 }
5354
5355 if (eIfType != HostNetworkInterfaceType_HostOnly)
5356 return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
5357 N_("Interface ('%ls') is not a Host-Only Adapter interface"),
5358 HostOnlyName.raw());
5359
5360 hrc = hostInterface->COMGETTER(Id)(bstr.asOutParam());
5361 if (FAILED(hrc))
5362 {
5363 LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(Id) failed, hrc (0x%x)\n", hrc));
5364 H();
5365 }
5366 Guid hostIFGuid(bstr);
5367
5368 INetCfg *pNc;
5369 ComPtr<INetCfgComponent> pAdaptorComponent;
5370 LPWSTR pszApp;
5371 hrc = VBoxNetCfgWinQueryINetCfg(&pNc, FALSE, L"VirtualBox", 10, &pszApp);
5372 Assert(hrc == S_OK);
5373 if (hrc != S_OK)
5374 {
5375 LogRel(("NetworkAttachmentType_HostOnly: Failed to get NetCfg, hrc=%Rhrc (0x%x)\n", hrc, hrc));
5376 H();
5377 }
5378
5379 /* get the adapter's INetCfgComponent*/
5380 hrc = VBoxNetCfgWinGetComponentByGuid(pNc, &GUID_DEVCLASS_NET, (GUID*)hostIFGuid.raw(),
5381 pAdaptorComponent.asOutParam());
5382 if (hrc != S_OK)
5383 {
5384 VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /*fHasWriteLock*/);
5385 LogRel(("NetworkAttachmentType_HostOnly: VBoxNetCfgWinGetComponentByGuid failed, hrc=%Rhrc (0x%x)\n", hrc, hrc));
5386 H();
5387 }
5388# define VBOX_WIN_BINDNAME_PREFIX "\\DEVICE\\"
5389 char szTrunkName[INTNET_MAX_TRUNK_NAME];
5390 char *pszTrunkName = szTrunkName;
5391 wchar_t * pswzBindName;
5392 hrc = pAdaptorComponent->GetBindName(&pswzBindName);
5393 Assert(hrc == S_OK);
5394 if (hrc == S_OK)
5395 {
5396 int cwBindName = (int)wcslen(pswzBindName) + 1;
5397 int cbFullBindNamePrefix = sizeof(VBOX_WIN_BINDNAME_PREFIX);
5398 if (sizeof(szTrunkName) > cbFullBindNamePrefix + cwBindName)
5399 {
5400 strcpy(szTrunkName, VBOX_WIN_BINDNAME_PREFIX);
5401 pszTrunkName += cbFullBindNamePrefix-1;
5402 if (!WideCharToMultiByte(CP_ACP, 0, pswzBindName, cwBindName, pszTrunkName,
5403 sizeof(szTrunkName) - cbFullBindNamePrefix + 1, NULL, NULL))
5404 {
5405 DWORD err = GetLastError();
5406 hrc = HRESULT_FROM_WIN32(err);
5407 AssertLogRelMsgFailed(("NetworkAttachmentType_HostOnly: WideCharToMultiByte failed, hr=%Rhrc (0x%x) err=%u\n",
5408 hrc, hrc, err));
5409 }
5410 }
5411 else
5412 {
5413 AssertLogRelMsgFailed(("NetworkAttachmentType_HostOnly: insufficient szTrunkName buffer space\n"));
5414 /** @todo set appropriate error code */
5415 hrc = E_FAIL;
5416 }
5417
5418 if (hrc != S_OK)
5419 {
5420 AssertFailed();
5421 CoTaskMemFree(pswzBindName);
5422 VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /*fHasWriteLock*/);
5423 H();
5424 }
5425 }
5426 else
5427 {
5428 VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /*fHasWriteLock*/);
5429 AssertLogRelMsgFailed(("NetworkAttachmentType_HostOnly: VBoxNetCfgWinGetComponentByGuid failed, hrc=%Rhrc (0x%x)\n",
5430 hrc, hrc));
5431 H();
5432 }
5433
5434
5435 CoTaskMemFree(pswzBindName);
5436
5437 /* The old NDIS5.1 version of driver uses TRUNKTYPE_NETADP */
5438 trunkType = IsNdis6() ? TRUNKTYPE_NETFLT : TRUNKTYPE_NETADP;
5439 InsertConfigInteger(pCfg, "TrunkType", trunkType == TRUNKTYPE_NETFLT ? kIntNetTrunkType_NetFlt : kIntNetTrunkType_NetAdp);
5440
5441 pAdaptorComponent.setNull();
5442 /* release the pNc finally */
5443 VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /*fHasWriteLock*/);
5444
5445 const char *pszTrunk = szTrunkName;
5446
5447 InsertConfigString(pCfg, "Trunk", pszTrunk);
5448 InsertConfigString(pCfg, "Network", szNetwork);
5449 InsertConfigInteger(pCfg, "IgnoreConnectFailure", (uint64_t)fIgnoreConnectFailure); /** @todo why is this
5450 windows only?? */
5451 networkName = Bstr(szNetwork);
5452 trunkName = Bstr(pszTrunk);
5453# endif /* defined VBOX_WITH_NETFLT*/
5454#elif defined(RT_OS_DARWIN)
5455 InsertConfigString(pCfg, "Trunk", pszHostOnlyName);
5456 InsertConfigString(pCfg, "Network", szNetwork);
5457 InsertConfigInteger(pCfg, "TrunkType", kIntNetTrunkType_NetAdp);
5458 networkName = Bstr(szNetwork);
5459 trunkName = Bstr(pszHostOnlyName);
5460 trunkType = TRUNKTYPE_NETADP;
5461#else
5462 InsertConfigString(pCfg, "Trunk", pszHostOnlyName);
5463 InsertConfigString(pCfg, "Network", szNetwork);
5464 InsertConfigInteger(pCfg, "TrunkType", kIntNetTrunkType_NetFlt);
5465 networkName = Bstr(szNetwork);
5466 trunkName = Bstr(pszHostOnlyName);
5467 trunkType = TRUNKTYPE_NETFLT;
5468#endif
5469 InsertConfigString(pCfg, "IfPolicyPromisc", pszPromiscuousGuestPolicy);
5470
5471#if !defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
5472
5473 Bstr tmpAddr, tmpMask;
5474
5475 hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPAddress",
5476 pszHostOnlyName).raw(),
5477 tmpAddr.asOutParam());
5478 if (SUCCEEDED(hrc) && !tmpAddr.isEmpty())
5479 {
5480 hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPNetMask",
5481 pszHostOnlyName).raw(),
5482 tmpMask.asOutParam());
5483 if (SUCCEEDED(hrc) && !tmpMask.isEmpty())
5484 hrc = hostInterface->EnableStaticIPConfig(tmpAddr.raw(),
5485 tmpMask.raw());
5486 else
5487 hrc = hostInterface->EnableStaticIPConfig(tmpAddr.raw(),
5488 Bstr(VBOXNET_IPV4MASK_DEFAULT).raw());
5489 }
5490 else
5491 {
5492 /* Grab the IP number from the 'vboxnetX' instance number (see netif.h) */
5493 hrc = hostInterface->EnableStaticIPConfig(getDefaultIPv4Address(Bstr(pszHostOnlyName)).raw(),
5494 Bstr(VBOXNET_IPV4MASK_DEFAULT).raw());
5495 }
5496
5497 ComAssertComRC(hrc); /** @todo r=bird: Why this isn't fatal? (H()) */
5498
5499 hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPV6Address",
5500 pszHostOnlyName).raw(),
5501 tmpAddr.asOutParam());
5502 if (SUCCEEDED(hrc))
5503 hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPV6NetMask", pszHostOnlyName).raw(),
5504 tmpMask.asOutParam());
5505 if (SUCCEEDED(hrc) && !tmpAddr.isEmpty() && !tmpMask.isEmpty())
5506 {
5507 hrc = hostInterface->EnableStaticIPConfigV6(tmpAddr.raw(),
5508 Utf8Str(tmpMask).toUInt32());
5509 ComAssertComRC(hrc); /** @todo r=bird: Why this isn't fatal? (H()) */
5510 }
5511#endif
5512 break;
5513 }
5514
5515 case NetworkAttachmentType_Generic:
5516 {
5517 hrc = aNetworkAdapter->COMGETTER(GenericDriver)(bstr.asOutParam()); H();
5518 SafeArray<BSTR> names;
5519 SafeArray<BSTR> values;
5520 hrc = aNetworkAdapter->GetProperties(Bstr().raw(),
5521 ComSafeArrayAsOutParam(names),
5522 ComSafeArrayAsOutParam(values)); H();
5523
5524 InsertConfigString(pLunL0, "Driver", bstr);
5525 InsertConfigNode(pLunL0, "Config", &pCfg);
5526 for (size_t ii = 0; ii < names.size(); ++ii)
5527 {
5528 if (values[ii] && *values[ii])
5529 {
5530 Utf8Str name = names[ii];
5531 Utf8Str value = values[ii];
5532 InsertConfigString(pCfg, name.c_str(), value);
5533 }
5534 }
5535 break;
5536 }
5537
5538 case NetworkAttachmentType_NATNetwork:
5539 {
5540 hrc = aNetworkAdapter->COMGETTER(NATNetwork)(bstr.asOutParam()); H();
5541 if (!bstr.isEmpty())
5542 {
5543 /** @todo add intnet prefix to separate namespaces, and add trunk if dealing with vboxnatX */
5544 InsertConfigString(pLunL0, "Driver", "IntNet");
5545 InsertConfigNode(pLunL0, "Config", &pCfg);
5546 InsertConfigString(pCfg, "Network", bstr);
5547 InsertConfigInteger(pCfg, "TrunkType", kIntNetTrunkType_WhateverNone);
5548 InsertConfigString(pCfg, "IfPolicyPromisc", pszPromiscuousGuestPolicy);
5549 networkName = bstr;
5550 trunkType = Bstr(TRUNKTYPE_WHATEVER);
5551 }
5552 break;
5553 }
5554
5555 default:
5556 AssertMsgFailed(("should not get here!\n"));
5557 break;
5558 }
5559
5560 /*
5561 * Attempt to attach the driver.
5562 */
5563 switch (eAttachmentType)
5564 {
5565 case NetworkAttachmentType_Null:
5566 break;
5567
5568 case NetworkAttachmentType_Bridged:
5569 case NetworkAttachmentType_Internal:
5570 case NetworkAttachmentType_HostOnly:
5571 case NetworkAttachmentType_NAT:
5572 case NetworkAttachmentType_Generic:
5573 case NetworkAttachmentType_NATNetwork:
5574 {
5575 if (SUCCEEDED(hrc) && SUCCEEDED(rc))
5576 {
5577 if (fAttachDetach)
5578 {
5579 rc = PDMR3DriverAttach(mpUVM, pszDevice, uInstance, uLun, 0 /*fFlags*/, NULL /* ppBase */);
5580 //AssertRC(rc);
5581 }
5582
5583 {
5584 /** @todo pritesh: get the dhcp server name from the
5585 * previous network configuration and then stop the server
5586 * else it may conflict with the dhcp server running with
5587 * the current attachment type
5588 */
5589 /* Stop the hostonly DHCP Server */
5590 }
5591
5592 /*
5593 * NAT networks start their DHCP server theirself, see NATNetwork::Start()
5594 */
5595 if ( !networkName.isEmpty()
5596 && eAttachmentType != NetworkAttachmentType_NATNetwork)
5597 {
5598 /*
5599 * Until we implement service reference counters DHCP Server will be stopped
5600 * by DHCPServerRunner destructor.
5601 */
5602 ComPtr<IDHCPServer> dhcpServer;
5603 hrc = virtualBox->FindDHCPServerByNetworkName(networkName.raw(),
5604 dhcpServer.asOutParam());
5605 if (SUCCEEDED(hrc))
5606 {
5607 /* there is a DHCP server available for this network */
5608 BOOL fEnabledDhcp;
5609 hrc = dhcpServer->COMGETTER(Enabled)(&fEnabledDhcp);
5610 if (FAILED(hrc))
5611 {
5612 LogRel(("DHCP svr: COMGETTER(Enabled) failed, hrc (%Rhrc)\n", hrc));
5613 H();
5614 }
5615
5616 if (fEnabledDhcp)
5617 hrc = dhcpServer->Start(networkName.raw(),
5618 trunkName.raw(),
5619 trunkType.raw());
5620 }
5621 else
5622 hrc = S_OK;
5623 }
5624 }
5625
5626 break;
5627 }
5628
5629 default:
5630 AssertMsgFailed(("should not get here!\n"));
5631 break;
5632 }
5633
5634 meAttachmentType[uInstance] = eAttachmentType;
5635 }
5636 catch (ConfigError &x)
5637 {
5638 // InsertConfig threw something:
5639 return x.m_vrc;
5640 }
5641
5642#undef H
5643
5644 return VINF_SUCCESS;
5645}
5646
5647#ifdef VBOX_WITH_GUEST_PROPS
5648/**
5649 * Set an array of guest properties
5650 */
5651static void configSetProperties(VMMDev * const pVMMDev,
5652 void *names,
5653 void *values,
5654 void *timestamps,
5655 void *flags)
5656{
5657 VBOXHGCMSVCPARM parms[4];
5658
5659 parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
5660 parms[0].u.pointer.addr = names;
5661 parms[0].u.pointer.size = 0; /* We don't actually care. */
5662 parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
5663 parms[1].u.pointer.addr = values;
5664 parms[1].u.pointer.size = 0; /* We don't actually care. */
5665 parms[2].type = VBOX_HGCM_SVC_PARM_PTR;
5666 parms[2].u.pointer.addr = timestamps;
5667 parms[2].u.pointer.size = 0; /* We don't actually care. */
5668 parms[3].type = VBOX_HGCM_SVC_PARM_PTR;
5669 parms[3].u.pointer.addr = flags;
5670 parms[3].u.pointer.size = 0; /* We don't actually care. */
5671
5672 pVMMDev->hgcmHostCall("VBoxGuestPropSvc",
5673 guestProp::SET_PROPS_HOST,
5674 4,
5675 &parms[0]);
5676}
5677
5678/**
5679 * Set a single guest property
5680 */
5681static void configSetProperty(VMMDev * const pVMMDev,
5682 const char *pszName,
5683 const char *pszValue,
5684 const char *pszFlags)
5685{
5686 VBOXHGCMSVCPARM parms[4];
5687
5688 AssertPtrReturnVoid(pszName);
5689 AssertPtrReturnVoid(pszValue);
5690 AssertPtrReturnVoid(pszFlags);
5691 parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
5692 parms[0].u.pointer.addr = (void *)pszName;
5693 parms[0].u.pointer.size = (uint32_t)strlen(pszName) + 1;
5694 parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
5695 parms[1].u.pointer.addr = (void *)pszValue;
5696 parms[1].u.pointer.size = (uint32_t)strlen(pszValue) + 1;
5697 parms[2].type = VBOX_HGCM_SVC_PARM_PTR;
5698 parms[2].u.pointer.addr = (void *)pszFlags;
5699 parms[2].u.pointer.size = (uint32_t)strlen(pszFlags) + 1;
5700 pVMMDev->hgcmHostCall("VBoxGuestPropSvc", guestProp::SET_PROP_HOST, 3,
5701 &parms[0]);
5702}
5703
5704/**
5705 * Set the global flags value by calling the service
5706 * @returns the status returned by the call to the service
5707 *
5708 * @param pTable the service instance handle
5709 * @param eFlags the flags to set
5710 */
5711int configSetGlobalPropertyFlags(VMMDev * const pVMMDev,
5712 guestProp::ePropFlags eFlags)
5713{
5714 VBOXHGCMSVCPARM paParm;
5715 paParm.setUInt32(eFlags);
5716 int rc = pVMMDev->hgcmHostCall("VBoxGuestPropSvc",
5717 guestProp::SET_GLOBAL_FLAGS_HOST, 1,
5718 &paParm);
5719 if (RT_FAILURE(rc))
5720 {
5721 char szFlags[guestProp::MAX_FLAGS_LEN];
5722 if (RT_FAILURE(writeFlags(eFlags, szFlags)))
5723 Log(("Failed to set the global flags.\n"));
5724 else
5725 Log(("Failed to set the global flags \"%s\".\n", szFlags));
5726 }
5727 return rc;
5728}
5729#endif /* VBOX_WITH_GUEST_PROPS */
5730
5731/**
5732 * Set up the Guest Property service, populate it with properties read from
5733 * the machine XML and set a couple of initial properties.
5734 */
5735/* static */ int Console::i_configGuestProperties(void *pvConsole, PUVM pUVM)
5736{
5737#ifdef VBOX_WITH_GUEST_PROPS
5738 AssertReturn(pvConsole, VERR_INVALID_POINTER);
5739 ComObjPtr<Console> pConsole = static_cast<Console *>(pvConsole);
5740 AssertReturn(pConsole->m_pVMMDev, VERR_INVALID_POINTER);
5741
5742 /* Load the service */
5743 int rc = pConsole->m_pVMMDev->hgcmLoadService("VBoxGuestPropSvc", "VBoxGuestPropSvc");
5744
5745 if (RT_FAILURE(rc))
5746 {
5747 LogRel(("VBoxGuestPropSvc is not available. rc = %Rrc\n", rc));
5748 /* That is not a fatal failure. */
5749 rc = VINF_SUCCESS;
5750 }
5751 else
5752 {
5753 /*
5754 * Initialize built-in properties that can be changed and saved.
5755 *
5756 * These are typically transient properties that the guest cannot
5757 * change.
5758 */
5759
5760 {
5761 VBOXHGCMSVCPARM Params[2];
5762 int rc2 = pConsole->m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", guestProp::GET_DBGF_INFO_FN, 2, &Params[0]);
5763 if (RT_SUCCESS(rc2))
5764 {
5765 PFNDBGFHANDLEREXT pfnHandler = (PFNDBGFHANDLEREXT)(uintptr_t)Params[0].u.pointer.addr;
5766 void *pService = (void*)Params[1].u.pointer.addr;
5767 DBGFR3InfoRegisterExternal(pUVM, "guestprops", "Display the guest properties", pfnHandler, pService);
5768 }
5769 }
5770
5771 /* Sysprep execution by VBoxService. */
5772 configSetProperty(pConsole->m_pVMMDev,
5773 "/VirtualBox/HostGuest/SysprepExec", "",
5774 "TRANSIENT, RDONLYGUEST");
5775 configSetProperty(pConsole->m_pVMMDev,
5776 "/VirtualBox/HostGuest/SysprepArgs", "",
5777 "TRANSIENT, RDONLYGUEST");
5778
5779 /*
5780 * Pull over the properties from the server.
5781 */
5782 SafeArray<BSTR> namesOut;
5783 SafeArray<BSTR> valuesOut;
5784 SafeArray<LONG64> timestampsOut;
5785 SafeArray<BSTR> flagsOut;
5786 HRESULT hrc;
5787 hrc = pConsole->mControl->PullGuestProperties(ComSafeArrayAsOutParam(namesOut),
5788 ComSafeArrayAsOutParam(valuesOut),
5789 ComSafeArrayAsOutParam(timestampsOut),
5790 ComSafeArrayAsOutParam(flagsOut));
5791 AssertLogRelMsgReturn(SUCCEEDED(hrc), ("hrc=%Rhrc\n", hrc), VERR_MAIN_CONFIG_CONSTRUCTOR_COM_ERROR);
5792 size_t cProps = namesOut.size();
5793 size_t cAlloc = cProps + 1;
5794 if ( valuesOut.size() != cProps
5795 || timestampsOut.size() != cProps
5796 || flagsOut.size() != cProps
5797 )
5798 AssertFailedReturn(VERR_INVALID_PARAMETER);
5799
5800 char **papszNames, **papszValues, **papszFlags;
5801 char szEmpty[] = "";
5802 LONG64 *pai64Timestamps;
5803 papszNames = (char **)RTMemTmpAllocZ(sizeof(void *) * cAlloc);
5804 papszValues = (char **)RTMemTmpAllocZ(sizeof(void *) * cAlloc);
5805 pai64Timestamps = (LONG64 *)RTMemTmpAllocZ(sizeof(LONG64) * cAlloc);
5806 papszFlags = (char **)RTMemTmpAllocZ(sizeof(void *) * cAlloc);
5807 if (papszNames && papszValues && pai64Timestamps && papszFlags)
5808 {
5809 for (unsigned i = 0; RT_SUCCESS(rc) && i < cProps; ++i)
5810 {
5811 AssertPtrBreakStmt(namesOut[i], rc = VERR_INVALID_PARAMETER);
5812 rc = RTUtf16ToUtf8(namesOut[i], &papszNames[i]);
5813 if (RT_FAILURE(rc))
5814 break;
5815 if (valuesOut[i])
5816 rc = RTUtf16ToUtf8(valuesOut[i], &papszValues[i]);
5817 else
5818 papszValues[i] = szEmpty;
5819 if (RT_FAILURE(rc))
5820 break;
5821 pai64Timestamps[i] = timestampsOut[i];
5822 if (flagsOut[i])
5823 rc = RTUtf16ToUtf8(flagsOut[i], &papszFlags[i]);
5824 else
5825 papszFlags[i] = szEmpty;
5826 }
5827 if (RT_SUCCESS(rc))
5828 configSetProperties(pConsole->m_pVMMDev,
5829 (void *)papszNames,
5830 (void *)papszValues,
5831 (void *)pai64Timestamps,
5832 (void *)papszFlags);
5833 for (unsigned i = 0; i < cProps; ++i)
5834 {
5835 RTStrFree(papszNames[i]);
5836 if (valuesOut[i])
5837 RTStrFree(papszValues[i]);
5838 if (flagsOut[i])
5839 RTStrFree(papszFlags[i]);
5840 }
5841 }
5842 else
5843 rc = VERR_NO_MEMORY;
5844 RTMemTmpFree(papszNames);
5845 RTMemTmpFree(papszValues);
5846 RTMemTmpFree(pai64Timestamps);
5847 RTMemTmpFree(papszFlags);
5848 AssertRCReturn(rc, rc);
5849
5850 /*
5851 * These properties have to be set before pulling over the properties
5852 * from the machine XML, to ensure that properties saved in the XML
5853 * will override them.
5854 */
5855 /* Set the raw VBox version string as a guest property. Used for host/guest
5856 * version comparison. */
5857 configSetProperty(pConsole->m_pVMMDev, "/VirtualBox/HostInfo/VBoxVer",
5858 VBOX_VERSION_STRING_RAW, "TRANSIENT, RDONLYGUEST");
5859 /* Set the full VBox version string as a guest property. Can contain vendor-specific
5860 * information/branding and/or pre-release tags. */
5861 configSetProperty(pConsole->m_pVMMDev, "/VirtualBox/HostInfo/VBoxVerExt",
5862 VBOX_VERSION_STRING, "TRANSIENT, RDONLYGUEST");
5863 /* Set the VBox SVN revision as a guest property */
5864 configSetProperty(pConsole->m_pVMMDev, "/VirtualBox/HostInfo/VBoxRev",
5865 RTBldCfgRevisionStr(), "TRANSIENT, RDONLYGUEST");
5866
5867 /*
5868 * Register the host notification callback
5869 */
5870 HGCMSVCEXTHANDLE hDummy;
5871 HGCMHostRegisterServiceExtension(&hDummy, "VBoxGuestPropSvc",
5872 Console::i_doGuestPropNotification,
5873 pvConsole);
5874
5875#ifdef VBOX_WITH_GUEST_PROPS_RDONLY_GUEST
5876 rc = configSetGlobalPropertyFlags(pConsole->m_pVMMDev,
5877 guestProp::RDONLYGUEST);
5878 AssertRCReturn(rc, rc);
5879#endif
5880
5881 Log(("Set VBoxGuestPropSvc property store\n"));
5882 }
5883 return VINF_SUCCESS;
5884#else /* !VBOX_WITH_GUEST_PROPS */
5885 return VERR_NOT_SUPPORTED;
5886#endif /* !VBOX_WITH_GUEST_PROPS */
5887}
5888
5889/**
5890 * Set up the Guest Control service.
5891 */
5892/* static */ int Console::i_configGuestControl(void *pvConsole)
5893{
5894#ifdef VBOX_WITH_GUEST_CONTROL
5895 AssertReturn(pvConsole, VERR_INVALID_POINTER);
5896 ComObjPtr<Console> pConsole = static_cast<Console *>(pvConsole);
5897
5898 /* Load the service */
5899 int rc = pConsole->m_pVMMDev->hgcmLoadService("VBoxGuestControlSvc", "VBoxGuestControlSvc");
5900
5901 if (RT_FAILURE(rc))
5902 {
5903 LogRel(("VBoxGuestControlSvc is not available. rc = %Rrc\n", rc));
5904 /* That is not a fatal failure. */
5905 rc = VINF_SUCCESS;
5906 }
5907 else
5908 {
5909 HGCMSVCEXTHANDLE hDummy;
5910 rc = HGCMHostRegisterServiceExtension(&hDummy, "VBoxGuestControlSvc",
5911 &Guest::i_notifyCtrlDispatcher,
5912 pConsole->i_getGuest());
5913 if (RT_FAILURE(rc))
5914 Log(("Cannot register VBoxGuestControlSvc extension!\n"));
5915 else
5916 LogRel(("Guest Control service loaded\n"));
5917 }
5918
5919 return rc;
5920#else /* !VBOX_WITH_GUEST_CONTROL */
5921 return VERR_NOT_SUPPORTED;
5922#endif /* !VBOX_WITH_GUEST_CONTROL */
5923}
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