VirtualBox

source: vbox/trunk/src/VBox/Main/src-server/HostImpl.cpp@ 57415

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

Main: build fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 116.3 KB
Line 
1/* $Id: HostImpl.cpp 56615 2015-06-24 09:26:53Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation: Host
4 */
5
6/*
7 * Copyright (C) 2004-2015 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#define __STDC_LIMIT_MACROS
19#define __STDC_CONSTANT_MACROS
20
21// for some reason Windows burns in sdk\...\winsock.h if this isn't included first
22#include "VBox/com/ptr.h"
23
24#include "HostImpl.h"
25
26#ifdef VBOX_WITH_USB
27# include "HostUSBDeviceImpl.h"
28# include "USBDeviceFilterImpl.h"
29# include "USBProxyService.h"
30#else
31# include "VirtualBoxImpl.h"
32#endif // VBOX_WITH_USB
33
34#include "HostNetworkInterfaceImpl.h"
35#include "HostVideoInputDeviceImpl.h"
36#include "MachineImpl.h"
37#include "AutoCaller.h"
38#include "Logging.h"
39#include "Performance.h"
40
41#include "MediumImpl.h"
42#include "HostPower.h"
43
44#if defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD)
45# include <HostHardwareLinux.h>
46#endif
47
48#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
49# include <set>
50#endif
51
52#ifdef VBOX_WITH_RESOURCE_USAGE_API
53# include "PerformanceImpl.h"
54#endif /* VBOX_WITH_RESOURCE_USAGE_API */
55
56#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
57# include <VBox/VBoxNetCfg-win.h>
58#endif /* #if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT) */
59
60#if defined(RT_OS_DARWIN) && ARCH_BITS == 32
61# include <sys/types.h>
62# include <sys/sysctl.h>
63#endif
64
65#ifdef RT_OS_LINUX
66# include <sys/ioctl.h>
67# include <errno.h>
68# include <net/if.h>
69# include <net/if_arp.h>
70#endif /* RT_OS_LINUX */
71
72#ifdef RT_OS_SOLARIS
73# include <fcntl.h>
74# include <unistd.h>
75# include <stropts.h>
76# include <errno.h>
77# include <limits.h>
78# include <stdio.h>
79# include <libdevinfo.h>
80# include <sys/mkdev.h>
81# include <sys/scsi/generic/inquiry.h>
82# include <net/if.h>
83# include <sys/socket.h>
84# include <sys/sockio.h>
85# include <net/if_arp.h>
86# include <net/if.h>
87# include <sys/types.h>
88# include <sys/stat.h>
89# include <sys/cdio.h>
90# include <sys/dkio.h>
91# include <sys/mnttab.h>
92# include <sys/mntent.h>
93/* Dynamic loading of libhal on Solaris hosts */
94# ifdef VBOX_USE_LIBHAL
95# include "vbox-libhal.h"
96extern "C" char *getfullrawname(char *);
97# endif
98# include "solaris/DynLoadLibSolaris.h"
99
100/**
101 * Solaris DVD drive list as returned by getDVDInfoFromDevTree().
102 */
103typedef struct SOLARISDVD
104{
105 struct SOLARISDVD *pNext;
106 char szDescription[512];
107 char szRawDiskPath[PATH_MAX];
108} SOLARISDVD;
109/** Pointer to a Solaris DVD descriptor. */
110typedef SOLARISDVD *PSOLARISDVD;
111
112
113
114#endif /* RT_OS_SOLARIS */
115
116#ifdef RT_OS_WINDOWS
117# define _WIN32_DCOM
118# include <windows.h>
119# include <shellapi.h>
120# define INITGUID
121# include <guiddef.h>
122# include <devguid.h>
123# include <objbase.h>
124//# include <setupapi.h>
125# include <shlobj.h>
126# include <cfgmgr32.h>
127
128#endif /* RT_OS_WINDOWS */
129
130#ifdef RT_OS_DARWIN
131# include "darwin/iokit.h"
132#endif
133
134#ifdef VBOX_WITH_CROGL
135#include <VBox/VBoxOGL.h>
136#endif /* VBOX_WITH_CROGL */
137
138#include <iprt/asm-amd64-x86.h>
139#include <iprt/string.h>
140#include <iprt/mp.h>
141#include <iprt/time.h>
142#include <iprt/param.h>
143#include <iprt/env.h>
144#include <iprt/mem.h>
145#include <iprt/system.h>
146#ifndef RT_OS_WINDOWS
147# include <iprt/path.h>
148#endif
149#ifdef RT_OS_SOLARIS
150# include <iprt/ctype.h>
151#endif
152#ifdef VBOX_WITH_HOSTNETIF_API
153# include "netif.h"
154#endif
155
156/* XXX Solaris: definitions in /usr/include/sys/regset.h clash with hm_svm.h */
157#undef DS
158#undef ES
159#undef CS
160#undef SS
161#undef FS
162#undef GS
163
164#include <VBox/usb.h>
165#include <VBox/vmm/hm_svm.h>
166#include <VBox/err.h>
167#include <VBox/settings.h>
168#include <VBox/sup.h>
169#include <iprt/x86.h>
170
171#include "VBox/com/MultiResult.h"
172#include "VBox/com/array.h"
173
174#include <stdio.h>
175
176#include <algorithm>
177#include <string>
178#include <vector>
179
180#include "HostDnsService.h"
181
182////////////////////////////////////////////////////////////////////////////////
183//
184// Host private data definition
185//
186////////////////////////////////////////////////////////////////////////////////
187
188struct Host::Data
189{
190 Data()
191 :
192 fDVDDrivesListBuilt(false),
193 fFloppyDrivesListBuilt(false)
194 {};
195
196 VirtualBox *pParent;
197
198 HostNetworkInterfaceList llNetIfs; // list of network interfaces
199
200#ifdef VBOX_WITH_USB
201 USBDeviceFilterList llChildren; // all USB device filters
202 USBDeviceFilterList llUSBDeviceFilters; // USB device filters in use by the USB proxy service
203
204 /** Pointer to the USBProxyService object. */
205 USBProxyService *pUSBProxyService;
206#endif /* VBOX_WITH_USB */
207
208 // list of host drives; lazily created by getDVDDrives() and getFloppyDrives(),
209 // and protected by the medium tree lock handle (including the bools).
210 MediaList llDVDDrives,
211 llFloppyDrives;
212 bool fDVDDrivesListBuilt,
213 fFloppyDrivesListBuilt;
214
215#if defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD)
216 /** Object with information about host drives */
217 VBoxMainDriveInfo hostDrives;
218#endif
219
220 /** @name Features that can be queried with GetProcessorFeature.
221 * @{ */
222 bool fVTSupported,
223 fLongModeSupported,
224 fPAESupported,
225 fNestedPagingSupported,
226 fRecheckVTSupported;
227
228 /** @} */
229
230 /** 3D hardware acceleration supported? Tristate, -1 meaning not probed. */
231 int f3DAccelerationSupported;
232
233 HostPowerService *pHostPowerService;
234 /** Host's DNS informaton fetching */
235 HostDnsMonitorProxy hostDnsMonitorProxy;
236};
237
238
239////////////////////////////////////////////////////////////////////////////////
240//
241// Constructor / destructor
242//
243////////////////////////////////////////////////////////////////////////////////
244DEFINE_EMPTY_CTOR_DTOR(Host)
245
246HRESULT Host::FinalConstruct()
247{
248 return BaseFinalConstruct();
249}
250
251void Host::FinalRelease()
252{
253 uninit();
254 BaseFinalRelease();
255}
256
257/**
258 * Initializes the host object.
259 *
260 * @param aParent VirtualBox parent object.
261 */
262HRESULT Host::init(VirtualBox *aParent)
263{
264 HRESULT hrc;
265 LogFlowThisFunc(("aParent=%p\n", aParent));
266
267 /* Enclose the state transition NotReady->InInit->Ready */
268 AutoInitSpan autoInitSpan(this);
269 AssertReturn(autoInitSpan.isOk(), E_FAIL);
270
271 m = new Data();
272
273 m->pParent = aParent;
274
275#ifdef VBOX_WITH_USB
276 /*
277 * Create and initialize the USB Proxy Service.
278 */
279# if defined(RT_OS_DARWIN)
280 m->pUSBProxyService = new USBProxyServiceDarwin(this);
281# elif defined(RT_OS_LINUX)
282 m->pUSBProxyService = new USBProxyServiceLinux(this);
283# elif defined(RT_OS_OS2)
284 m->pUSBProxyService = new USBProxyServiceOs2(this);
285# elif defined(RT_OS_SOLARIS)
286 m->pUSBProxyService = new USBProxyServiceSolaris(this);
287# elif defined(RT_OS_WINDOWS)
288 m->pUSBProxyService = new USBProxyServiceWindows(this);
289# elif defined(RT_OS_FREEBSD)
290 m->pUSBProxyService = new USBProxyServiceFreeBSD(this);
291# else
292 m->pUSBProxyService = new USBProxyService(this);
293# endif
294 hrc = m->pUSBProxyService->init();
295 AssertComRCReturn(hrc, hrc);
296#endif /* VBOX_WITH_USB */
297
298#ifdef VBOX_WITH_RESOURCE_USAGE_API
299 i_registerMetrics(aParent->i_performanceCollector());
300#endif /* VBOX_WITH_RESOURCE_USAGE_API */
301 /* Create the list of network interfaces so their metrics get registered. */
302 i_updateNetIfList();
303
304 m->hostDnsMonitorProxy.init(HostDnsMonitor::getHostDnsMonitor(m->pParent), m->pParent);
305
306#if defined(RT_OS_WINDOWS)
307 m->pHostPowerService = new HostPowerServiceWin(m->pParent);
308#elif defined(RT_OS_LINUX) && defined(VBOX_WITH_DBUS)
309 m->pHostPowerService = new HostPowerServiceLinux(m->pParent);
310#elif defined(RT_OS_DARWIN)
311 m->pHostPowerService = new HostPowerServiceDarwin(m->pParent);
312#else
313 m->pHostPowerService = new HostPowerService(m->pParent);
314#endif
315
316 /* Cache the features reported by GetProcessorFeature. */
317 m->fVTSupported = false;
318 m->fLongModeSupported = false;
319 m->fPAESupported = false;
320 m->fNestedPagingSupported = false;
321 m->fRecheckVTSupported = false;
322
323 if (ASMHasCpuId())
324 {
325 /* Note! This code is duplicated in SUPDrv.c and other places! */
326 uint32_t uMaxId, uVendorEBX, uVendorECX, uVendorEDX;
327 ASMCpuId(0, &uMaxId, &uVendorEBX, &uVendorECX, &uVendorEDX);
328 if (ASMIsValidStdRange(uMaxId))
329 {
330 /* PAE? */
331 uint32_t uDummy, fFeaturesEcx, fFeaturesEdx;
332 ASMCpuId(1, &uDummy, &uDummy, &fFeaturesEcx, &fFeaturesEdx);
333 m->fPAESupported = RT_BOOL(fFeaturesEdx & X86_CPUID_FEATURE_EDX_PAE);
334
335 /* Long Mode? */
336 uint32_t uExtMaxId, fExtFeaturesEcx, fExtFeaturesEdx;
337 ASMCpuId(0x80000000, &uExtMaxId, &uDummy, &uDummy, &uDummy);
338 ASMCpuId(0x80000001, &uDummy, &uDummy, &fExtFeaturesEcx, &fExtFeaturesEdx);
339 m->fLongModeSupported = ASMIsValidExtRange(uExtMaxId)
340 && (fExtFeaturesEdx & X86_CPUID_EXT_FEATURE_EDX_LONG_MODE);
341
342#if defined(RT_OS_DARWIN) && ARCH_BITS == 32 /* darwin.x86 has some optimizations of 64-bit on 32-bit. */
343 int f64bitCapable = 0;
344 size_t cbParameter = sizeof(f64bitCapable);
345 if (sysctlbyname("hw.cpu64bit_capable", &f64bitCapable, &cbParameter, NULL, NULL) != -1)
346 m->fLongModeSupported = f64bitCapable != 0;
347#endif
348
349 /* VT-x? */
350 if ( ASMIsIntelCpuEx(uVendorEBX, uVendorECX, uVendorEDX)
351 || ASMIsViaCentaurCpuEx(uVendorEBX, uVendorECX, uVendorEDX))
352 {
353 if ( (fFeaturesEcx & X86_CPUID_FEATURE_ECX_VMX)
354 && (fFeaturesEdx & X86_CPUID_FEATURE_EDX_MSR)
355 && (fFeaturesEdx & X86_CPUID_FEATURE_EDX_FXSR)
356 )
357 {
358 int rc = SUPR3QueryVTxSupported();
359 if (RT_SUCCESS(rc))
360 m->fVTSupported = true;
361 }
362 }
363 /* AMD-V */
364 else if (ASMIsAmdCpuEx(uVendorEBX, uVendorECX, uVendorEDX))
365 {
366 if ( (fExtFeaturesEcx & X86_CPUID_AMD_FEATURE_ECX_SVM)
367 && (fFeaturesEdx & X86_CPUID_FEATURE_EDX_MSR)
368 && (fFeaturesEdx & X86_CPUID_FEATURE_EDX_FXSR)
369 && ASMIsValidExtRange(uExtMaxId)
370 )
371 {
372 m->fVTSupported = true;
373
374 /* Query AMD features. */
375 if (uExtMaxId >= 0x8000000a)
376 {
377 uint32_t fSVMFeaturesEdx;
378 ASMCpuId(0x8000000a, &uDummy, &uDummy, &uDummy, &fSVMFeaturesEdx);
379 if (fSVMFeaturesEdx & AMD_CPUID_SVM_FEATURE_EDX_NESTED_PAGING)
380 m->fNestedPagingSupported = true;
381 }
382 }
383 }
384 }
385 }
386
387 /* Check with SUPDrv if VT-x and AMD-V are really supported (may fail). */
388 if (m->fVTSupported)
389 {
390 int rc = SUPR3InitEx(false /*fUnrestricted*/, NULL);
391 if (RT_SUCCESS(rc))
392 {
393 uint32_t fVTCaps;
394 rc = SUPR3QueryVTCaps(&fVTCaps);
395 if (RT_SUCCESS(rc))
396 {
397 Assert(fVTCaps & (SUPVTCAPS_AMD_V | SUPVTCAPS_VT_X));
398 if (fVTCaps & SUPVTCAPS_NESTED_PAGING)
399 m->fNestedPagingSupported = true;
400 else
401 Assert(m->fNestedPagingSupported == false);
402 }
403 else
404 {
405 LogRel(("SUPR0QueryVTCaps -> %Rrc\n", rc));
406 m->fVTSupported = m->fNestedPagingSupported = false;
407 }
408 rc = SUPR3Term(false);
409 AssertRC(rc);
410 }
411 else
412 m->fRecheckVTSupported = true; /* Try again later when the driver is loaded. */
413 }
414
415#ifdef VBOX_WITH_CROGL
416 /* Test for 3D hardware acceleration support later when (if ever) need. */
417 m->f3DAccelerationSupported = -1;
418#else
419 m->f3DAccelerationSupported = false;
420#endif
421
422#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
423 /* Extract the list of configured host-only interfaces */
424 std::set<Utf8Str> aConfiguredNames;
425 SafeArray<BSTR> aGlobalExtraDataKeys;
426 hrc = aParent->GetExtraDataKeys(ComSafeArrayAsOutParam(aGlobalExtraDataKeys));
427 AssertMsg(SUCCEEDED(hrc), ("VirtualBox::GetExtraDataKeys failed with %Rhrc\n", hrc));
428 for (size_t i = 0; i < aGlobalExtraDataKeys.size(); ++i)
429 {
430 Utf8Str strKey = aGlobalExtraDataKeys[i];
431
432 if (!strKey.startsWith("HostOnly/vboxnet"))
433 continue;
434
435 size_t pos = strKey.find("/", sizeof("HostOnly/vboxnet"));
436 if (pos != Utf8Str::npos)
437 aConfiguredNames.insert(strKey.substr(sizeof("HostOnly"),
438 pos - sizeof("HostOnly")));
439 }
440
441 for (std::set<Utf8Str>::const_iterator it = aConfiguredNames.begin();
442 it != aConfiguredNames.end();
443 ++it)
444 {
445 ComPtr<IHostNetworkInterface> hif;
446 ComPtr<IProgress> progress;
447
448 int r = NetIfCreateHostOnlyNetworkInterface(m->pParent,
449 hif.asOutParam(),
450 progress.asOutParam(),
451 it->c_str());
452 if (RT_FAILURE(r))
453 LogRel(("failed to create %s, error (0x%x)\n", it->c_str(), r));
454 }
455
456#endif /* defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD) */
457
458 /* Confirm a successful initialization */
459 autoInitSpan.setSucceeded();
460
461 return S_OK;
462}
463
464/**
465 * Uninitializes the host object and sets the ready flag to FALSE.
466 * Called either from FinalRelease() or by the parent when it gets destroyed.
467 */
468void Host::uninit()
469{
470 LogFlowThisFunc(("\n"));
471
472 /* Enclose the state transition Ready->InUninit->NotReady */
473 AutoUninitSpan autoUninitSpan(this);
474 if (autoUninitSpan.uninitDone())
475 return;
476
477#ifdef VBOX_WITH_RESOURCE_USAGE_API
478 PerformanceCollector *aCollector = m->pParent->i_performanceCollector();
479 i_unregisterMetrics(aCollector);
480#endif /* VBOX_WITH_RESOURCE_USAGE_API */
481 /*
482 * Note that unregisterMetrics() has unregistered all metrics associated
483 * with Host including network interface ones. We can destroy network
484 * interface objects now. Don't forget the uninit call, otherwise this
485 * causes a race with crashing API clients getting their stale references
486 * cleaned up and VirtualBox shutting down.
487 */
488 while (!m->llNetIfs.empty())
489 {
490 ComObjPtr<HostNetworkInterface> &pNet = m->llNetIfs.front();
491 pNet->uninit();
492 m->llNetIfs.pop_front();
493 }
494
495#ifdef VBOX_WITH_USB
496 /* wait for USB proxy service to terminate before we uninit all USB
497 * devices */
498 LogFlowThisFunc(("Stopping USB proxy service...\n"));
499 delete m->pUSBProxyService;
500 m->pUSBProxyService = NULL;
501 LogFlowThisFunc(("Done stopping USB proxy service.\n"));
502#endif
503
504 delete m->pHostPowerService;
505
506#ifdef VBOX_WITH_USB
507 /* uninit all USB device filters still referenced by clients
508 * Note! HostUSBDeviceFilter::uninit() will modify llChildren.
509 * This list should be already empty, but better be safe than sorry. */
510 while (!m->llChildren.empty())
511 {
512 ComObjPtr<HostUSBDeviceFilter> &pChild = m->llChildren.front();
513 pChild->uninit();
514 m->llChildren.pop_front();
515 }
516
517 /* No need to uninit these, as either Machine::uninit() or the above loop
518 * already covered them all. Subset of llChildren. */
519 m->llUSBDeviceFilters.clear();
520#endif
521
522 /* uninit all host DVD medium objects */
523 while (!m->llDVDDrives.empty())
524 {
525 ComObjPtr<Medium> &pMedium = m->llDVDDrives.front();
526 pMedium->uninit();
527 m->llDVDDrives.pop_front();
528 }
529 /* uninit all host floppy medium objects */
530 while (!m->llFloppyDrives.empty())
531 {
532 ComObjPtr<Medium> &pMedium = m->llFloppyDrives.front();
533 pMedium->uninit();
534 m->llFloppyDrives.pop_front();
535 }
536
537 delete m;
538 m = NULL;
539}
540
541////////////////////////////////////////////////////////////////////////////////
542//
543// IHost public methods
544//
545////////////////////////////////////////////////////////////////////////////////
546
547/**
548 * Returns a list of host DVD drives.
549 *
550 * @returns COM status code
551 * @param drives address of result pointer
552 */
553
554HRESULT Host::getDVDDrives(std::vector<ComPtr<IMedium> > &aDVDDrives)
555{
556 AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
557
558 MediaList *pList;
559 HRESULT rc = i_getDrives(DeviceType_DVD, true /* fRefresh */, pList, treeLock);
560 if (FAILED(rc))
561 return rc;
562
563 aDVDDrives.resize(pList->size());
564 size_t i = 0;
565 for (MediaList::const_iterator it = pList->begin(); it != pList->end(); ++it, ++i)
566 (*it).queryInterfaceTo(aDVDDrives[i].asOutParam());
567
568 return S_OK;
569}
570
571/**
572 * Returns a list of host floppy drives.
573 *
574 * @returns COM status code
575 * @param drives address of result pointer
576 */
577HRESULT Host::getFloppyDrives(std::vector<ComPtr<IMedium> > &aFloppyDrives)
578{
579 AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
580
581 MediaList *pList;
582 HRESULT rc = i_getDrives(DeviceType_Floppy, true /* fRefresh */, pList, treeLock);
583 if (FAILED(rc))
584 return rc;
585
586 aFloppyDrives.resize(pList->size());
587 size_t i = 0;
588 for (MediaList::const_iterator it = pList->begin(); it != pList->end(); ++it, ++i)
589 (*it).queryInterfaceTo(aFloppyDrives[i].asOutParam());
590
591 return S_OK;
592}
593
594
595#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
596# define VBOX_APP_NAME L"VirtualBox"
597
598static int vboxNetWinAddComponent(std::list< ComObjPtr<HostNetworkInterface> > *pPist,
599 INetCfgComponent *pncc)
600{
601 LPWSTR lpszName;
602 GUID IfGuid;
603 HRESULT hr;
604 int rc = VERR_GENERAL_FAILURE;
605
606 hr = pncc->GetDisplayName(&lpszName);
607 Assert(hr == S_OK);
608 if (hr == S_OK)
609 {
610 Bstr name((CBSTR)lpszName);
611
612 hr = pncc->GetInstanceGuid(&IfGuid);
613 Assert(hr == S_OK);
614 if (hr == S_OK)
615 {
616 /* create a new object and add it to the list */
617 ComObjPtr<HostNetworkInterface> iface;
618 iface.createObject();
619 /* remove the curly bracket at the end */
620 if (SUCCEEDED(iface->init(name, name, Guid(IfGuid), HostNetworkInterfaceType_Bridged)))
621 {
622// iface->setVirtualBox(m->pParent);
623 pPist->push_back(iface);
624 rc = VINF_SUCCESS;
625 }
626 else
627 {
628 Assert(0);
629 }
630 }
631 CoTaskMemFree(lpszName);
632 }
633
634 return rc;
635}
636#endif /* defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT) */
637
638/**
639 * Returns a list of host network interfaces.
640 *
641 * @returns COM status code
642 * @param drives address of result pointer
643 */
644HRESULT Host::getNetworkInterfaces(std::vector<ComPtr<IHostNetworkInterface> > &aNetworkInterfaces)
645{
646#if defined(RT_OS_WINDOWS) || defined(VBOX_WITH_NETFLT) /*|| defined(RT_OS_OS2)*/
647# ifdef VBOX_WITH_HOSTNETIF_API
648 HRESULT rc = i_updateNetIfList();
649 if (FAILED(rc))
650 {
651 Log(("Failed to update host network interface list with rc=%Rhrc\n", rc));
652 return rc;
653 }
654
655 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
656
657 aNetworkInterfaces.resize(m->llNetIfs.size());
658 size_t i = 0;
659 for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it, ++i)
660 (*it).queryInterfaceTo(aNetworkInterfaces[i].asOutParam());
661
662 return S_OK;
663# else
664 std::list<ComObjPtr<HostNetworkInterface> > list;
665
666# if defined(RT_OS_DARWIN)
667 PDARWINETHERNIC pEtherNICs = DarwinGetEthernetControllers();
668 while (pEtherNICs)
669 {
670 ComObjPtr<HostNetworkInterface> IfObj;
671 IfObj.createObject();
672 if (SUCCEEDED(IfObj->init(Bstr(pEtherNICs->szName), Guid(pEtherNICs->Uuid), HostNetworkInterfaceType_Bridged)))
673 list.push_back(IfObj);
674
675 /* next, free current */
676 void *pvFree = pEtherNICs;
677 pEtherNICs = pEtherNICs->pNext;
678 RTMemFree(pvFree);
679 }
680
681# elif defined RT_OS_WINDOWS
682# ifndef VBOX_WITH_NETFLT
683 hr = E_NOTIMPL;
684# else /* # if defined VBOX_WITH_NETFLT */
685 INetCfg *pNc;
686 INetCfgComponent *pMpNcc;
687 INetCfgComponent *pTcpIpNcc;
688 LPWSTR lpszApp;
689 HRESULT hr;
690 IEnumNetCfgBindingPath *pEnumBp;
691 INetCfgBindingPath *pBp;
692 IEnumNetCfgBindingInterface *pEnumBi;
693 INetCfgBindingInterface *pBi;
694
695 /* we are using the INetCfg API for getting the list of miniports */
696 hr = VBoxNetCfgWinQueryINetCfg(FALSE,
697 VBOX_APP_NAME,
698 &pNc,
699 &lpszApp);
700 Assert(hr == S_OK);
701 if (hr == S_OK)
702 {
703# ifdef VBOX_NETFLT_ONDEMAND_BIND
704 /* for the protocol-based approach for now we just get all miniports the MS_TCPIP protocol binds to */
705 hr = pNc->FindComponent(L"MS_TCPIP", &pTcpIpNcc);
706# else
707 /* for the filter-based approach we get all miniports our filter (oracle_VBoxNetLwf)is bound to */
708 hr = pNc->FindComponent(L"oracle_VBoxNetLwf", &pTcpIpNcc);
709 if (hr != S_OK)
710 {
711 /* fall back to NDIS5 miniport lookup (sun_VBoxNetFlt) */
712 hr = pNc->FindComponent(L"sun_VBoxNetFlt", &pTcpIpNcc);
713 }
714# ifndef VBOX_WITH_HARDENING
715 if (hr != S_OK)
716 {
717 /* TODO: try to install the netflt from here */
718 }
719# endif
720
721# endif
722
723 if (hr == S_OK)
724 {
725 hr = VBoxNetCfgWinGetBindingPathEnum(pTcpIpNcc, EBP_BELOW, &pEnumBp);
726 Assert(hr == S_OK);
727 if (hr == S_OK)
728 {
729 hr = VBoxNetCfgWinGetFirstBindingPath(pEnumBp, &pBp);
730 Assert(hr == S_OK || hr == S_FALSE);
731 while (hr == S_OK)
732 {
733 /* S_OK == enabled, S_FALSE == disabled */
734 if (pBp->IsEnabled() == S_OK)
735 {
736 hr = VBoxNetCfgWinGetBindingInterfaceEnum(pBp, &pEnumBi);
737 Assert(hr == S_OK);
738 if (hr == S_OK)
739 {
740 hr = VBoxNetCfgWinGetFirstBindingInterface(pEnumBi, &pBi);
741 Assert(hr == S_OK);
742 while (hr == S_OK)
743 {
744 hr = pBi->GetLowerComponent(&pMpNcc);
745 Assert(hr == S_OK);
746 if (hr == S_OK)
747 {
748 ULONG uComponentStatus;
749 hr = pMpNcc->GetDeviceStatus(&uComponentStatus);
750 Assert(hr == S_OK);
751 if (hr == S_OK)
752 {
753 if (uComponentStatus == 0)
754 {
755 vboxNetWinAddComponent(&list, pMpNcc);
756 }
757 }
758 VBoxNetCfgWinReleaseRef(pMpNcc);
759 }
760 VBoxNetCfgWinReleaseRef(pBi);
761
762 hr = VBoxNetCfgWinGetNextBindingInterface(pEnumBi, &pBi);
763 }
764 VBoxNetCfgWinReleaseRef(pEnumBi);
765 }
766 }
767 VBoxNetCfgWinReleaseRef(pBp);
768
769 hr = VBoxNetCfgWinGetNextBindingPath(pEnumBp, &pBp);
770 }
771 VBoxNetCfgWinReleaseRef(pEnumBp);
772 }
773 VBoxNetCfgWinReleaseRef(pTcpIpNcc);
774 }
775 else
776 {
777 LogRel(("failed to get the oracle_VBoxNetLwf(sun_VBoxNetFlt) component, error (0x%x)\n", hr));
778 }
779
780 VBoxNetCfgWinReleaseINetCfg(pNc, FALSE);
781 }
782# endif /* # if defined VBOX_WITH_NETFLT */
783
784
785# elif defined RT_OS_LINUX
786 int sock = socket(AF_INET, SOCK_DGRAM, 0);
787 if (sock >= 0)
788 {
789 char pBuffer[2048];
790 struct ifconf ifConf;
791 ifConf.ifc_len = sizeof(pBuffer);
792 ifConf.ifc_buf = pBuffer;
793 if (ioctl(sock, SIOCGIFCONF, &ifConf) >= 0)
794 {
795 for (struct ifreq *pReq = ifConf.ifc_req; (char*)pReq < pBuffer + ifConf.ifc_len; pReq++)
796 {
797 if (ioctl(sock, SIOCGIFHWADDR, pReq) >= 0)
798 {
799 if (pReq->ifr_hwaddr.sa_family == ARPHRD_ETHER)
800 {
801 RTUUID uuid;
802 Assert(sizeof(uuid) <= sizeof(*pReq));
803 memcpy(&uuid, pReq, sizeof(uuid));
804
805 ComObjPtr<HostNetworkInterface> IfObj;
806 IfObj.createObject();
807 if (SUCCEEDED(IfObj->init(Bstr(pReq->ifr_name), Guid(uuid), HostNetworkInterfaceType_Bridged)))
808 list.push_back(IfObj);
809 }
810 }
811 }
812 }
813 close(sock);
814 }
815# endif /* RT_OS_LINUX */
816
817 aNetworkInterfaces.resize(list.size());
818 size_t i = 0;
819 for (std::list<ComObjPtr<HostNetworkInterface> >::const_iterator it = list.begin(); it != list.end(); ++it, ++i)
820 aNetworkInterfaces[i] = *it;
821
822 return S_OK;
823# endif
824#else
825 /* Not implemented / supported on this platform. */
826 ReturnComNotImplemented();
827#endif
828}
829
830HRESULT Host::getUSBDevices(std::vector<ComPtr<IHostUSBDevice> > &aUSBDevices)
831{
832#ifdef VBOX_WITH_USB
833 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
834
835 MultiResult rc = i_checkUSBProxyService();
836 if (FAILED(rc))
837 return rc;
838
839 return m->pUSBProxyService->getDeviceCollection(aUSBDevices);
840#else
841 /* Note: The GUI depends on this method returning E_NOTIMPL with no
842 * extended error info to indicate that USB is simply not available
843 * (w/o treating it as a failure), for example, as in OSE. */
844 NOREF(aUSBDevices);
845# ifndef RT_OS_WINDOWS
846 NOREF(aUSBDevices);
847# endif
848 ReturnComNotImplemented();
849#endif
850}
851
852/**
853 * This method return the list of registered name servers
854 */
855HRESULT Host::getNameServers(std::vector<com::Utf8Str> &aNameServers)
856{
857 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
858 return m->hostDnsMonitorProxy.GetNameServers(aNameServers);
859}
860
861
862/**
863 * This method returns the domain name of the host
864 */
865HRESULT Host::getDomainName(com::Utf8Str &aDomainName)
866{
867 /* XXX: note here should be synchronization with thread polling state
868 * changes in name resoving system on host */
869 return m->hostDnsMonitorProxy.GetDomainName(&aDomainName);
870}
871
872
873/**
874 * This method returns the search string.
875 */
876HRESULT Host::getSearchStrings(std::vector<com::Utf8Str> &aSearchStrings)
877{
878 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
879 return m->hostDnsMonitorProxy.GetSearchStrings(aSearchStrings);
880}
881
882HRESULT Host::getUSBDeviceFilters(std::vector<ComPtr<IHostUSBDeviceFilter> > &aUSBDeviceFilters)
883{
884#ifdef VBOX_WITH_USB
885 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
886
887 MultiResult rc = i_checkUSBProxyService();
888 if (FAILED(rc))
889 return rc;
890
891 aUSBDeviceFilters.resize(m->llUSBDeviceFilters.size());
892 size_t i = 0;
893 for (USBDeviceFilterList::iterator it = m->llUSBDeviceFilters.begin(); it != m->llUSBDeviceFilters.end(); ++it, ++i)
894 (*it).queryInterfaceTo(aUSBDeviceFilters[i].asOutParam());
895
896 return rc;
897#else
898 /* Note: The GUI depends on this method returning E_NOTIMPL with no
899 * extended error info to indicate that USB is simply not available
900 * (w/o treating it as a failure), for example, as in OSE. */
901 NOREF(aUSBDeviceFilters);
902# ifndef RT_OS_WINDOWS
903 NOREF(aUSBDeviceFilters);
904# endif
905 ReturnComNotImplemented();
906#endif
907}
908
909/**
910 * Returns the number of installed logical processors
911 *
912 * @returns COM status code
913 * @param count address of result variable
914 */
915
916HRESULT Host::getProcessorCount(ULONG *aCount)
917{
918 // no locking required
919
920 *aCount = RTMpGetPresentCount();
921 return S_OK;
922}
923
924/**
925 * Returns the number of online logical processors
926 *
927 * @returns COM status code
928 * @param count address of result variable
929 */
930HRESULT Host::getProcessorOnlineCount(ULONG *aCount)
931{
932 // no locking required
933
934 *aCount = RTMpGetOnlineCount();
935 return S_OK;
936}
937
938/**
939 * Returns the number of installed physical processor cores.
940 *
941 * @returns COM status code
942 * @param count address of result variable
943 */
944HRESULT Host::getProcessorCoreCount(ULONG *aCount)
945{
946 // no locking required
947
948 *aCount = RTMpGetPresentCoreCount();
949 return S_OK;
950}
951
952/**
953 * Returns the number of installed physical processor cores.
954 *
955 * @returns COM status code
956 * @param count address of result variable
957 */
958HRESULT Host::getProcessorOnlineCoreCount(ULONG *aCount)
959{
960 // no locking required
961
962 *aCount = RTMpGetOnlineCoreCount();
963 return S_OK;
964}
965
966/**
967 * Returns the (approximate) maximum speed of the given host CPU in MHz
968 *
969 * @returns COM status code
970 * @param cpu id to get info for.
971 * @param speed address of result variable, speed is 0 if unknown or aCpuId is invalid.
972 */
973HRESULT Host::getProcessorSpeed(ULONG aCpuId,
974 ULONG *aSpeed)
975{
976 // no locking required
977
978 *aSpeed = RTMpGetMaxFrequency(aCpuId);
979 return S_OK;
980}
981
982/**
983 * Returns a description string for the host CPU
984 *
985 * @returns COM status code
986 * @param cpu id to get info for.
987 * @param description address of result variable, empty string if not known or aCpuId is invalid.
988 */
989HRESULT Host::getProcessorDescription(ULONG aCpuId, com::Utf8Str &aDescription)
990{
991 // no locking required
992
993 char szCPUModel[80];
994 szCPUModel[0] = 0;
995 int vrc = RTMpGetDescription(aCpuId, szCPUModel, sizeof(szCPUModel));
996 if (RT_FAILURE(vrc))
997 return E_FAIL; /** @todo error reporting? */
998
999 aDescription = Utf8Str(szCPUModel);
1000
1001 return S_OK;
1002}
1003
1004/**
1005 * Returns whether a host processor feature is supported or not
1006 *
1007 * @returns COM status code
1008 * @param Feature to query.
1009 * @param address of supported bool result variable
1010 */
1011HRESULT Host::getProcessorFeature(ProcessorFeature_T aFeature, BOOL *aSupported)
1012{
1013 /* Validate input. */
1014 switch (aFeature)
1015 {
1016 case ProcessorFeature_HWVirtEx:
1017 case ProcessorFeature_PAE:
1018 case ProcessorFeature_LongMode:
1019 case ProcessorFeature_NestedPaging:
1020 break;
1021 default:
1022 return setError(E_INVALIDARG, tr("The aFeature value %d (%#x) is out of range."), (int)aFeature, (int)aFeature);
1023 }
1024
1025 /* Do the job. */
1026 AutoCaller autoCaller(this);
1027 HRESULT hrc = autoCaller.rc();
1028 if (SUCCEEDED(hrc))
1029 {
1030 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1031
1032 if ( m->fRecheckVTSupported
1033 && ( aFeature == ProcessorFeature_HWVirtEx
1034 || aFeature == ProcessorFeature_NestedPaging)
1035 )
1036 {
1037 alock.release();
1038
1039 /* Perhaps the driver is available now... */
1040 int rc = SUPR3InitEx(false /*fUnrestricted*/, NULL);
1041 if (RT_SUCCESS(rc))
1042 {
1043 uint32_t fVTCaps;
1044 rc = SUPR3QueryVTCaps(&fVTCaps);
1045
1046 AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);
1047 if (RT_SUCCESS(rc))
1048 {
1049 Assert(fVTCaps & (SUPVTCAPS_AMD_V | SUPVTCAPS_VT_X));
1050 if (fVTCaps & SUPVTCAPS_NESTED_PAGING)
1051 m->fNestedPagingSupported = true;
1052 else
1053 Assert(m->fNestedPagingSupported == false);
1054 }
1055 else
1056 {
1057 LogRel(("SUPR0QueryVTCaps -> %Rrc\n", rc));
1058 m->fVTSupported = m->fNestedPagingSupported = true;
1059 }
1060 rc = SUPR3Term(false);
1061 AssertRC(rc);
1062 m->fRecheckVTSupported = false; /* No need to try again, we cached everything. */
1063 }
1064
1065 alock.acquire();
1066 }
1067
1068 switch (aFeature)
1069 {
1070 case ProcessorFeature_HWVirtEx:
1071 *aSupported = m->fVTSupported;
1072 break;
1073
1074 case ProcessorFeature_PAE:
1075 *aSupported = m->fPAESupported;
1076 break;
1077
1078 case ProcessorFeature_LongMode:
1079 *aSupported = m->fLongModeSupported;
1080 break;
1081
1082 case ProcessorFeature_NestedPaging:
1083 *aSupported = m->fNestedPagingSupported;
1084 break;
1085
1086 default:
1087 AssertFailed();
1088 }
1089 }
1090 return hrc;
1091}
1092
1093/**
1094 * Returns the specific CPUID leaf.
1095 *
1096 * @returns COM status code
1097 * @param aCpuId The CPU number. Mostly ignored.
1098 * @param aLeaf The leaf number.
1099 * @param aSubLeaf The sub-leaf number.
1100 * @param aValEAX Where to return EAX.
1101 * @param aValEBX Where to return EBX.
1102 * @param aValECX Where to return ECX.
1103 * @param aValEDX Where to return EDX.
1104 */
1105HRESULT Host::getProcessorCPUIDLeaf(ULONG aCpuId, ULONG aLeaf, ULONG aSubLeaf,
1106 ULONG *aValEAX, ULONG *aValEBX, ULONG *aValECX, ULONG *aValEDX)
1107{
1108 // no locking required
1109
1110 /* Check that the CPU is online. */
1111 /** @todo later use RTMpOnSpecific. */
1112 if (!RTMpIsCpuOnline(aCpuId))
1113 return RTMpIsCpuPresent(aCpuId)
1114 ? setError(E_FAIL, tr("CPU no.%u is not present"), aCpuId)
1115 : setError(E_FAIL, tr("CPU no.%u is not online"), aCpuId);
1116
1117 uint32_t uEAX, uEBX, uECX, uEDX;
1118 ASMCpuId_Idx_ECX(aLeaf, aSubLeaf, &uEAX, &uEBX, &uECX, &uEDX);
1119 *aValEAX = uEAX;
1120 *aValEBX = uEBX;
1121 *aValECX = uECX;
1122 *aValEDX = uEDX;
1123
1124 return S_OK;
1125}
1126
1127/**
1128 * Returns the amount of installed system memory in megabytes
1129 *
1130 * @returns COM status code
1131 * @param size address of result variable
1132 */
1133HRESULT Host::getMemorySize(ULONG *aSize)
1134{
1135 // no locking required
1136
1137 uint64_t cb;
1138 int rc = RTSystemQueryTotalRam(&cb);
1139 if (RT_FAILURE(rc))
1140 return E_FAIL;
1141 *aSize = (ULONG)(cb / _1M);
1142 return S_OK;
1143}
1144
1145/**
1146 * Returns the current system memory free space in megabytes
1147 *
1148 * @returns COM status code
1149 * @param available address of result variable
1150 */
1151HRESULT Host::getMemoryAvailable(ULONG *aAvailable)
1152{
1153 // no locking required
1154
1155 uint64_t cb;
1156 int rc = RTSystemQueryAvailableRam(&cb);
1157 if (RT_FAILURE(rc))
1158 return E_FAIL;
1159 *aAvailable = (ULONG)(cb / _1M);
1160 return S_OK;
1161}
1162
1163/**
1164 * Returns the name string of the host operating system
1165 *
1166 * @returns COM status code
1167 * @param os address of result variable
1168 */
1169HRESULT Host::getOperatingSystem(com::Utf8Str &aOperatingSystem)
1170{
1171 // no locking required
1172
1173 char szOSName[80];
1174 int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szOSName, sizeof(szOSName));
1175 if (RT_FAILURE(vrc))
1176 return E_FAIL; /** @todo error reporting? */
1177 aOperatingSystem = Utf8Str(szOSName);
1178 return S_OK;
1179}
1180
1181/**
1182 * Returns the version string of the host operating system
1183 *
1184 * @returns COM status code
1185 * @param os address of result variable
1186 */
1187HRESULT Host::getOSVersion(com::Utf8Str &aVersion)
1188{
1189 // no locking required
1190
1191 /* Get the OS release. Reserve some buffer space for the service pack. */
1192 char szOSRelease[128];
1193 int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szOSRelease, sizeof(szOSRelease) - 32);
1194 if (RT_FAILURE(vrc))
1195 return E_FAIL; /** @todo error reporting? */
1196
1197 /* Append the service pack if present. */
1198 char szOSServicePack[80];
1199 vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szOSServicePack, sizeof(szOSServicePack));
1200 if (RT_FAILURE(vrc))
1201 {
1202 if (vrc != VERR_NOT_SUPPORTED)
1203 return E_FAIL; /** @todo error reporting? */
1204 szOSServicePack[0] = '\0';
1205 }
1206 if (szOSServicePack[0] != '\0')
1207 {
1208 char *psz = strchr(szOSRelease, '\0');
1209 RTStrPrintf(psz, &szOSRelease[sizeof(szOSRelease)] - psz, "sp%s", szOSServicePack);
1210 }
1211
1212 aVersion = szOSRelease;
1213 return S_OK;
1214}
1215
1216/**
1217 * Returns the current host time in milliseconds since 1970-01-01 UTC.
1218 *
1219 * @returns COM status code
1220 * @param time address of result variable
1221 */
1222HRESULT Host::getUTCTime(LONG64 *aUTCTime)
1223{
1224 // no locking required
1225
1226 RTTIMESPEC now;
1227 *aUTCTime = RTTimeSpecGetMilli(RTTimeNow(&now));
1228
1229 return S_OK;
1230}
1231
1232
1233HRESULT Host::getAcceleration3DAvailable(BOOL *aSupported)
1234{
1235 HRESULT hrc = S_OK;
1236 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1237 if (m->f3DAccelerationSupported != -1)
1238 *aSupported = m->f3DAccelerationSupported;
1239 else
1240 {
1241 alock.release();
1242
1243#ifdef VBOX_WITH_CROGL
1244 bool fSupported = VBoxOglIs3DAccelerationSupported();
1245#else
1246 bool fSupported = false; /* shoudn't get here, but just in case. */
1247#endif
1248 AutoWriteLock alock2(this COMMA_LOCKVAL_SRC_POS);
1249
1250 m->f3DAccelerationSupported = fSupported;
1251 alock2.release();
1252 *aSupported = fSupported;
1253 }
1254
1255#ifdef DEBUG_misha
1256 AssertMsgFailed(("should not be here any more!\n"));
1257#endif
1258
1259 return hrc;
1260}
1261
1262HRESULT Host::createHostOnlyNetworkInterface(ComPtr<IHostNetworkInterface> &aHostInterface,
1263 ComPtr<IProgress> &aProgress)
1264
1265{
1266#ifdef VBOX_WITH_HOSTNETIF_API
1267 /* No need to lock anything. If there ever will - watch out, the function
1268 * called below grabs the VirtualBox lock. */
1269
1270 int r = NetIfCreateHostOnlyNetworkInterface(m->pParent, aHostInterface.asOutParam(), aProgress.asOutParam());
1271 if (RT_SUCCESS(r))
1272 {
1273 if (aHostInterface.isNull())
1274 return setError(E_FAIL,
1275 tr("Unable to create a host network interface"));
1276
1277#if !defined(RT_OS_WINDOWS)
1278 Bstr tmpAddr, tmpMask, tmpName;
1279 HRESULT hrc;
1280 hrc = aHostInterface->COMGETTER(Name)(tmpName.asOutParam());
1281 ComAssertComRCRet(hrc, hrc);
1282 hrc = aHostInterface->COMGETTER(IPAddress)(tmpAddr.asOutParam());
1283 ComAssertComRCRet(hrc, hrc);
1284 hrc = aHostInterface->COMGETTER(NetworkMask)(tmpMask.asOutParam());
1285 ComAssertComRCRet(hrc, hrc);
1286 /*
1287 * We need to write the default IP address and mask to extra data now,
1288 * so the interface gets re-created after vboxnetadp.ko reload.
1289 * Note that we avoid calling EnableStaticIpConfig since it would
1290 * change the address on host's interface as well and we want to
1291 * postpone the change until VM actually starts.
1292 */
1293 hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress",
1294 tmpName.raw()).raw(),
1295 tmpAddr.raw());
1296 ComAssertComRCRet(hrc, hrc);
1297
1298 hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask",
1299 tmpName.raw()).raw(),
1300 tmpMask.raw());
1301 ComAssertComRCRet(hrc, hrc);
1302#endif
1303 }
1304
1305 return S_OK;
1306#else
1307 return E_NOTIMPL;
1308#endif
1309}
1310
1311HRESULT Host::removeHostOnlyNetworkInterface(const com::Guid &aId,
1312 ComPtr<IProgress> &aProgress)
1313
1314{
1315#ifdef VBOX_WITH_HOSTNETIF_API
1316 /* No need to lock anything, the code below does not touch the state
1317 * of the host object. If that ever changes then check for lock order
1318 * violations with the called functions. */
1319
1320 Bstr name;
1321 HRESULT rc;
1322
1323 /* first check whether an interface with the given name already exists */
1324 {
1325 ComPtr<IHostNetworkInterface> iface;
1326 rc = findHostNetworkInterfaceById(aId, iface);
1327 if (FAILED(rc))
1328 return setError(VBOX_E_OBJECT_NOT_FOUND,
1329 tr("Host network interface with UUID {%RTuuid} does not exist"),
1330 Guid(aId).raw());
1331 rc = iface->COMGETTER(Name)(name.asOutParam());
1332 ComAssertComRCRet(rc, rc);
1333 }
1334
1335 int r = NetIfRemoveHostOnlyNetworkInterface(m->pParent, Guid(aId).ref(), aProgress.asOutParam());
1336 if (RT_SUCCESS(r))
1337 {
1338 /* Drop configuration parameters for removed interface */
1339 rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", name.raw()).raw(), NULL);
1340 rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", name.raw()).raw(), NULL);
1341 rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", name.raw()).raw(), NULL);
1342 rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPV6NetMask", name.raw()).raw(), NULL);
1343
1344 return S_OK;
1345 }
1346
1347 return r == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
1348#else
1349 return E_NOTIMPL;
1350#endif
1351}
1352
1353HRESULT Host::createUSBDeviceFilter(const com::Utf8Str &aName,
1354 ComPtr<IHostUSBDeviceFilter> &aFilter)
1355{
1356#ifdef VBOX_WITH_USB
1357
1358 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1359
1360 ComObjPtr<HostUSBDeviceFilter> filter;
1361 filter.createObject();
1362 HRESULT rc = filter->init(this, Bstr(aName).raw());
1363 ComAssertComRCRet(rc, rc);
1364 rc = filter.queryInterfaceTo(aFilter.asOutParam());
1365 AssertComRCReturn(rc, rc);
1366 return S_OK;
1367#else
1368 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1369 * extended error info to indicate that USB is simply not available
1370 * (w/o treating it as a failure), for example, as in OSE. */
1371 NOREF(aName);
1372 NOREF(aFilter);
1373 ReturnComNotImplemented();
1374#endif
1375}
1376
1377HRESULT Host::insertUSBDeviceFilter(ULONG aPosition,
1378 const ComPtr<IHostUSBDeviceFilter> &aFilter)
1379{
1380#ifdef VBOX_WITH_USB
1381 /* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
1382
1383 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1384
1385 MultiResult rc = i_checkUSBProxyService();
1386 if (FAILED(rc))
1387 return rc;
1388
1389 ComObjPtr<HostUSBDeviceFilter> pFilter;
1390 for (USBDeviceFilterList::iterator it = m->llChildren.begin();
1391 it != m->llChildren.end();
1392 ++it)
1393 {
1394 if (*it == aFilter)
1395 {
1396 pFilter = *it;
1397 break;
1398 }
1399 }
1400 if (pFilter.isNull())
1401 return setError(VBOX_E_INVALID_OBJECT_STATE,
1402 tr("The given USB device filter is not created within this VirtualBox instance"));
1403
1404 if (pFilter->mInList)
1405 return setError(E_INVALIDARG,
1406 tr("The given USB device filter is already in the list"));
1407
1408 /* iterate to the position... */
1409 USBDeviceFilterList::iterator itPos = m->llUSBDeviceFilters.begin();
1410 std::advance(itPos, aPosition);
1411 /* ...and insert */
1412 m->llUSBDeviceFilters.insert(itPos, pFilter);
1413 pFilter->mInList = true;
1414
1415 /* notify the proxy (only when the filter is active) */
1416 if ( m->pUSBProxyService->isActive()
1417 && pFilter->i_getData().mActive)
1418 {
1419 ComAssertRet(pFilter->i_getId() == NULL, E_FAIL);
1420 pFilter->i_getId() = m->pUSBProxyService->insertFilter(&pFilter->i_getData().mUSBFilter);
1421 }
1422
1423 // save the global settings; for that we should hold only the VirtualBox lock
1424 alock.release();
1425 AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
1426 return rc = m->pParent->i_saveSettings();
1427#else
1428
1429 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1430 * extended error info to indicate that USB is simply not available
1431 * (w/o treating it as a failure), for example, as in OSE. */
1432 NOREF(aPosition);
1433 NOREF(aFilter);
1434 ReturnComNotImplemented();
1435#endif
1436}
1437
1438HRESULT Host::removeUSBDeviceFilter(ULONG aPosition)
1439{
1440#ifdef VBOX_WITH_USB
1441
1442 /* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
1443 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1444
1445 MultiResult rc = i_checkUSBProxyService();
1446 if (FAILED(rc))
1447 return rc;
1448
1449 if (!m->llUSBDeviceFilters.size())
1450 return setError(E_INVALIDARG,
1451 tr("The USB device filter list is empty"));
1452
1453 if (aPosition >= m->llUSBDeviceFilters.size())
1454 return setError(E_INVALIDARG,
1455 tr("Invalid position: %lu (must be in range [0, %lu])"),
1456 aPosition, m->llUSBDeviceFilters.size() - 1);
1457
1458 ComObjPtr<HostUSBDeviceFilter> filter;
1459 {
1460 /* iterate to the position... */
1461 USBDeviceFilterList::iterator it = m->llUSBDeviceFilters.begin();
1462 std::advance(it, aPosition);
1463 /* ...get an element from there... */
1464 filter = *it;
1465 /* ...and remove */
1466 filter->mInList = false;
1467 m->llUSBDeviceFilters.erase(it);
1468 }
1469
1470 /* notify the proxy (only when the filter is active) */
1471 if (m->pUSBProxyService->isActive() && filter->i_getData().mActive)
1472 {
1473 ComAssertRet(filter->i_getId() != NULL, E_FAIL);
1474 m->pUSBProxyService->removeFilter(filter->i_getId());
1475 filter->i_getId() = NULL;
1476 }
1477
1478 // save the global settings; for that we should hold only the VirtualBox lock
1479 alock.release();
1480 AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
1481 return rc = m->pParent->i_saveSettings();
1482#else
1483 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1484 * extended error info to indicate that USB is simply not available
1485 * (w/o treating it as a failure), for example, as in OSE. */
1486 NOREF(aPosition);
1487 ReturnComNotImplemented();
1488#endif
1489}
1490
1491HRESULT Host::findHostDVDDrive(const com::Utf8Str &aName,
1492 ComPtr<IMedium> &aDrive)
1493{
1494 ComObjPtr<Medium> medium;
1495 HRESULT rc = i_findHostDriveByNameOrId(DeviceType_DVD, aName, medium);
1496 if (SUCCEEDED(rc))
1497 rc = medium.queryInterfaceTo(aDrive.asOutParam());
1498 else
1499 rc = setError(rc, Medium::tr("The host DVD drive named '%s' could not be found"), aName.c_str());
1500 return rc;
1501}
1502
1503HRESULT Host::findHostFloppyDrive(const com::Utf8Str &aName, ComPtr<IMedium> &aDrive)
1504{
1505 aDrive = NULL;
1506
1507 ComObjPtr<Medium>medium;
1508
1509 HRESULT rc = i_findHostDriveByNameOrId(DeviceType_Floppy, aName, medium);
1510 if (SUCCEEDED(rc))
1511 return medium.queryInterfaceTo(aDrive.asOutParam());
1512 else
1513 return setError(rc, Medium::tr("The host floppy drive named '%s' could not be found"), aName.c_str());
1514}
1515
1516HRESULT Host::findHostNetworkInterfaceByName(const com::Utf8Str &aName,
1517 ComPtr<IHostNetworkInterface> &aNetworkInterface)
1518{
1519#ifndef VBOX_WITH_HOSTNETIF_API
1520 return E_NOTIMPL;
1521#else
1522 if (!aName.length())
1523 return E_INVALIDARG;
1524
1525 HRESULT rc = i_updateNetIfList();
1526 if (FAILED(rc))
1527 {
1528 Log(("Failed to update host network interface list with rc=%Rhrc\n", rc));
1529 return rc;
1530 }
1531
1532 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1533
1534 ComObjPtr<HostNetworkInterface> found;
1535 for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
1536 {
1537 Bstr n;
1538 (*it)->COMGETTER(Name)(n.asOutParam());
1539 if (n == aName)
1540 found = *it;
1541 }
1542
1543 if (!found)
1544 return setError(E_INVALIDARG,
1545 HostNetworkInterface::tr("The host network interface with the given name could not be found"));
1546
1547 return found.queryInterfaceTo(aNetworkInterface.asOutParam());
1548#endif
1549}
1550
1551HRESULT Host::findHostNetworkInterfaceById(const com::Guid &aId,
1552 ComPtr<IHostNetworkInterface> &aNetworkInterface)
1553{
1554#ifndef VBOX_WITH_HOSTNETIF_API
1555 return E_NOTIMPL;
1556#else
1557 if (!aId.isValid())
1558 return E_INVALIDARG;
1559
1560 HRESULT rc = i_updateNetIfList();
1561 if (FAILED(rc))
1562 {
1563 Log(("Failed to update host network interface list with rc=%Rhrc\n", rc));
1564 return rc;
1565 }
1566
1567 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1568
1569 ComObjPtr<HostNetworkInterface> found;
1570 for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
1571 {
1572 Bstr g;
1573 (*it)->COMGETTER(Id)(g.asOutParam());
1574 if (Guid(g) == aId)
1575 found = *it;
1576 }
1577
1578 if (!found)
1579 return setError(E_INVALIDARG,
1580 HostNetworkInterface::tr("The host network interface with the given GUID could not be found"));
1581 return found.queryInterfaceTo(aNetworkInterface.asOutParam());
1582
1583#endif
1584}
1585
1586HRESULT Host::findHostNetworkInterfacesOfType(HostNetworkInterfaceType_T aType,
1587 std::vector<ComPtr<IHostNetworkInterface> > &aNetworkInterfaces)
1588{
1589#ifdef VBOX_WITH_HOSTNETIF_API
1590 HRESULT rc = i_updateNetIfList();
1591 if (FAILED(rc))
1592 {
1593 Log(("Failed to update host network interface list with rc=%Rhrc\n", rc));
1594 return rc;
1595 }
1596
1597 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1598
1599 HostNetworkInterfaceList resultList;
1600 for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
1601 {
1602 HostNetworkInterfaceType_T t;
1603 HRESULT hr = (*it)->COMGETTER(InterfaceType)(&t);
1604 if (FAILED(hr))
1605 return hr;
1606
1607 if (t == aType)
1608 resultList.push_back(*it);
1609 }
1610 aNetworkInterfaces.resize(resultList.size());
1611 size_t i = 0;
1612 for (HostNetworkInterfaceList::iterator it = resultList.begin(); it != resultList.end(); ++it, ++i)
1613 {
1614 (*it).queryInterfaceTo(aNetworkInterfaces[i].asOutParam());
1615 }
1616
1617 return S_OK;
1618#else
1619 return E_NOTIMPL;
1620#endif
1621}
1622
1623HRESULT Host::findUSBDeviceByAddress(const com::Utf8Str &aName,
1624 ComPtr<IHostUSBDevice> &aDevice)
1625{
1626#ifdef VBOX_WITH_USB
1627
1628 aDevice = NULL;
1629 SafeIfaceArray<IHostUSBDevice> devsvec;
1630 HRESULT rc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
1631 if (FAILED(rc))
1632 return rc;
1633
1634 for (size_t i = 0; i < devsvec.size(); ++i)
1635 {
1636 Bstr address;
1637 rc = devsvec[i]->COMGETTER(Address)(address.asOutParam());
1638 if (FAILED(rc))
1639 return rc;
1640 if (address == aName)
1641 {
1642 return (ComPtr<IHostUSBDevice>(devsvec[i]).queryInterfaceTo(aDevice.asOutParam()));
1643 }
1644 }
1645
1646 return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
1647 tr("Could not find a USB device with address '%s'"),
1648 aName.c_str());
1649
1650#else /* !VBOX_WITH_USB */
1651 NOREF(aName);
1652 NOREF(aDevice);
1653 return E_NOTIMPL;
1654#endif /* !VBOX_WITH_USB */
1655}
1656HRESULT Host::findUSBDeviceById(const com::Guid &aId,
1657 ComPtr<IHostUSBDevice> &aDevice)
1658{
1659#ifdef VBOX_WITH_USB
1660 if (!aId.isValid())
1661 return E_INVALIDARG;
1662
1663 aDevice = NULL;
1664
1665 SafeIfaceArray<IHostUSBDevice> devsvec;
1666 HRESULT rc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
1667 if (FAILED(rc))
1668 return rc;
1669
1670 for (size_t i = 0; i < devsvec.size(); ++i)
1671 {
1672 Bstr id;
1673 rc = devsvec[i]->COMGETTER(Id)(id.asOutParam());
1674 if (FAILED(rc))
1675 return rc;
1676 if (Guid(id) == aId)
1677 {
1678 return (ComPtr<IHostUSBDevice>(devsvec[i]).queryInterfaceTo(aDevice.asOutParam()));
1679 }
1680 }
1681 return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
1682 tr("Could not find a USB device with uuid {%RTuuid}"),
1683 aId.raw());
1684
1685#else /* !VBOX_WITH_USB */
1686 NOREF(aId);
1687 NOREF(aDevice);
1688 return E_NOTIMPL;
1689#endif /* !VBOX_WITH_USB */
1690}
1691
1692HRESULT Host::generateMACAddress(com::Utf8Str &aAddress)
1693{
1694 // no locking required
1695 i_generateMACAddress(aAddress);
1696 return S_OK;
1697}
1698
1699/**
1700 * Returns a list of host video capture devices (webcams, etc).
1701 *
1702 * @returns COM status code
1703 * @param aVideoInputDevices Array of interface pointers to be filled.
1704 */
1705HRESULT Host::getVideoInputDevices(std::vector<ComPtr<IHostVideoInputDevice> > &aVideoInputDevices)
1706{
1707 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1708 HostVideoInputDeviceList list;
1709
1710 HRESULT rc = HostVideoInputDevice::queryHostDevices(m->pParent, &list);
1711 if (FAILED(rc))
1712 return rc;
1713
1714 aVideoInputDevices.resize(list.size());
1715 size_t i = 0;
1716 for (HostVideoInputDeviceList::const_iterator it = list.begin(); it != list.end(); ++it, ++i)
1717 (*it).queryInterfaceTo(aVideoInputDevices[i].asOutParam());
1718
1719 return S_OK;
1720}
1721
1722// public methods only for internal purposes
1723////////////////////////////////////////////////////////////////////////////////
1724
1725HRESULT Host::i_loadSettings(const settings::Host &data)
1726{
1727 HRESULT rc = S_OK;
1728#ifdef VBOX_WITH_USB
1729 AutoCaller autoCaller(this);
1730 if (FAILED(autoCaller.rc()))
1731 return autoCaller.rc();
1732
1733 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1734
1735 for (settings::USBDeviceFiltersList::const_iterator it = data.llUSBDeviceFilters.begin();
1736 it != data.llUSBDeviceFilters.end();
1737 ++it)
1738 {
1739 const settings::USBDeviceFilter &f = *it;
1740 ComObjPtr<HostUSBDeviceFilter> pFilter;
1741 pFilter.createObject();
1742 rc = pFilter->init(this, f);
1743 if (FAILED(rc))
1744 break;
1745
1746 m->llUSBDeviceFilters.push_back(pFilter);
1747 pFilter->mInList = true;
1748
1749 /* notify the proxy (only when the filter is active) */
1750 if (pFilter->i_getData().mActive)
1751 {
1752 HostUSBDeviceFilter *flt = pFilter; /* resolve ambiguity */
1753 flt->i_getId() = m->pUSBProxyService->insertFilter(&pFilter->i_getData().mUSBFilter);
1754 }
1755 }
1756#else
1757 NOREF(data);
1758#endif /* VBOX_WITH_USB */
1759 return rc;
1760}
1761
1762HRESULT Host::i_saveSettings(settings::Host &data)
1763{
1764#ifdef VBOX_WITH_USB
1765 AutoCaller autoCaller(this);
1766 if (FAILED(autoCaller.rc()))
1767 return autoCaller.rc();
1768
1769 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1770
1771 data.llUSBDeviceFilters.clear();
1772
1773 for (USBDeviceFilterList::const_iterator it = m->llUSBDeviceFilters.begin();
1774 it != m->llUSBDeviceFilters.end();
1775 ++it)
1776 {
1777 ComObjPtr<HostUSBDeviceFilter> pFilter = *it;
1778 settings::USBDeviceFilter f;
1779 pFilter->i_saveSettings(f);
1780 data.llUSBDeviceFilters.push_back(f);
1781 }
1782#else
1783 NOREF(data);
1784#endif /* VBOX_WITH_USB */
1785
1786 return S_OK;
1787}
1788
1789/**
1790 * Sets the given pointer to point to the static list of DVD or floppy
1791 * drives in the Host instance data, depending on the @a mediumType
1792 * parameter.
1793 *
1794 * This builds the list on the first call; it adds or removes host drives
1795 * that may have changed if fRefresh == true.
1796 *
1797 * The caller must hold the medium tree write lock before calling this.
1798 * To protect the list to which the caller's pointer points, the caller
1799 * must also hold that lock.
1800 *
1801 * @param mediumType Must be DeviceType_Floppy or DeviceType_DVD.
1802 * @param fRefresh Whether to refresh the host drives list even if this is not the first call.
1803 * @param pll Caller's pointer which gets set to the static list of host drives.
1804 * @param treeLock Reference to media tree lock, need to drop it temporarily.
1805 * @returns COM status code
1806 */
1807HRESULT Host::i_getDrives(DeviceType_T mediumType,
1808 bool fRefresh,
1809 MediaList *&pll,
1810 AutoWriteLock &treeLock)
1811{
1812 HRESULT rc = S_OK;
1813 Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
1814
1815 MediaList llNew;
1816 MediaList *pllCached;
1817 bool *pfListBuilt = NULL;
1818
1819 switch (mediumType)
1820 {
1821 case DeviceType_DVD:
1822 if (!m->fDVDDrivesListBuilt || fRefresh)
1823 {
1824 rc = i_buildDVDDrivesList(llNew);
1825 if (FAILED(rc))
1826 return rc;
1827 pfListBuilt = &m->fDVDDrivesListBuilt;
1828 }
1829 pllCached = &m->llDVDDrives;
1830 break;
1831
1832 case DeviceType_Floppy:
1833 if (!m->fFloppyDrivesListBuilt || fRefresh)
1834 {
1835 rc = i_buildFloppyDrivesList(llNew);
1836 if (FAILED(rc))
1837 return rc;
1838 pfListBuilt = &m->fFloppyDrivesListBuilt;
1839 }
1840 pllCached = &m->llFloppyDrives;
1841 break;
1842
1843 default:
1844 return E_INVALIDARG;
1845 }
1846
1847 if (pfListBuilt)
1848 {
1849 // a list was built in llNew above:
1850 if (!*pfListBuilt)
1851 {
1852 // this was the first call (instance bool is still false): then just copy the whole list and return
1853 *pllCached = llNew;
1854 // and mark the instance data as "built"
1855 *pfListBuilt = true;
1856 }
1857 else
1858 {
1859 // list was built, and this was a subsequent call: then compare the old and the new lists
1860
1861 // remove drives from the cached list which are no longer present
1862 for (MediaList::iterator itCached = pllCached->begin();
1863 itCached != pllCached->end();
1864 /*nothing */)
1865 {
1866 Medium *pCached = *itCached;
1867 const Utf8Str strLocationCached = pCached->i_getLocationFull();
1868 bool fFound = false;
1869 for (MediaList::iterator itNew = llNew.begin();
1870 itNew != llNew.end();
1871 ++itNew)
1872 {
1873 Medium *pNew = *itNew;
1874 const Utf8Str strLocationNew = pNew->i_getLocationFull();
1875 if (strLocationNew == strLocationCached)
1876 {
1877 fFound = true;
1878 break;
1879 }
1880 }
1881 if (!fFound)
1882 {
1883 pCached->uninit();
1884 itCached = pllCached->erase(itCached);
1885 }
1886 else
1887 ++itCached;
1888 }
1889
1890 // add drives to the cached list that are not on there yet
1891 for (MediaList::iterator itNew = llNew.begin();
1892 itNew != llNew.end();
1893 ++itNew)
1894 {
1895 Medium *pNew = *itNew;
1896 const Utf8Str strLocationNew = pNew->i_getLocationFull();
1897 bool fFound = false;
1898 for (MediaList::iterator itCached = pllCached->begin();
1899 itCached != pllCached->end();
1900 ++itCached)
1901 {
1902 Medium *pCached = *itCached;
1903 const Utf8Str strLocationCached = pCached->i_getLocationFull();
1904 if (strLocationNew == strLocationCached)
1905 {
1906 fFound = true;
1907 break;
1908 }
1909 }
1910
1911 if (!fFound)
1912 pllCached->push_back(pNew);
1913 }
1914 }
1915 }
1916
1917 // return cached list to caller
1918 pll = pllCached;
1919
1920 // Make sure the media tree lock is released before llNew is cleared,
1921 // as this usually triggers calls to uninit().
1922 treeLock.release();
1923
1924 llNew.clear();
1925
1926 treeLock.acquire();
1927
1928 return rc;
1929}
1930
1931/**
1932 * Goes through the list of host drives that would be returned by getDrives()
1933 * and looks for a host drive with the given UUID. If found, it sets pMedium
1934 * to that drive; otherwise returns VBOX_E_OBJECT_NOT_FOUND.
1935 *
1936 * @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
1937 * @param uuid Medium UUID of host drive to look for.
1938 * @param fRefresh Whether to refresh the host drives list (see getDrives())
1939 * @param pMedium Medium object, if found...
1940 * @return VBOX_E_OBJECT_NOT_FOUND if not found, or S_OK if found, or errors from getDrives().
1941 */
1942HRESULT Host::i_findHostDriveById(DeviceType_T mediumType,
1943 const Guid &uuid,
1944 bool fRefresh,
1945 ComObjPtr<Medium> &pMedium)
1946{
1947 MediaList *pllMedia;
1948
1949 AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
1950 HRESULT rc = i_getDrives(mediumType, fRefresh, pllMedia, treeLock);
1951 if (SUCCEEDED(rc))
1952 {
1953 for (MediaList::iterator it = pllMedia->begin();
1954 it != pllMedia->end();
1955 ++it)
1956 {
1957 Medium *pThis = *it;
1958 AutoCaller mediumCaller(pThis);
1959 AutoReadLock mediumLock(pThis COMMA_LOCKVAL_SRC_POS);
1960 if (pThis->i_getId() == uuid)
1961 {
1962 pMedium = pThis;
1963 return S_OK;
1964 }
1965 }
1966 }
1967
1968 return VBOX_E_OBJECT_NOT_FOUND;
1969}
1970
1971/**
1972 * Goes through the list of host drives that would be returned by getDrives()
1973 * and looks for a host drive with the given name. If found, it sets pMedium
1974 * to that drive; otherwise returns VBOX_E_OBJECT_NOT_FOUND.
1975 *
1976 * @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
1977 * @param strLocationFull Name (path) of host drive to look for.
1978 * @param fRefresh Whether to refresh the host drives list (see getDrives())
1979 * @param pMedium Medium object, if found
1980 * @return VBOX_E_OBJECT_NOT_FOUND if not found, or S_OK if found, or errors from getDrives().
1981 */
1982HRESULT Host::i_findHostDriveByName(DeviceType_T mediumType,
1983 const Utf8Str &strLocationFull,
1984 bool fRefresh,
1985 ComObjPtr<Medium> &pMedium)
1986{
1987 MediaList *pllMedia;
1988
1989 AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
1990 HRESULT rc = i_getDrives(mediumType, fRefresh, pllMedia, treeLock);
1991 if (SUCCEEDED(rc))
1992 {
1993 for (MediaList::iterator it = pllMedia->begin();
1994 it != pllMedia->end();
1995 ++it)
1996 {
1997 Medium *pThis = *it;
1998 AutoCaller mediumCaller(pThis);
1999 AutoReadLock mediumLock(pThis COMMA_LOCKVAL_SRC_POS);
2000 if (pThis->i_getLocationFull() == strLocationFull)
2001 {
2002 pMedium = pThis;
2003 return S_OK;
2004 }
2005 }
2006 }
2007
2008 return VBOX_E_OBJECT_NOT_FOUND;
2009}
2010
2011/**
2012 * Goes through the list of host drives that would be returned by getDrives()
2013 * and looks for a host drive with the given name, location or ID. If found,
2014 * it sets pMedium to that drive; otherwise returns VBOX_E_OBJECT_NOT_FOUND.
2015 *
2016 * @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
2017 * @param strNameOrId Name or full location or UUID of host drive to look for.
2018 * @param pMedium Medium object, if found...
2019 * @return VBOX_E_OBJECT_NOT_FOUND if not found, or S_OK if found, or errors from getDrives().
2020 */
2021HRESULT Host::i_findHostDriveByNameOrId(DeviceType_T mediumType,
2022 const Utf8Str &strNameOrId,
2023 ComObjPtr<Medium> &pMedium)
2024{
2025 AutoWriteLock wlock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
2026
2027 Guid uuid(strNameOrId);
2028 if (uuid.isValid() && !uuid.isZero())
2029 return i_findHostDriveById(mediumType, uuid, true /* fRefresh */, pMedium);
2030
2031 // string is not a syntactically valid UUID: try a name then
2032 return i_findHostDriveByName(mediumType, strNameOrId, true /* fRefresh */, pMedium);
2033}
2034
2035/**
2036 * Called from getDrives() to build the DVD drives list.
2037 * @param pll
2038 * @return
2039 */
2040HRESULT Host::i_buildDVDDrivesList(MediaList &list)
2041{
2042 HRESULT rc = S_OK;
2043
2044 Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
2045
2046 try
2047 {
2048#if defined(RT_OS_WINDOWS)
2049 int sz = GetLogicalDriveStrings(0, NULL);
2050 TCHAR *hostDrives = new TCHAR[sz+1];
2051 GetLogicalDriveStrings(sz, hostDrives);
2052 wchar_t driveName[3] = { '?', ':', '\0' };
2053 TCHAR *p = hostDrives;
2054 do
2055 {
2056 if (GetDriveType(p) == DRIVE_CDROM)
2057 {
2058 driveName[0] = *p;
2059 ComObjPtr<Medium> hostDVDDriveObj;
2060 hostDVDDriveObj.createObject();
2061 hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(driveName));
2062 list.push_back(hostDVDDriveObj);
2063 }
2064 p += _tcslen(p) + 1;
2065 }
2066 while (*p);
2067 delete[] hostDrives;
2068
2069#elif defined(RT_OS_SOLARIS)
2070# ifdef VBOX_USE_LIBHAL
2071 if (!i_getDVDInfoFromHal(list))
2072# endif
2073 {
2074 i_getDVDInfoFromDevTree(list);
2075 }
2076
2077#elif defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD)
2078 if (RT_SUCCESS(m->hostDrives.updateDVDs()))
2079 for (DriveInfoList::const_iterator it = m->hostDrives.DVDBegin();
2080 SUCCEEDED(rc) && it != m->hostDrives.DVDEnd(); ++it)
2081 {
2082 ComObjPtr<Medium> hostDVDDriveObj;
2083 Utf8Str location(it->mDevice);
2084 Utf8Str description(it->mDescription);
2085 if (SUCCEEDED(rc))
2086 rc = hostDVDDriveObj.createObject();
2087 if (SUCCEEDED(rc))
2088 rc = hostDVDDriveObj->init(m->pParent, DeviceType_DVD, location, description);
2089 if (SUCCEEDED(rc))
2090 list.push_back(hostDVDDriveObj);
2091 }
2092#elif defined(RT_OS_DARWIN)
2093 PDARWINDVD cur = DarwinGetDVDDrives();
2094 while (cur)
2095 {
2096 ComObjPtr<Medium> hostDVDDriveObj;
2097 hostDVDDriveObj.createObject();
2098 hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(cur->szName));
2099 list.push_back(hostDVDDriveObj);
2100
2101 /* next */
2102 void *freeMe = cur;
2103 cur = cur->pNext;
2104 RTMemFree(freeMe);
2105 }
2106#else
2107 /* PORTME */
2108#endif
2109 }
2110 catch(std::bad_alloc &)
2111 {
2112 rc = E_OUTOFMEMORY;
2113 }
2114 return rc;
2115}
2116
2117/**
2118 * Called from getDrives() to build the floppy drives list.
2119 * @param list
2120 * @return
2121 */
2122HRESULT Host::i_buildFloppyDrivesList(MediaList &list)
2123{
2124 HRESULT rc = S_OK;
2125
2126 Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
2127
2128 try
2129 {
2130#ifdef RT_OS_WINDOWS
2131 int sz = GetLogicalDriveStrings(0, NULL);
2132 TCHAR *hostDrives = new TCHAR[sz+1];
2133 GetLogicalDriveStrings(sz, hostDrives);
2134 wchar_t driveName[3] = { '?', ':', '\0' };
2135 TCHAR *p = hostDrives;
2136 do
2137 {
2138 if (GetDriveType(p) == DRIVE_REMOVABLE)
2139 {
2140 driveName[0] = *p;
2141 ComObjPtr<Medium> hostFloppyDriveObj;
2142 hostFloppyDriveObj.createObject();
2143 hostFloppyDriveObj->init(m->pParent, DeviceType_Floppy, Bstr(driveName));
2144 list.push_back(hostFloppyDriveObj);
2145 }
2146 p += _tcslen(p) + 1;
2147 }
2148 while (*p);
2149 delete[] hostDrives;
2150#elif defined(RT_OS_LINUX)
2151 if (RT_SUCCESS(m->hostDrives.updateFloppies()))
2152 for (DriveInfoList::const_iterator it = m->hostDrives.FloppyBegin();
2153 SUCCEEDED(rc) && it != m->hostDrives.FloppyEnd(); ++it)
2154 {
2155 ComObjPtr<Medium> hostFloppyDriveObj;
2156 Utf8Str location(it->mDevice);
2157 Utf8Str description(it->mDescription);
2158 if (SUCCEEDED(rc))
2159 rc = hostFloppyDriveObj.createObject();
2160 if (SUCCEEDED(rc))
2161 rc = hostFloppyDriveObj->init(m->pParent, DeviceType_Floppy, location, description);
2162 if (SUCCEEDED(rc))
2163 list.push_back(hostFloppyDriveObj);
2164 }
2165#else
2166 NOREF(list);
2167 /* PORTME */
2168#endif
2169 }
2170 catch(std::bad_alloc &)
2171 {
2172 rc = E_OUTOFMEMORY;
2173 }
2174
2175 return rc;
2176}
2177
2178#ifdef VBOX_WITH_USB
2179USBProxyService* Host::i_usbProxyService()
2180{
2181 return m->pUSBProxyService;
2182}
2183
2184HRESULT Host::i_addChild(HostUSBDeviceFilter *pChild)
2185{
2186 AutoCaller autoCaller(this);
2187 if (FAILED(autoCaller.rc()))
2188 return autoCaller.rc();
2189
2190 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2191
2192 m->llChildren.push_back(pChild);
2193
2194 return S_OK;
2195}
2196
2197HRESULT Host::i_removeChild(HostUSBDeviceFilter *pChild)
2198{
2199 AutoCaller autoCaller(this);
2200 if (FAILED(autoCaller.rc()))
2201 return autoCaller.rc();
2202
2203 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2204
2205 for (USBDeviceFilterList::iterator it = m->llChildren.begin();
2206 it != m->llChildren.end();
2207 ++it)
2208 {
2209 if (*it == pChild)
2210 {
2211 m->llChildren.erase(it);
2212 break;
2213 }
2214 }
2215
2216 return S_OK;
2217}
2218
2219VirtualBox* Host::i_parent()
2220{
2221 return m->pParent;
2222}
2223
2224/**
2225 * Called by setter methods of all USB device filters.
2226 */
2227HRESULT Host::i_onUSBDeviceFilterChange(HostUSBDeviceFilter *aFilter,
2228 BOOL aActiveChanged /* = FALSE */)
2229{
2230 AutoCaller autoCaller(this);
2231 if (FAILED(autoCaller.rc()))
2232 return autoCaller.rc();
2233
2234 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2235
2236 if (aFilter->mInList)
2237 {
2238 if (aActiveChanged)
2239 {
2240 // insert/remove the filter from the proxy
2241 if (aFilter->i_getData().mActive)
2242 {
2243 ComAssertRet(aFilter->i_getId() == NULL, E_FAIL);
2244 aFilter->i_getId() = m->pUSBProxyService->insertFilter(&aFilter->i_getData().mUSBFilter);
2245 }
2246 else
2247 {
2248 ComAssertRet(aFilter->i_getId() != NULL, E_FAIL);
2249 m->pUSBProxyService->removeFilter(aFilter->i_getId());
2250 aFilter->i_getId() = NULL;
2251 }
2252 }
2253 else
2254 {
2255 if (aFilter->i_getData().mActive)
2256 {
2257 // update the filter in the proxy
2258 ComAssertRet(aFilter->i_getId() != NULL, E_FAIL);
2259 m->pUSBProxyService->removeFilter(aFilter->i_getId());
2260 aFilter->i_getId() = m->pUSBProxyService->insertFilter(&aFilter->i_getData().mUSBFilter);
2261 }
2262 }
2263
2264 // save the global settings... yeah, on every single filter property change
2265 // for that we should hold only the VirtualBox lock
2266 alock.release();
2267 AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
2268 return m->pParent->i_saveSettings();
2269 }
2270
2271 return S_OK;
2272}
2273
2274
2275/**
2276 * Interface for obtaining a copy of the USBDeviceFilterList,
2277 * used by the USBProxyService.
2278 *
2279 * @param aGlobalFilters Where to put the global filter list copy.
2280 * @param aMachines Where to put the machine vector.
2281 */
2282void Host::i_getUSBFilters(Host::USBDeviceFilterList *aGlobalFilters)
2283{
2284 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2285
2286 *aGlobalFilters = m->llUSBDeviceFilters;
2287}
2288
2289#endif /* VBOX_WITH_USB */
2290
2291// private methods
2292////////////////////////////////////////////////////////////////////////////////
2293
2294#if defined(RT_OS_SOLARIS) && defined(VBOX_USE_LIBHAL)
2295
2296/**
2297 * Helper function to get the slice number from a device path
2298 *
2299 * @param pszDevLinkPath Pointer to a device path (/dev/(r)dsk/c7d1t0d0s3 etc.)
2300 * @returns Pointer to the slice portion of the given path.
2301 */
2302static char *solarisGetSliceFromPath(const char *pszDevLinkPath)
2303{
2304 char *pszFound = NULL;
2305 char *pszSlice = strrchr(pszDevLinkPath, 's');
2306 char *pszDisk = strrchr(pszDevLinkPath, 'd');
2307 if (pszSlice && pszSlice > pszDisk)
2308 pszFound = pszSlice;
2309 else
2310 pszFound = pszDisk;
2311
2312 if (pszFound && RT_C_IS_DIGIT(pszFound[1]))
2313 return pszFound;
2314
2315 return NULL;
2316}
2317
2318/**
2319 * Walk device links and returns an allocated path for the first one in the snapshot.
2320 *
2321 * @param DevLink Handle to the device link being walked.
2322 * @param pvArg Opaque data containing the pointer to the path.
2323 * @returns Pointer to an allocated device path string.
2324 */
2325static int solarisWalkDevLink(di_devlink_t DevLink, void *pvArg)
2326{
2327 char **ppszPath = (char **)pvArg;
2328 *ppszPath = strdup(di_devlink_path(DevLink));
2329 return DI_WALK_TERMINATE;
2330}
2331
2332/**
2333 * Walk all devices in the system and enumerate CD/DVD drives.
2334 * @param Node Handle to the current node.
2335 * @param pvArg Opaque data (holds list pointer).
2336 * @returns Solaris specific code whether to continue walking or not.
2337 */
2338static int solarisWalkDeviceNodeForDVD(di_node_t Node, void *pvArg)
2339{
2340 PSOLARISDVD *ppDrives = (PSOLARISDVD *)pvArg;
2341
2342 /*
2343 * Check for "removable-media" or "hotpluggable" instead of "SCSI" so that we also include USB CD-ROMs.
2344 * As unfortunately the Solaris drivers only export these common properties.
2345 */
2346 int *pInt = NULL;
2347 if ( di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "removable-media", &pInt) >= 0
2348 || di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "hotpluggable", &pInt) >= 0)
2349 {
2350 if (di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "inquiry-device-type", &pInt) > 0
2351 && ( *pInt == DTYPE_RODIRECT /* CDROM */
2352 || *pInt == DTYPE_OPTICAL)) /* Optical Drive */
2353 {
2354 char *pszProduct = NULL;
2355 if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "inquiry-product-id", &pszProduct) > 0)
2356 {
2357 char *pszVendor = NULL;
2358 if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "inquiry-vendor-id", &pszVendor) > 0)
2359 {
2360 /*
2361 * Found a DVD drive, we need to scan the minor nodes to find the correct
2362 * slice that represents the whole drive. "s2" is always the whole drive for CD/DVDs.
2363 */
2364 int Major = di_driver_major(Node);
2365 di_minor_t Minor = DI_MINOR_NIL;
2366 di_devlink_handle_t DevLink = di_devlink_init(NULL /* name */, 0 /* flags */);
2367 if (DevLink)
2368 {
2369 while ((Minor = di_minor_next(Node, Minor)) != DI_MINOR_NIL)
2370 {
2371 dev_t Dev = di_minor_devt(Minor);
2372 if ( Major != (int)major(Dev)
2373 || di_minor_spectype(Minor) == S_IFBLK
2374 || di_minor_type(Minor) != DDM_MINOR)
2375 {
2376 continue;
2377 }
2378
2379 char *pszMinorPath = di_devfs_minor_path(Minor);
2380 if (!pszMinorPath)
2381 continue;
2382
2383 char *pszDevLinkPath = NULL;
2384 di_devlink_walk(DevLink, NULL, pszMinorPath, DI_PRIMARY_LINK, &pszDevLinkPath, solarisWalkDevLink);
2385 di_devfs_path_free(pszMinorPath);
2386
2387 if (pszDevLinkPath)
2388 {
2389 char *pszSlice = solarisGetSliceFromPath(pszDevLinkPath);
2390 if ( pszSlice && !strcmp(pszSlice, "s2")
2391 && !strncmp(pszDevLinkPath, RT_STR_TUPLE("/dev/rdsk"))) /* We want only raw disks */
2392 {
2393 /*
2394 * We've got a fully qualified DVD drive. Add it to the list.
2395 */
2396 PSOLARISDVD pDrive = (PSOLARISDVD)RTMemAllocZ(sizeof(SOLARISDVD));
2397 if (RT_LIKELY(pDrive))
2398 {
2399 RTStrPrintf(pDrive->szDescription, sizeof(pDrive->szDescription),
2400 "%s %s", pszVendor, pszProduct);
2401 RTStrCopy(pDrive->szRawDiskPath, sizeof(pDrive->szRawDiskPath), pszDevLinkPath);
2402 if (*ppDrives)
2403 pDrive->pNext = *ppDrives;
2404 *ppDrives = pDrive;
2405
2406 /* We're not interested in any of the other slices, stop minor nodes traversal. */
2407 free(pszDevLinkPath);
2408 break;
2409 }
2410 }
2411 free(pszDevLinkPath);
2412 }
2413 }
2414 di_devlink_fini(&DevLink);
2415 }
2416 }
2417 }
2418 }
2419 }
2420 return DI_WALK_CONTINUE;
2421}
2422
2423/**
2424 * Solaris specific function to enumerate CD/DVD drives via the device tree.
2425 * Works on Solaris 10 as well as OpenSolaris without depending on libhal.
2426 */
2427void Host::i_getDVDInfoFromDevTree(std::list<ComObjPtr<Medium> > &list)
2428{
2429 PSOLARISDVD pDrives = NULL;
2430 di_node_t RootNode = di_init("/", DINFOCPYALL);
2431 if (RootNode != DI_NODE_NIL)
2432 di_walk_node(RootNode, DI_WALK_CLDFIRST, &pDrives, solarisWalkDeviceNodeForDVD);
2433
2434 di_fini(RootNode);
2435
2436 while (pDrives)
2437 {
2438 ComObjPtr<Medium> hostDVDDriveObj;
2439 hostDVDDriveObj.createObject();
2440 hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(pDrives->szRawDiskPath), Bstr(pDrives->szDescription));
2441 list.push_back(hostDVDDriveObj);
2442
2443 void *pvDrive = pDrives;
2444 pDrives = pDrives->pNext;
2445 RTMemFree(pvDrive);
2446 }
2447}
2448
2449/* Solaris hosts, loading libhal at runtime */
2450
2451/**
2452 * Helper function to query the hal subsystem for information about DVD drives attached to the
2453 * system.
2454 *
2455 * @returns true if information was successfully obtained, false otherwise
2456 * @retval list drives found will be attached to this list
2457 */
2458bool Host::i_getDVDInfoFromHal(std::list<ComObjPtr<Medium> > &list)
2459{
2460 bool halSuccess = false;
2461 DBusError dbusError;
2462 if (!gLibHalCheckPresence())
2463 return false;
2464 gDBusErrorInit(&dbusError);
2465 DBusConnection *dbusConnection = gDBusBusGet(DBUS_BUS_SYSTEM, &dbusError);
2466 if (dbusConnection != 0)
2467 {
2468 LibHalContext *halContext = gLibHalCtxNew();
2469 if (halContext != 0)
2470 {
2471 if (gLibHalCtxSetDBusConnection(halContext, dbusConnection))
2472 {
2473 if (gLibHalCtxInit(halContext, &dbusError))
2474 {
2475 int numDevices;
2476 char **halDevices = gLibHalFindDeviceStringMatch(halContext,
2477 "storage.drive_type", "cdrom",
2478 &numDevices, &dbusError);
2479 if (halDevices != 0)
2480 {
2481 /* Hal is installed and working, so if no devices are reported, assume
2482 that there are none. */
2483 halSuccess = true;
2484 for (int i = 0; i < numDevices; i++)
2485 {
2486 char *devNode = gLibHalDeviceGetPropertyString(halContext,
2487 halDevices[i], "block.device", &dbusError);
2488#ifdef RT_OS_SOLARIS
2489 /* The CD/DVD ioctls work only for raw device nodes. */
2490 char *tmp = getfullrawname(devNode);
2491 gLibHalFreeString(devNode);
2492 devNode = tmp;
2493#endif
2494
2495 if (devNode != 0)
2496 {
2497// if (validateDevice(devNode, true))
2498// {
2499 Utf8Str description;
2500 char *vendor, *product;
2501 /* We do not check the error here, as this field may
2502 not even exist. */
2503 vendor = gLibHalDeviceGetPropertyString(halContext,
2504 halDevices[i], "info.vendor", 0);
2505 product = gLibHalDeviceGetPropertyString(halContext,
2506 halDevices[i], "info.product", &dbusError);
2507 if ((product != 0 && product[0] != 0))
2508 {
2509 if ((vendor != 0) && (vendor[0] != 0))
2510 {
2511 description = Utf8StrFmt("%s %s",
2512 vendor, product);
2513 }
2514 else
2515 {
2516 description = product;
2517 }
2518 ComObjPtr<Medium> hostDVDDriveObj;
2519 hostDVDDriveObj.createObject();
2520 hostDVDDriveObj->init(m->pParent, DeviceType_DVD,
2521 Bstr(devNode), Bstr(description));
2522 list.push_back(hostDVDDriveObj);
2523 }
2524 else
2525 {
2526 if (product == 0)
2527 {
2528 LogRel(("Host::COMGETTER(DVDDrives): failed to get property \"info.product\" for device %s. dbus error: %s (%s)\n",
2529 halDevices[i], dbusError.name, dbusError.message));
2530 gDBusErrorFree(&dbusError);
2531 }
2532 ComObjPtr<Medium> hostDVDDriveObj;
2533 hostDVDDriveObj.createObject();
2534 hostDVDDriveObj->init(m->pParent, DeviceType_DVD,
2535 Bstr(devNode));
2536 list.push_back(hostDVDDriveObj);
2537 }
2538 if (vendor != 0)
2539 {
2540 gLibHalFreeString(vendor);
2541 }
2542 if (product != 0)
2543 {
2544 gLibHalFreeString(product);
2545 }
2546// }
2547// else
2548// {
2549// LogRel(("Host::COMGETTER(DVDDrives): failed to validate the block device %s as a DVD drive\n"));
2550// }
2551#ifndef RT_OS_SOLARIS
2552 gLibHalFreeString(devNode);
2553#else
2554 free(devNode);
2555#endif
2556 }
2557 else
2558 {
2559 LogRel(("Host::COMGETTER(DVDDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
2560 halDevices[i], dbusError.name, dbusError.message));
2561 gDBusErrorFree(&dbusError);
2562 }
2563 }
2564 gLibHalFreeStringArray(halDevices);
2565 }
2566 else
2567 {
2568 LogRel(("Host::COMGETTER(DVDDrives): failed to get devices with capability \"storage.cdrom\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2569 gDBusErrorFree(&dbusError);
2570 }
2571 if (!gLibHalCtxShutdown(halContext, &dbusError)) /* what now? */
2572 {
2573 LogRel(("Host::COMGETTER(DVDDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n",
2574 dbusError.name, dbusError.message));
2575 gDBusErrorFree(&dbusError);
2576 }
2577 }
2578 else
2579 {
2580 LogRel(("Host::COMGETTER(DVDDrives): failed to initialise libhal context. dbus error: %s (%s)\n",
2581 dbusError.name, dbusError.message));
2582 gDBusErrorFree(&dbusError);
2583 }
2584 gLibHalCtxFree(halContext);
2585 }
2586 else
2587 {
2588 LogRel(("Host::COMGETTER(DVDDrives): failed to set libhal connection to dbus.\n"));
2589 }
2590 }
2591 else
2592 {
2593 LogRel(("Host::COMGETTER(DVDDrives): failed to get a libhal context - out of memory?\n"));
2594 }
2595 gDBusConnectionUnref(dbusConnection);
2596 }
2597 else
2598 {
2599 LogRel(("Host::COMGETTER(DVDDrives): failed to connect to dbus. dbus error: %s (%s)\n",
2600 dbusError.name, dbusError.message));
2601 gDBusErrorFree(&dbusError);
2602 }
2603 return halSuccess;
2604}
2605
2606
2607/**
2608 * Helper function to query the hal subsystem for information about floppy drives attached to the
2609 * system.
2610 *
2611 * @returns true if information was successfully obtained, false otherwise
2612 * @retval list drives found will be attached to this list
2613 */
2614bool Host::i_getFloppyInfoFromHal(std::list< ComObjPtr<Medium> > &list)
2615{
2616 bool halSuccess = false;
2617 DBusError dbusError;
2618 if (!gLibHalCheckPresence())
2619 return false;
2620 gDBusErrorInit(&dbusError);
2621 DBusConnection *dbusConnection = gDBusBusGet(DBUS_BUS_SYSTEM, &dbusError);
2622 if (dbusConnection != 0)
2623 {
2624 LibHalContext *halContext = gLibHalCtxNew();
2625 if (halContext != 0)
2626 {
2627 if (gLibHalCtxSetDBusConnection(halContext, dbusConnection))
2628 {
2629 if (gLibHalCtxInit(halContext, &dbusError))
2630 {
2631 int numDevices;
2632 char **halDevices = gLibHalFindDeviceStringMatch(halContext,
2633 "storage.drive_type", "floppy",
2634 &numDevices, &dbusError);
2635 if (halDevices != 0)
2636 {
2637 /* Hal is installed and working, so if no devices are reported, assume
2638 that there are none. */
2639 halSuccess = true;
2640 for (int i = 0; i < numDevices; i++)
2641 {
2642 char *driveType = gLibHalDeviceGetPropertyString(halContext,
2643 halDevices[i], "storage.drive_type", 0);
2644 if (driveType != 0)
2645 {
2646 if (strcmp(driveType, "floppy") != 0)
2647 {
2648 gLibHalFreeString(driveType);
2649 continue;
2650 }
2651 gLibHalFreeString(driveType);
2652 }
2653 else
2654 {
2655 /* An error occurred. The attribute "storage.drive_type"
2656 probably didn't exist. */
2657 continue;
2658 }
2659 char *devNode = gLibHalDeviceGetPropertyString(halContext,
2660 halDevices[i], "block.device", &dbusError);
2661 if (devNode != 0)
2662 {
2663// if (validateDevice(devNode, false))
2664// {
2665 Utf8Str description;
2666 char *vendor, *product;
2667 /* We do not check the error here, as this field may
2668 not even exist. */
2669 vendor = gLibHalDeviceGetPropertyString(halContext,
2670 halDevices[i], "info.vendor", 0);
2671 product = gLibHalDeviceGetPropertyString(halContext,
2672 halDevices[i], "info.product", &dbusError);
2673 if ((product != 0) && (product[0] != 0))
2674 {
2675 if ((vendor != 0) && (vendor[0] != 0))
2676 {
2677 description = Utf8StrFmt("%s %s",
2678 vendor, product);
2679 }
2680 else
2681 {
2682 description = product;
2683 }
2684 ComObjPtr<Medium> hostFloppyDrive;
2685 hostFloppyDrive.createObject();
2686 hostFloppyDrive->init(m->pParent, DeviceType_DVD,
2687 Bstr(devNode), Bstr(description));
2688 list.push_back(hostFloppyDrive);
2689 }
2690 else
2691 {
2692 if (product == 0)
2693 {
2694 LogRel(("Host::COMGETTER(FloppyDrives): failed to get property \"info.product\" for device %s. dbus error: %s (%s)\n",
2695 halDevices[i], dbusError.name, dbusError.message));
2696 gDBusErrorFree(&dbusError);
2697 }
2698 ComObjPtr<Medium> hostFloppyDrive;
2699 hostFloppyDrive.createObject();
2700 hostFloppyDrive->init(m->pParent, DeviceType_DVD,
2701 Bstr(devNode));
2702 list.push_back(hostFloppyDrive);
2703 }
2704 if (vendor != 0)
2705 {
2706 gLibHalFreeString(vendor);
2707 }
2708 if (product != 0)
2709 {
2710 gLibHalFreeString(product);
2711 }
2712// }
2713// else
2714// {
2715// LogRel(("Host::COMGETTER(FloppyDrives): failed to validate the block device %s as a floppy drive\n"));
2716// }
2717 gLibHalFreeString(devNode);
2718 }
2719 else
2720 {
2721 LogRel(("Host::COMGETTER(FloppyDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
2722 halDevices[i], dbusError.name, dbusError.message));
2723 gDBusErrorFree(&dbusError);
2724 }
2725 }
2726 gLibHalFreeStringArray(halDevices);
2727 }
2728 else
2729 {
2730 LogRel(("Host::COMGETTER(FloppyDrives): failed to get devices with capability \"storage.cdrom\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2731 gDBusErrorFree(&dbusError);
2732 }
2733 if (!gLibHalCtxShutdown(halContext, &dbusError)) /* what now? */
2734 {
2735 LogRel(("Host::COMGETTER(FloppyDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n",
2736 dbusError.name, dbusError.message));
2737 gDBusErrorFree(&dbusError);
2738 }
2739 }
2740 else
2741 {
2742 LogRel(("Host::COMGETTER(FloppyDrives): failed to initialise libhal context. dbus error: %s (%s)\n",
2743 dbusError.name, dbusError.message));
2744 gDBusErrorFree(&dbusError);
2745 }
2746 gLibHalCtxFree(halContext);
2747 }
2748 else
2749 {
2750 LogRel(("Host::COMGETTER(FloppyDrives): failed to set libhal connection to dbus.\n"));
2751 }
2752 }
2753 else
2754 {
2755 LogRel(("Host::COMGETTER(FloppyDrives): failed to get a libhal context - out of memory?\n"));
2756 }
2757 gDBusConnectionUnref(dbusConnection);
2758 }
2759 else
2760 {
2761 LogRel(("Host::COMGETTER(FloppyDrives): failed to connect to dbus. dbus error: %s (%s)\n",
2762 dbusError.name, dbusError.message));
2763 gDBusErrorFree(&dbusError);
2764 }
2765 return halSuccess;
2766}
2767#endif /* RT_OS_SOLARIS and VBOX_USE_HAL */
2768
2769/** @todo get rid of dead code below - RT_OS_SOLARIS and RT_OS_LINUX are never both set */
2770#if defined(RT_OS_SOLARIS)
2771
2772/**
2773 * Helper function to parse the given mount file and add found entries
2774 */
2775void Host::i_parseMountTable(char *mountTable, std::list< ComObjPtr<Medium> > &list)
2776{
2777#ifdef RT_OS_LINUX
2778 FILE *mtab = setmntent(mountTable, "r");
2779 if (mtab)
2780 {
2781 struct mntent *mntent;
2782 char *mnt_type;
2783 char *mnt_dev;
2784 char *tmp;
2785 while ((mntent = getmntent(mtab)))
2786 {
2787 mnt_type = (char*)malloc(strlen(mntent->mnt_type) + 1);
2788 mnt_dev = (char*)malloc(strlen(mntent->mnt_fsname) + 1);
2789 strcpy(mnt_type, mntent->mnt_type);
2790 strcpy(mnt_dev, mntent->mnt_fsname);
2791 // supermount fs case
2792 if (strcmp(mnt_type, "supermount") == 0)
2793 {
2794 tmp = strstr(mntent->mnt_opts, "fs=");
2795 if (tmp)
2796 {
2797 free(mnt_type);
2798 mnt_type = strdup(tmp + strlen("fs="));
2799 if (mnt_type)
2800 {
2801 tmp = strchr(mnt_type, ',');
2802 if (tmp)
2803 *tmp = '\0';
2804 }
2805 }
2806 tmp = strstr(mntent->mnt_opts, "dev=");
2807 if (tmp)
2808 {
2809 free(mnt_dev);
2810 mnt_dev = strdup(tmp + strlen("dev="));
2811 if (mnt_dev)
2812 {
2813 tmp = strchr(mnt_dev, ',');
2814 if (tmp)
2815 *tmp = '\0';
2816 }
2817 }
2818 }
2819 // use strstr here to cover things fs types like "udf,iso9660"
2820 if (strstr(mnt_type, "iso9660") == 0)
2821 {
2822 /** @todo check whether we've already got the drive in our list! */
2823 if (i_validateDevice(mnt_dev, true))
2824 {
2825 ComObjPtr<Medium> hostDVDDriveObj;
2826 hostDVDDriveObj.createObject();
2827 hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(mnt_dev));
2828 list.push_back (hostDVDDriveObj);
2829 }
2830 }
2831 free(mnt_dev);
2832 free(mnt_type);
2833 }
2834 endmntent(mtab);
2835 }
2836#else // RT_OS_SOLARIS
2837 FILE *mntFile = fopen(mountTable, "r");
2838 if (mntFile)
2839 {
2840 struct mnttab mntTab;
2841 while (getmntent(mntFile, &mntTab) == 0)
2842 {
2843 const char *mountName = mntTab.mnt_special;
2844 const char *mountPoint = mntTab.mnt_mountp;
2845 const char *mountFSType = mntTab.mnt_fstype;
2846 if (mountName && mountPoint && mountFSType)
2847 {
2848 // skip devices we are not interested in
2849 if ((*mountName && mountName[0] == '/') && // skip 'fake' devices (like -hosts,
2850 // proc, fd, swap)
2851 (*mountFSType && (strncmp(mountFSType, RT_STR_TUPLE("devfs")) != 0 && // skip devfs
2852 // (i.e. /devices)
2853 strncmp(mountFSType, RT_STR_TUPLE("dev")) != 0 && // skip dev (i.e. /dev)
2854 strncmp(mountFSType, RT_STR_TUPLE("lofs")) != 0))) // skip loop-back file-system (lofs)
2855 {
2856 char *rawDevName = getfullrawname((char *)mountName);
2857 if (i_validateDevice(rawDevName, true))
2858 {
2859 ComObjPtr<Medium> hostDVDDriveObj;
2860 hostDVDDriveObj.createObject();
2861 hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(rawDevName));
2862 list.push_back(hostDVDDriveObj);
2863 }
2864 free(rawDevName);
2865 }
2866 }
2867 }
2868
2869 fclose(mntFile);
2870 }
2871#endif
2872}
2873
2874/**
2875 * Helper function to check whether the given device node is a valid drive
2876 */
2877bool Host::i_validateDevice(const char *deviceNode, bool isCDROM)
2878{
2879 struct stat statInfo;
2880 bool retValue = false;
2881
2882 // sanity check
2883 if (!deviceNode)
2884 {
2885 return false;
2886 }
2887
2888 // first a simple stat() call
2889 if (stat(deviceNode, &statInfo) < 0)
2890 {
2891 return false;
2892 }
2893 else
2894 {
2895 if (isCDROM)
2896 {
2897 if (S_ISCHR(statInfo.st_mode) || S_ISBLK(statInfo.st_mode))
2898 {
2899 int fileHandle;
2900 // now try to open the device
2901 fileHandle = open(deviceNode, O_RDONLY | O_NONBLOCK, 0);
2902 if (fileHandle >= 0)
2903 {
2904 cdrom_subchnl cdChannelInfo;
2905 cdChannelInfo.cdsc_format = CDROM_MSF;
2906 // this call will finally reveal the whole truth
2907#ifdef RT_OS_LINUX
2908 if ((ioctl(fileHandle, CDROMSUBCHNL, &cdChannelInfo) == 0) ||
2909 (errno == EIO) || (errno == ENOENT) ||
2910 (errno == EINVAL) || (errno == ENOMEDIUM))
2911#else
2912 if ((ioctl(fileHandle, CDROMSUBCHNL, &cdChannelInfo) == 0) ||
2913 (errno == EIO) || (errno == ENOENT) ||
2914 (errno == EINVAL))
2915#endif
2916 {
2917 retValue = true;
2918 }
2919 close(fileHandle);
2920 }
2921 }
2922 } else
2923 {
2924 // floppy case
2925 if (S_ISCHR(statInfo.st_mode) || S_ISBLK(statInfo.st_mode))
2926 {
2927 /// @todo do some more testing, maybe a nice IOCTL!
2928 retValue = true;
2929 }
2930 }
2931 }
2932 return retValue;
2933}
2934#endif // RT_OS_SOLARIS
2935
2936#ifdef VBOX_WITH_USB
2937/**
2938 * Checks for the presence and status of the USB Proxy Service.
2939 * Returns S_OK when the Proxy is present and OK, VBOX_E_HOST_ERROR (as a
2940 * warning) if the proxy service is not available due to the way the host is
2941 * configured (at present, that means that usbfs and hal/DBus are not
2942 * available on a Linux host) or E_FAIL and a corresponding error message
2943 * otherwise. Intended to be used by methods that rely on the Proxy Service
2944 * availability.
2945 *
2946 * @note This method may return a warning result code. It is recommended to use
2947 * MultiError to store the return value.
2948 *
2949 * @note Locks this object for reading.
2950 */
2951HRESULT Host::i_checkUSBProxyService()
2952{
2953 AutoCaller autoCaller(this);
2954 if (FAILED(autoCaller.rc()))
2955 return autoCaller.rc();
2956
2957 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2958
2959 AssertReturn(m->pUSBProxyService, E_FAIL);
2960 if (!m->pUSBProxyService->isActive())
2961 {
2962 /* disable the USB controller completely to avoid assertions if the
2963 * USB proxy service could not start. */
2964
2965 switch (m->pUSBProxyService->getLastError())
2966 {
2967 case VERR_FILE_NOT_FOUND: /** @todo what does this mean? */
2968 return setWarning(E_FAIL,
2969 tr("Could not load the Host USB Proxy Service (VERR_FILE_NOT_FOUND). The service might not be installed on the host computer"));
2970 case VERR_VUSB_USB_DEVICE_PERMISSION:
2971 return setWarning(E_FAIL,
2972 tr("VirtualBox is not currently allowed to access USB devices. You can change this by adding your user to the 'vboxusers' group. Please see the user manual for a more detailed explanation"));
2973 case VERR_VUSB_USBFS_PERMISSION:
2974 return setWarning(E_FAIL,
2975 tr("VirtualBox is not currently allowed to access USB devices. You can change this by allowing your user to access the 'usbfs' folder and files. Please see the user manual for a more detailed explanation"));
2976 case VINF_SUCCESS:
2977 return setWarning(E_FAIL,
2978 tr("The USB Proxy Service has not yet been ported to this host"));
2979 default:
2980 return setWarning(E_FAIL, "%s: %Rrc",
2981 tr("Could not load the Host USB Proxy service"),
2982 m->pUSBProxyService->getLastError());
2983 }
2984 }
2985
2986 return S_OK;
2987}
2988#endif /* VBOX_WITH_USB */
2989
2990HRESULT Host::i_updateNetIfList()
2991{
2992#ifdef VBOX_WITH_HOSTNETIF_API
2993 AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
2994
2995 /** @todo r=klaus it would save lots of clock cycles if for concurrent
2996 * threads executing this code we'd only do one interface enumeration
2997 * and update, and let the other threads use the result as is. However
2998 * if there's a constant hammering of this method, we don't want this
2999 * to cause update starvation. */
3000 HostNetworkInterfaceList list;
3001 int rc = NetIfList(list);
3002 if (rc)
3003 {
3004 Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
3005 return E_FAIL;
3006 }
3007
3008 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3009
3010 AssertReturn(m->pParent, E_FAIL);
3011 /* Make a copy as the original may be partially destroyed later. */
3012 HostNetworkInterfaceList listCopy(list);
3013 HostNetworkInterfaceList::iterator itOld, itNew;
3014# ifdef VBOX_WITH_RESOURCE_USAGE_API
3015 PerformanceCollector *aCollector = m->pParent->i_performanceCollector();
3016# endif
3017 for (itOld = m->llNetIfs.begin(); itOld != m->llNetIfs.end(); ++itOld)
3018 {
3019 bool fGone = true;
3020 Bstr nameOld;
3021 (*itOld)->COMGETTER(Name)(nameOld.asOutParam());
3022 for (itNew = listCopy.begin(); itNew != listCopy.end(); ++itNew)
3023 {
3024 Bstr nameNew;
3025 (*itNew)->COMGETTER(Name)(nameNew.asOutParam());
3026 if (nameNew == nameOld)
3027 {
3028 fGone = false;
3029 (*itNew)->uninit();
3030 listCopy.erase(itNew);
3031 break;
3032 }
3033 }
3034 if (fGone)
3035 {
3036# ifdef VBOX_WITH_RESOURCE_USAGE_API
3037 (*itOld)->i_unregisterMetrics(aCollector, this);
3038 (*itOld)->uninit();
3039# endif
3040 }
3041 }
3042 /*
3043 * Need to set the references to VirtualBox object in all interface objects
3044 * (see @bugref{6439}).
3045 */
3046 for (itNew = list.begin(); itNew != list.end(); ++itNew)
3047 (*itNew)->i_setVirtualBox(m->pParent);
3048 /* At this point listCopy will contain newly discovered interfaces only. */
3049 for (itNew = listCopy.begin(); itNew != listCopy.end(); ++itNew)
3050 {
3051 HostNetworkInterfaceType_T t;
3052 HRESULT hrc = (*itNew)->COMGETTER(InterfaceType)(&t);
3053 if (FAILED(hrc))
3054 {
3055 Bstr n;
3056 (*itNew)->COMGETTER(Name)(n.asOutParam());
3057 LogRel(("Host::updateNetIfList: failed to get interface type for %ls\n", n.raw()));
3058 }
3059 else if (t == HostNetworkInterfaceType_Bridged)
3060 {
3061# ifdef VBOX_WITH_RESOURCE_USAGE_API
3062 (*itNew)->i_registerMetrics(aCollector, this);
3063# endif
3064 }
3065 }
3066 m->llNetIfs = list;
3067 return S_OK;
3068#else
3069 return E_NOTIMPL;
3070#endif
3071}
3072
3073#ifdef VBOX_WITH_RESOURCE_USAGE_API
3074
3075void Host::i_registerDiskMetrics(PerformanceCollector *aCollector)
3076{
3077 pm::CollectorHAL *hal = aCollector->getHAL();
3078 /* Create sub metrics */
3079 Utf8StrFmt fsNameBase("FS/{%s}/Usage", "/");
3080 //Utf8StrFmt fsNameBase("Filesystem/[root]/Usage");
3081 pm::SubMetric *fsRootUsageTotal = new pm::SubMetric(fsNameBase + "/Total",
3082 "Root file system size.");
3083 pm::SubMetric *fsRootUsageUsed = new pm::SubMetric(fsNameBase + "/Used",
3084 "Root file system space currently occupied.");
3085 pm::SubMetric *fsRootUsageFree = new pm::SubMetric(fsNameBase + "/Free",
3086 "Root file system space currently empty.");
3087
3088 pm::BaseMetric *fsRootUsage = new pm::HostFilesystemUsage(hal, this,
3089 fsNameBase, "/",
3090 fsRootUsageTotal,
3091 fsRootUsageUsed,
3092 fsRootUsageFree);
3093 aCollector->registerBaseMetric(fsRootUsage);
3094
3095 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal, 0));
3096 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
3097 new pm::AggregateAvg()));
3098 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
3099 new pm::AggregateMin()));
3100 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
3101 new pm::AggregateMax()));
3102
3103 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed, 0));
3104 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
3105 new pm::AggregateAvg()));
3106 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
3107 new pm::AggregateMin()));
3108 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
3109 new pm::AggregateMax()));
3110
3111 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree, 0));
3112 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
3113 new pm::AggregateAvg()));
3114 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
3115 new pm::AggregateMin()));
3116 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
3117 new pm::AggregateMax()));
3118
3119 /* For now we are concerned with the root file system only. */
3120 pm::DiskList disksUsage, disksLoad;
3121 int rc = hal->getDiskListByFs("/", disksUsage, disksLoad);
3122 if (RT_FAILURE(rc))
3123 return;
3124 pm::DiskList::iterator it;
3125 for (it = disksLoad.begin(); it != disksLoad.end(); ++it)
3126 {
3127 Utf8StrFmt strName("Disk/%s", it->c_str());
3128 pm::SubMetric *fsLoadUtil = new pm::SubMetric(strName + "/Load/Util",
3129 "Percentage of time disk was busy serving I/O requests.");
3130 pm::BaseMetric *fsLoad = new pm::HostDiskLoadRaw(hal, this, strName + "/Load",
3131 *it, fsLoadUtil);
3132 aCollector->registerBaseMetric(fsLoad);
3133
3134 aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil, 0));
3135 aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
3136 new pm::AggregateAvg()));
3137 aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
3138 new pm::AggregateMin()));
3139 aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
3140 new pm::AggregateMax()));
3141 }
3142 for (it = disksUsage.begin(); it != disksUsage.end(); ++it)
3143 {
3144 Utf8StrFmt strName("Disk/%s", it->c_str());
3145 pm::SubMetric *fsUsageTotal = new pm::SubMetric(strName + "/Usage/Total",
3146 "Disk size.");
3147 pm::BaseMetric *fsUsage = new pm::HostDiskUsage(hal, this, strName + "/Usage",
3148 *it, fsUsageTotal);
3149 aCollector->registerBaseMetric(fsUsage);
3150
3151 aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal, 0));
3152 aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal,
3153 new pm::AggregateAvg()));
3154 aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal,
3155 new pm::AggregateMin()));
3156 aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal,
3157 new pm::AggregateMax()));
3158 }
3159}
3160
3161void Host::i_registerMetrics(PerformanceCollector *aCollector)
3162{
3163 pm::CollectorHAL *hal = aCollector->getHAL();
3164 /* Create sub metrics */
3165 pm::SubMetric *cpuLoadUser = new pm::SubMetric("CPU/Load/User",
3166 "Percentage of processor time spent in user mode.");
3167 pm::SubMetric *cpuLoadKernel = new pm::SubMetric("CPU/Load/Kernel",
3168 "Percentage of processor time spent in kernel mode.");
3169 pm::SubMetric *cpuLoadIdle = new pm::SubMetric("CPU/Load/Idle",
3170 "Percentage of processor time spent idling.");
3171 pm::SubMetric *cpuMhzSM = new pm::SubMetric("CPU/MHz",
3172 "Average of current frequency of all processors.");
3173 pm::SubMetric *ramUsageTotal = new pm::SubMetric("RAM/Usage/Total",
3174 "Total physical memory installed.");
3175 pm::SubMetric *ramUsageUsed = new pm::SubMetric("RAM/Usage/Used",
3176 "Physical memory currently occupied.");
3177 pm::SubMetric *ramUsageFree = new pm::SubMetric("RAM/Usage/Free",
3178 "Physical memory currently available to applications.");
3179 pm::SubMetric *ramVMMUsed = new pm::SubMetric("RAM/VMM/Used",
3180 "Total physical memory used by the hypervisor.");
3181 pm::SubMetric *ramVMMFree = new pm::SubMetric("RAM/VMM/Free",
3182 "Total physical memory free inside the hypervisor.");
3183 pm::SubMetric *ramVMMBallooned = new pm::SubMetric("RAM/VMM/Ballooned",
3184 "Total physical memory ballooned by the hypervisor.");
3185 pm::SubMetric *ramVMMShared = new pm::SubMetric("RAM/VMM/Shared",
3186 "Total physical memory shared between VMs.");
3187
3188
3189 /* Create and register base metrics */
3190 pm::BaseMetric *cpuLoad = new pm::HostCpuLoadRaw(hal, this, cpuLoadUser, cpuLoadKernel,
3191 cpuLoadIdle);
3192 aCollector->registerBaseMetric(cpuLoad);
3193 pm::BaseMetric *cpuMhz = new pm::HostCpuMhz(hal, this, cpuMhzSM);
3194 aCollector->registerBaseMetric(cpuMhz);
3195 pm::BaseMetric *ramUsage = new pm::HostRamUsage(hal, this,
3196 ramUsageTotal,
3197 ramUsageUsed,
3198 ramUsageFree);
3199 aCollector->registerBaseMetric(ramUsage);
3200 pm::BaseMetric *ramVmm = new pm::HostRamVmm(aCollector->getGuestManager(), this,
3201 ramVMMUsed,
3202 ramVMMFree,
3203 ramVMMBallooned,
3204 ramVMMShared);
3205 aCollector->registerBaseMetric(ramVmm);
3206
3207 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser, 0));
3208 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
3209 new pm::AggregateAvg()));
3210 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
3211 new pm::AggregateMin()));
3212 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
3213 new pm::AggregateMax()));
3214
3215 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel, 0));
3216 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
3217 new pm::AggregateAvg()));
3218 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
3219 new pm::AggregateMin()));
3220 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
3221 new pm::AggregateMax()));
3222
3223 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle, 0));
3224 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
3225 new pm::AggregateAvg()));
3226 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
3227 new pm::AggregateMin()));
3228 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
3229 new pm::AggregateMax()));
3230
3231 aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM, 0));
3232 aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
3233 new pm::AggregateAvg()));
3234 aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
3235 new pm::AggregateMin()));
3236 aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
3237 new pm::AggregateMax()));
3238
3239 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal, 0));
3240 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
3241 new pm::AggregateAvg()));
3242 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
3243 new pm::AggregateMin()));
3244 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
3245 new pm::AggregateMax()));
3246
3247 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed, 0));
3248 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
3249 new pm::AggregateAvg()));
3250 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
3251 new pm::AggregateMin()));
3252 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
3253 new pm::AggregateMax()));
3254
3255 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree, 0));
3256 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
3257 new pm::AggregateAvg()));
3258 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
3259 new pm::AggregateMin()));
3260 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
3261 new pm::AggregateMax()));
3262
3263 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed, 0));
3264 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed,
3265 new pm::AggregateAvg()));
3266 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed,
3267 new pm::AggregateMin()));
3268 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed,
3269 new pm::AggregateMax()));
3270
3271 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree, 0));
3272 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree,
3273 new pm::AggregateAvg()));
3274 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree,
3275 new pm::AggregateMin()));
3276 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree,
3277 new pm::AggregateMax()));
3278
3279 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned, 0));
3280 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned,
3281 new pm::AggregateAvg()));
3282 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned,
3283 new pm::AggregateMin()));
3284 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned,
3285 new pm::AggregateMax()));
3286
3287 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared, 0));
3288 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared,
3289 new pm::AggregateAvg()));
3290 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared,
3291 new pm::AggregateMin()));
3292 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared,
3293 new pm::AggregateMax()));
3294 i_registerDiskMetrics(aCollector);
3295}
3296
3297void Host::i_unregisterMetrics(PerformanceCollector *aCollector)
3298{
3299 aCollector->unregisterMetricsFor(this);
3300 aCollector->unregisterBaseMetricsFor(this);
3301}
3302
3303#endif /* VBOX_WITH_RESOURCE_USAGE_API */
3304
3305
3306/* static */
3307void Host::i_generateMACAddress(Utf8Str &mac)
3308{
3309 /*
3310 * Our strategy is as follows: the first three bytes are our fixed
3311 * vendor ID (080027). The remaining 3 bytes will be taken from the
3312 * start of a GUID. This is a fairly safe algorithm.
3313 */
3314 Guid guid;
3315 guid.create();
3316 mac = Utf8StrFmt("080027%02X%02X%02X",
3317 guid.raw()->au8[0], guid.raw()->au8[1], guid.raw()->au8[2]);
3318}
3319
3320/* vi: set tabstop=4 shiftwidth=4 expandtab: */
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