VirtualBox

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

Last change on this file since 63378 was 63311, checked in by vboxsync, 8 years ago

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