VirtualBox

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

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

scm: cleaning up todos
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 116.8 KB
Line 
1/* $Id: HostImpl.cpp 63563 2016-08-16 14:04:28Z 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 RT_NOREF(aNetworkInterfaces);
815 ReturnComNotImplemented();
816#endif
817}
818
819HRESULT Host::getUSBDevices(std::vector<ComPtr<IHostUSBDevice> > &aUSBDevices)
820{
821#ifdef VBOX_WITH_USB
822 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
823
824 MultiResult rc = i_checkUSBProxyService();
825 if (FAILED(rc))
826 return rc;
827
828 return m->pUSBProxyService->getDeviceCollection(aUSBDevices);
829#else
830 /* Note: The GUI depends on this method returning E_NOTIMPL with no
831 * extended error info to indicate that USB is simply not available
832 * (w/o treating it as a failure), for example, as in OSE. */
833 NOREF(aUSBDevices);
834# ifndef RT_OS_WINDOWS
835 NOREF(aUSBDevices);
836# endif
837 ReturnComNotImplemented();
838#endif
839}
840
841/**
842 * This method return the list of registered name servers
843 */
844HRESULT Host::getNameServers(std::vector<com::Utf8Str> &aNameServers)
845{
846 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
847 return m->hostDnsMonitorProxy.GetNameServers(aNameServers);
848}
849
850
851/**
852 * This method returns the domain name of the host
853 */
854HRESULT Host::getDomainName(com::Utf8Str &aDomainName)
855{
856 /* XXX: note here should be synchronization with thread polling state
857 * changes in name resoving system on host */
858 return m->hostDnsMonitorProxy.GetDomainName(&aDomainName);
859}
860
861
862/**
863 * This method returns the search string.
864 */
865HRESULT Host::getSearchStrings(std::vector<com::Utf8Str> &aSearchStrings)
866{
867 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
868 return m->hostDnsMonitorProxy.GetSearchStrings(aSearchStrings);
869}
870
871HRESULT Host::getUSBDeviceFilters(std::vector<ComPtr<IHostUSBDeviceFilter> > &aUSBDeviceFilters)
872{
873#ifdef VBOX_WITH_USB
874 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
875
876 MultiResult rc = i_checkUSBProxyService();
877 if (FAILED(rc))
878 return rc;
879
880 aUSBDeviceFilters.resize(m->llUSBDeviceFilters.size());
881 size_t i = 0;
882 for (USBDeviceFilterList::iterator it = m->llUSBDeviceFilters.begin(); it != m->llUSBDeviceFilters.end(); ++it, ++i)
883 (*it).queryInterfaceTo(aUSBDeviceFilters[i].asOutParam());
884
885 return rc;
886#else
887 /* Note: The GUI depends on this method returning E_NOTIMPL with no
888 * extended error info to indicate that USB is simply not available
889 * (w/o treating it as a failure), for example, as in OSE. */
890 NOREF(aUSBDeviceFilters);
891# ifndef RT_OS_WINDOWS
892 NOREF(aUSBDeviceFilters);
893# endif
894 ReturnComNotImplemented();
895#endif
896}
897
898/**
899 * Returns the number of installed logical processors
900 *
901 * @returns COM status code
902 * @param count address of result variable
903 */
904
905HRESULT Host::getProcessorCount(ULONG *aCount)
906{
907 // no locking required
908
909 *aCount = RTMpGetPresentCount();
910 return S_OK;
911}
912
913/**
914 * Returns the number of online logical processors
915 *
916 * @returns COM status code
917 * @param count address of result variable
918 */
919HRESULT Host::getProcessorOnlineCount(ULONG *aCount)
920{
921 // no locking required
922
923 *aCount = RTMpGetOnlineCount();
924 return S_OK;
925}
926
927/**
928 * Returns the number of installed physical processor cores.
929 *
930 * @returns COM status code
931 * @param count address of result variable
932 */
933HRESULT Host::getProcessorCoreCount(ULONG *aCount)
934{
935 // no locking required
936
937 *aCount = RTMpGetPresentCoreCount();
938 return S_OK;
939}
940
941/**
942 * Returns the number of installed physical processor cores.
943 *
944 * @returns COM status code
945 * @param count address of result variable
946 */
947HRESULT Host::getProcessorOnlineCoreCount(ULONG *aCount)
948{
949 // no locking required
950
951 *aCount = RTMpGetOnlineCoreCount();
952 return S_OK;
953}
954
955/**
956 * Returns the (approximate) maximum speed of the given host CPU in MHz
957 *
958 * @returns COM status code
959 * @param cpu id to get info for.
960 * @param speed address of result variable, speed is 0 if unknown or aCpuId is invalid.
961 */
962HRESULT Host::getProcessorSpeed(ULONG aCpuId,
963 ULONG *aSpeed)
964{
965 // no locking required
966
967 *aSpeed = RTMpGetMaxFrequency(aCpuId);
968 return S_OK;
969}
970
971/**
972 * Returns a description string for the host CPU
973 *
974 * @returns COM status code
975 * @param cpu id to get info for.
976 * @param description address of result variable, empty string if not known or aCpuId is invalid.
977 */
978HRESULT Host::getProcessorDescription(ULONG aCpuId, com::Utf8Str &aDescription)
979{
980 // no locking required
981
982 char szCPUModel[80];
983 szCPUModel[0] = 0;
984 int vrc = RTMpGetDescription(aCpuId, szCPUModel, sizeof(szCPUModel));
985 if (RT_FAILURE(vrc))
986 return E_FAIL; /** @todo error reporting? */
987
988 aDescription = Utf8Str(szCPUModel);
989
990 return S_OK;
991}
992
993/**
994 * Returns whether a host processor feature is supported or not
995 *
996 * @returns COM status code
997 * @param Feature to query.
998 * @param address of supported bool result variable
999 */
1000HRESULT Host::getProcessorFeature(ProcessorFeature_T aFeature, BOOL *aSupported)
1001{
1002 /* Validate input. */
1003 switch (aFeature)
1004 {
1005 case ProcessorFeature_HWVirtEx:
1006 case ProcessorFeature_PAE:
1007 case ProcessorFeature_LongMode:
1008 case ProcessorFeature_NestedPaging:
1009 break;
1010 default:
1011 return setError(E_INVALIDARG, tr("The aFeature value %d (%#x) is out of range."), (int)aFeature, (int)aFeature);
1012 }
1013
1014 /* Do the job. */
1015 AutoCaller autoCaller(this);
1016 HRESULT hrc = autoCaller.rc();
1017 if (SUCCEEDED(hrc))
1018 {
1019 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1020
1021 if ( m->fRecheckVTSupported
1022 && ( aFeature == ProcessorFeature_HWVirtEx
1023 || aFeature == ProcessorFeature_NestedPaging)
1024 )
1025 {
1026 alock.release();
1027
1028 /* Perhaps the driver is available now... */
1029 int rc = SUPR3InitEx(false /*fUnrestricted*/, NULL);
1030 if (RT_SUCCESS(rc))
1031 {
1032 uint32_t fVTCaps;
1033 rc = SUPR3QueryVTCaps(&fVTCaps);
1034
1035 AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);
1036 if (RT_SUCCESS(rc))
1037 {
1038 Assert(fVTCaps & (SUPVTCAPS_AMD_V | SUPVTCAPS_VT_X));
1039 if (fVTCaps & SUPVTCAPS_NESTED_PAGING)
1040 m->fNestedPagingSupported = true;
1041 else
1042 Assert(m->fNestedPagingSupported == false);
1043 }
1044 else
1045 {
1046 LogRel(("SUPR0QueryVTCaps -> %Rrc\n", rc));
1047 m->fVTSupported = m->fNestedPagingSupported = true;
1048 }
1049 rc = SUPR3Term(false);
1050 AssertRC(rc);
1051 m->fRecheckVTSupported = false; /* No need to try again, we cached everything. */
1052 }
1053
1054 alock.acquire();
1055 }
1056
1057 switch (aFeature)
1058 {
1059 case ProcessorFeature_HWVirtEx:
1060 *aSupported = m->fVTSupported;
1061 break;
1062
1063 case ProcessorFeature_PAE:
1064 *aSupported = m->fPAESupported;
1065 break;
1066
1067 case ProcessorFeature_LongMode:
1068 *aSupported = m->fLongModeSupported;
1069 break;
1070
1071 case ProcessorFeature_NestedPaging:
1072 *aSupported = m->fNestedPagingSupported;
1073 break;
1074
1075 default:
1076 AssertFailed();
1077 }
1078 }
1079 return hrc;
1080}
1081
1082/**
1083 * Returns the specific CPUID leaf.
1084 *
1085 * @returns COM status code
1086 * @param aCpuId The CPU number. Mostly ignored.
1087 * @param aLeaf The leaf number.
1088 * @param aSubLeaf The sub-leaf number.
1089 * @param aValEAX Where to return EAX.
1090 * @param aValEBX Where to return EBX.
1091 * @param aValECX Where to return ECX.
1092 * @param aValEDX Where to return EDX.
1093 */
1094HRESULT Host::getProcessorCPUIDLeaf(ULONG aCpuId, ULONG aLeaf, ULONG aSubLeaf,
1095 ULONG *aValEAX, ULONG *aValEBX, ULONG *aValECX, ULONG *aValEDX)
1096{
1097 // no locking required
1098
1099 /* Check that the CPU is online. */
1100 /** @todo later use RTMpOnSpecific. */
1101 if (!RTMpIsCpuOnline(aCpuId))
1102 return RTMpIsCpuPresent(aCpuId)
1103 ? setError(E_FAIL, tr("CPU no.%u is not present"), aCpuId)
1104 : setError(E_FAIL, tr("CPU no.%u is not online"), aCpuId);
1105
1106 uint32_t uEAX, uEBX, uECX, uEDX;
1107 ASMCpuId_Idx_ECX(aLeaf, aSubLeaf, &uEAX, &uEBX, &uECX, &uEDX);
1108 *aValEAX = uEAX;
1109 *aValEBX = uEBX;
1110 *aValECX = uECX;
1111 *aValEDX = uEDX;
1112
1113 return S_OK;
1114}
1115
1116/**
1117 * Returns the amount of installed system memory in megabytes
1118 *
1119 * @returns COM status code
1120 * @param size address of result variable
1121 */
1122HRESULT Host::getMemorySize(ULONG *aSize)
1123{
1124 // no locking required
1125
1126 uint64_t cb;
1127 int rc = RTSystemQueryTotalRam(&cb);
1128 if (RT_FAILURE(rc))
1129 return E_FAIL;
1130 *aSize = (ULONG)(cb / _1M);
1131 return S_OK;
1132}
1133
1134/**
1135 * Returns the current system memory free space in megabytes
1136 *
1137 * @returns COM status code
1138 * @param available address of result variable
1139 */
1140HRESULT Host::getMemoryAvailable(ULONG *aAvailable)
1141{
1142 // no locking required
1143
1144 uint64_t cb;
1145 int rc = RTSystemQueryAvailableRam(&cb);
1146 if (RT_FAILURE(rc))
1147 return E_FAIL;
1148 *aAvailable = (ULONG)(cb / _1M);
1149 return S_OK;
1150}
1151
1152/**
1153 * Returns the name string of the host operating system
1154 *
1155 * @returns COM status code
1156 * @param os address of result variable
1157 */
1158HRESULT Host::getOperatingSystem(com::Utf8Str &aOperatingSystem)
1159{
1160 // no locking required
1161
1162 char szOSName[80];
1163 int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szOSName, sizeof(szOSName));
1164 if (RT_FAILURE(vrc))
1165 return E_FAIL; /** @todo error reporting? */
1166 aOperatingSystem = Utf8Str(szOSName);
1167 return S_OK;
1168}
1169
1170/**
1171 * Returns the version string of the host operating system
1172 *
1173 * @returns COM status code
1174 * @param os address of result variable
1175 */
1176HRESULT Host::getOSVersion(com::Utf8Str &aVersion)
1177{
1178 // no locking required
1179
1180 /* Get the OS release. Reserve some buffer space for the service pack. */
1181 char szOSRelease[128];
1182 int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szOSRelease, sizeof(szOSRelease) - 32);
1183 if (RT_FAILURE(vrc))
1184 return E_FAIL; /** @todo error reporting? */
1185
1186 /* Append the service pack if present. */
1187 char szOSServicePack[80];
1188 vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szOSServicePack, sizeof(szOSServicePack));
1189 if (RT_FAILURE(vrc))
1190 {
1191 if (vrc != VERR_NOT_SUPPORTED)
1192 return E_FAIL; /** @todo error reporting? */
1193 szOSServicePack[0] = '\0';
1194 }
1195 if (szOSServicePack[0] != '\0')
1196 {
1197 char *psz = strchr(szOSRelease, '\0');
1198 RTStrPrintf(psz, &szOSRelease[sizeof(szOSRelease)] - psz, "sp%s", szOSServicePack);
1199 }
1200
1201 aVersion = szOSRelease;
1202 return S_OK;
1203}
1204
1205/**
1206 * Returns the current host time in milliseconds since 1970-01-01 UTC.
1207 *
1208 * @returns COM status code
1209 * @param time address of result variable
1210 */
1211HRESULT Host::getUTCTime(LONG64 *aUTCTime)
1212{
1213 // no locking required
1214
1215 RTTIMESPEC now;
1216 *aUTCTime = RTTimeSpecGetMilli(RTTimeNow(&now));
1217
1218 return S_OK;
1219}
1220
1221
1222HRESULT Host::getAcceleration3DAvailable(BOOL *aSupported)
1223{
1224 HRESULT hrc = S_OK;
1225 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1226 if (m->f3DAccelerationSupported != -1)
1227 *aSupported = m->f3DAccelerationSupported;
1228 else
1229 {
1230 alock.release();
1231
1232#ifdef VBOX_WITH_CROGL
1233 bool fSupported = VBoxOglIs3DAccelerationSupported();
1234#else
1235 bool fSupported = false; /* shoudn't get here, but just in case. */
1236#endif
1237 AutoWriteLock alock2(this COMMA_LOCKVAL_SRC_POS);
1238
1239 m->f3DAccelerationSupported = fSupported;
1240 alock2.release();
1241 *aSupported = fSupported;
1242 }
1243
1244#ifdef DEBUG_misha
1245 AssertMsgFailed(("should not be here any more!\n"));
1246#endif
1247
1248 return hrc;
1249}
1250
1251HRESULT Host::createHostOnlyNetworkInterface(ComPtr<IHostNetworkInterface> &aHostInterface,
1252 ComPtr<IProgress> &aProgress)
1253
1254{
1255#ifdef VBOX_WITH_HOSTNETIF_API
1256 /* No need to lock anything. If there ever will - watch out, the function
1257 * called below grabs the VirtualBox lock. */
1258
1259 int r = NetIfCreateHostOnlyNetworkInterface(m->pParent, aHostInterface.asOutParam(), aProgress.asOutParam());
1260 if (RT_SUCCESS(r))
1261 {
1262 if (aHostInterface.isNull())
1263 return setError(E_FAIL,
1264 tr("Unable to create a host network interface"));
1265
1266#if !defined(RT_OS_WINDOWS)
1267 Bstr tmpAddr, tmpMask, tmpName;
1268 HRESULT hrc;
1269 hrc = aHostInterface->COMGETTER(Name)(tmpName.asOutParam());
1270 ComAssertComRCRet(hrc, hrc);
1271 hrc = aHostInterface->COMGETTER(IPAddress)(tmpAddr.asOutParam());
1272 ComAssertComRCRet(hrc, hrc);
1273 hrc = aHostInterface->COMGETTER(NetworkMask)(tmpMask.asOutParam());
1274 ComAssertComRCRet(hrc, hrc);
1275 /*
1276 * We need to write the default IP address and mask to extra data now,
1277 * so the interface gets re-created after vboxnetadp.ko reload.
1278 * Note that we avoid calling EnableStaticIpConfig since it would
1279 * change the address on host's interface as well and we want to
1280 * postpone the change until VM actually starts.
1281 */
1282 hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress",
1283 tmpName.raw()).raw(),
1284 tmpAddr.raw());
1285 ComAssertComRCRet(hrc, hrc);
1286
1287 hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask",
1288 tmpName.raw()).raw(),
1289 tmpMask.raw());
1290 ComAssertComRCRet(hrc, hrc);
1291#endif
1292 }
1293
1294 return S_OK;
1295#else
1296 return E_NOTIMPL;
1297#endif
1298}
1299
1300HRESULT Host::removeHostOnlyNetworkInterface(const com::Guid &aId,
1301 ComPtr<IProgress> &aProgress)
1302
1303{
1304#ifdef VBOX_WITH_HOSTNETIF_API
1305 /* No need to lock anything, the code below does not touch the state
1306 * of the host object. If that ever changes then check for lock order
1307 * violations with the called functions. */
1308
1309 Bstr name;
1310 HRESULT rc;
1311
1312 /* first check whether an interface with the given name already exists */
1313 {
1314 ComPtr<IHostNetworkInterface> iface;
1315 rc = findHostNetworkInterfaceById(aId, iface);
1316 if (FAILED(rc))
1317 return setError(VBOX_E_OBJECT_NOT_FOUND,
1318 tr("Host network interface with UUID {%RTuuid} does not exist"),
1319 Guid(aId).raw());
1320 rc = iface->COMGETTER(Name)(name.asOutParam());
1321 ComAssertComRCRet(rc, rc);
1322 }
1323
1324 int r = NetIfRemoveHostOnlyNetworkInterface(m->pParent, Guid(aId).ref(), aProgress.asOutParam());
1325 if (RT_SUCCESS(r))
1326 {
1327 /* Drop configuration parameters for removed interface */
1328 rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", name.raw()).raw(), NULL);
1329 rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", name.raw()).raw(), NULL);
1330 rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", name.raw()).raw(), NULL);
1331 rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPV6NetMask", name.raw()).raw(), NULL);
1332
1333 return S_OK;
1334 }
1335
1336 return r == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
1337#else
1338 return E_NOTIMPL;
1339#endif
1340}
1341
1342HRESULT Host::createUSBDeviceFilter(const com::Utf8Str &aName,
1343 ComPtr<IHostUSBDeviceFilter> &aFilter)
1344{
1345#ifdef VBOX_WITH_USB
1346
1347 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1348
1349 ComObjPtr<HostUSBDeviceFilter> filter;
1350 filter.createObject();
1351 HRESULT rc = filter->init(this, Bstr(aName).raw());
1352 ComAssertComRCRet(rc, rc);
1353 rc = filter.queryInterfaceTo(aFilter.asOutParam());
1354 AssertComRCReturn(rc, rc);
1355 return S_OK;
1356#else
1357 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1358 * extended error info to indicate that USB is simply not available
1359 * (w/o treating it as a failure), for example, as in OSE. */
1360 NOREF(aName);
1361 NOREF(aFilter);
1362 ReturnComNotImplemented();
1363#endif
1364}
1365
1366HRESULT Host::insertUSBDeviceFilter(ULONG aPosition,
1367 const ComPtr<IHostUSBDeviceFilter> &aFilter)
1368{
1369#ifdef VBOX_WITH_USB
1370 /* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
1371
1372 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1373
1374 MultiResult rc = i_checkUSBProxyService();
1375 if (FAILED(rc))
1376 return rc;
1377
1378 ComObjPtr<HostUSBDeviceFilter> pFilter;
1379 for (USBDeviceFilterList::iterator it = m->llChildren.begin();
1380 it != m->llChildren.end();
1381 ++it)
1382 {
1383 if (*it == aFilter)
1384 {
1385 pFilter = *it;
1386 break;
1387 }
1388 }
1389 if (pFilter.isNull())
1390 return setError(VBOX_E_INVALID_OBJECT_STATE,
1391 tr("The given USB device filter is not created within this VirtualBox instance"));
1392
1393 if (pFilter->mInList)
1394 return setError(E_INVALIDARG,
1395 tr("The given USB device filter is already in the list"));
1396
1397 /* iterate to the position... */
1398 USBDeviceFilterList::iterator itPos = m->llUSBDeviceFilters.begin();
1399 std::advance(itPos, aPosition);
1400 /* ...and insert */
1401 m->llUSBDeviceFilters.insert(itPos, pFilter);
1402 pFilter->mInList = true;
1403
1404 /* notify the proxy (only when the filter is active) */
1405 if ( m->pUSBProxyService->isActive()
1406 && pFilter->i_getData().mData.fActive)
1407 {
1408 ComAssertRet(pFilter->i_getId() == NULL, E_FAIL);
1409 pFilter->i_getId() = m->pUSBProxyService->insertFilter(&pFilter->i_getData().mUSBFilter);
1410 }
1411
1412 // save the global settings; for that we should hold only the VirtualBox lock
1413 alock.release();
1414 AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
1415 return rc = m->pParent->i_saveSettings();
1416#else
1417
1418 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1419 * extended error info to indicate that USB is simply not available
1420 * (w/o treating it as a failure), for example, as in OSE. */
1421 NOREF(aPosition);
1422 NOREF(aFilter);
1423 ReturnComNotImplemented();
1424#endif
1425}
1426
1427HRESULT Host::removeUSBDeviceFilter(ULONG aPosition)
1428{
1429#ifdef VBOX_WITH_USB
1430
1431 /* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
1432 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1433
1434 MultiResult rc = i_checkUSBProxyService();
1435 if (FAILED(rc))
1436 return rc;
1437
1438 if (!m->llUSBDeviceFilters.size())
1439 return setError(E_INVALIDARG,
1440 tr("The USB device filter list is empty"));
1441
1442 if (aPosition >= m->llUSBDeviceFilters.size())
1443 return setError(E_INVALIDARG,
1444 tr("Invalid position: %lu (must be in range [0, %lu])"),
1445 aPosition, m->llUSBDeviceFilters.size() - 1);
1446
1447 ComObjPtr<HostUSBDeviceFilter> filter;
1448 {
1449 /* iterate to the position... */
1450 USBDeviceFilterList::iterator it = m->llUSBDeviceFilters.begin();
1451 std::advance(it, aPosition);
1452 /* ...get an element from there... */
1453 filter = *it;
1454 /* ...and remove */
1455 filter->mInList = false;
1456 m->llUSBDeviceFilters.erase(it);
1457 }
1458
1459 /* notify the proxy (only when the filter is active) */
1460 if (m->pUSBProxyService->isActive() && filter->i_getData().mData.fActive)
1461 {
1462 ComAssertRet(filter->i_getId() != NULL, E_FAIL);
1463 m->pUSBProxyService->removeFilter(filter->i_getId());
1464 filter->i_getId() = NULL;
1465 }
1466
1467 // save the global settings; for that we should hold only the VirtualBox lock
1468 alock.release();
1469 AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
1470 return rc = m->pParent->i_saveSettings();
1471#else
1472 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1473 * extended error info to indicate that USB is simply not available
1474 * (w/o treating it as a failure), for example, as in OSE. */
1475 NOREF(aPosition);
1476 ReturnComNotImplemented();
1477#endif
1478}
1479
1480HRESULT Host::findHostDVDDrive(const com::Utf8Str &aName,
1481 ComPtr<IMedium> &aDrive)
1482{
1483 ComObjPtr<Medium> medium;
1484 HRESULT rc = i_findHostDriveByNameOrId(DeviceType_DVD, aName, medium);
1485 if (SUCCEEDED(rc))
1486 rc = medium.queryInterfaceTo(aDrive.asOutParam());
1487 else
1488 rc = setError(rc, Medium::tr("The host DVD drive named '%s' could not be found"), aName.c_str());
1489 return rc;
1490}
1491
1492HRESULT Host::findHostFloppyDrive(const com::Utf8Str &aName, ComPtr<IMedium> &aDrive)
1493{
1494 aDrive = NULL;
1495
1496 ComObjPtr<Medium>medium;
1497
1498 HRESULT rc = i_findHostDriveByNameOrId(DeviceType_Floppy, aName, medium);
1499 if (SUCCEEDED(rc))
1500 return medium.queryInterfaceTo(aDrive.asOutParam());
1501 else
1502 return setError(rc, Medium::tr("The host floppy drive named '%s' could not be found"), aName.c_str());
1503}
1504
1505HRESULT Host::findHostNetworkInterfaceByName(const com::Utf8Str &aName,
1506 ComPtr<IHostNetworkInterface> &aNetworkInterface)
1507{
1508#ifndef VBOX_WITH_HOSTNETIF_API
1509 return E_NOTIMPL;
1510#else
1511 if (!aName.length())
1512 return E_INVALIDARG;
1513
1514 HRESULT rc = i_updateNetIfList();
1515 if (FAILED(rc))
1516 {
1517 Log(("Failed to update host network interface list with rc=%Rhrc\n", rc));
1518 return rc;
1519 }
1520
1521 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1522
1523 ComObjPtr<HostNetworkInterface> found;
1524 for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
1525 {
1526 Bstr n;
1527 (*it)->COMGETTER(Name)(n.asOutParam());
1528 if (n == aName)
1529 found = *it;
1530 }
1531
1532 if (!found)
1533 return setError(E_INVALIDARG,
1534 HostNetworkInterface::tr("The host network interface named '%s' could not be found"), aName.c_str());
1535
1536 return found.queryInterfaceTo(aNetworkInterface.asOutParam());
1537#endif
1538}
1539
1540HRESULT Host::findHostNetworkInterfaceById(const com::Guid &aId,
1541 ComPtr<IHostNetworkInterface> &aNetworkInterface)
1542{
1543#ifndef VBOX_WITH_HOSTNETIF_API
1544 return E_NOTIMPL;
1545#else
1546 if (!aId.isValid())
1547 return E_INVALIDARG;
1548
1549 HRESULT rc = i_updateNetIfList();
1550 if (FAILED(rc))
1551 {
1552 Log(("Failed to update host network interface list with rc=%Rhrc\n", rc));
1553 return rc;
1554 }
1555
1556 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1557
1558 ComObjPtr<HostNetworkInterface> found;
1559 for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
1560 {
1561 Bstr g;
1562 (*it)->COMGETTER(Id)(g.asOutParam());
1563 if (Guid(g) == aId)
1564 found = *it;
1565 }
1566
1567 if (!found)
1568 return setError(E_INVALIDARG,
1569 HostNetworkInterface::tr("The host network interface with the given GUID could not be found"));
1570 return found.queryInterfaceTo(aNetworkInterface.asOutParam());
1571
1572#endif
1573}
1574
1575HRESULT Host::findHostNetworkInterfacesOfType(HostNetworkInterfaceType_T aType,
1576 std::vector<ComPtr<IHostNetworkInterface> > &aNetworkInterfaces)
1577{
1578#ifdef VBOX_WITH_HOSTNETIF_API
1579 HRESULT rc = i_updateNetIfList();
1580 if (FAILED(rc))
1581 {
1582 Log(("Failed to update host network interface list with rc=%Rhrc\n", rc));
1583 return rc;
1584 }
1585
1586 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1587
1588 HostNetworkInterfaceList resultList;
1589 for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
1590 {
1591 HostNetworkInterfaceType_T t;
1592 HRESULT hr = (*it)->COMGETTER(InterfaceType)(&t);
1593 if (FAILED(hr))
1594 return hr;
1595
1596 if (t == aType)
1597 resultList.push_back(*it);
1598 }
1599 aNetworkInterfaces.resize(resultList.size());
1600 size_t i = 0;
1601 for (HostNetworkInterfaceList::iterator it = resultList.begin(); it != resultList.end(); ++it, ++i)
1602 {
1603 (*it).queryInterfaceTo(aNetworkInterfaces[i].asOutParam());
1604 }
1605
1606 return S_OK;
1607#else
1608 return E_NOTIMPL;
1609#endif
1610}
1611
1612HRESULT Host::findUSBDeviceByAddress(const com::Utf8Str &aName,
1613 ComPtr<IHostUSBDevice> &aDevice)
1614{
1615#ifdef VBOX_WITH_USB
1616
1617 aDevice = NULL;
1618 SafeIfaceArray<IHostUSBDevice> devsvec;
1619 HRESULT rc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
1620 if (FAILED(rc))
1621 return rc;
1622
1623 for (size_t i = 0; i < devsvec.size(); ++i)
1624 {
1625 Bstr address;
1626 rc = devsvec[i]->COMGETTER(Address)(address.asOutParam());
1627 if (FAILED(rc))
1628 return rc;
1629 if (address == aName)
1630 {
1631 return (ComPtr<IHostUSBDevice>(devsvec[i]).queryInterfaceTo(aDevice.asOutParam()));
1632 }
1633 }
1634
1635 return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
1636 tr("Could not find a USB device with address '%s'"),
1637 aName.c_str());
1638
1639#else /* !VBOX_WITH_USB */
1640 NOREF(aName);
1641 NOREF(aDevice);
1642 return E_NOTIMPL;
1643#endif /* !VBOX_WITH_USB */
1644}
1645HRESULT Host::findUSBDeviceById(const com::Guid &aId,
1646 ComPtr<IHostUSBDevice> &aDevice)
1647{
1648#ifdef VBOX_WITH_USB
1649 if (!aId.isValid())
1650 return E_INVALIDARG;
1651
1652 aDevice = NULL;
1653
1654 SafeIfaceArray<IHostUSBDevice> devsvec;
1655 HRESULT rc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
1656 if (FAILED(rc))
1657 return rc;
1658
1659 for (size_t i = 0; i < devsvec.size(); ++i)
1660 {
1661 Bstr id;
1662 rc = devsvec[i]->COMGETTER(Id)(id.asOutParam());
1663 if (FAILED(rc))
1664 return rc;
1665 if (Guid(id) == aId)
1666 {
1667 return (ComPtr<IHostUSBDevice>(devsvec[i]).queryInterfaceTo(aDevice.asOutParam()));
1668 }
1669 }
1670 return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
1671 tr("Could not find a USB device with uuid {%RTuuid}"),
1672 aId.raw());
1673
1674#else /* !VBOX_WITH_USB */
1675 NOREF(aId);
1676 NOREF(aDevice);
1677 return E_NOTIMPL;
1678#endif /* !VBOX_WITH_USB */
1679}
1680
1681HRESULT Host::generateMACAddress(com::Utf8Str &aAddress)
1682{
1683 // no locking required
1684 i_generateMACAddress(aAddress);
1685 return S_OK;
1686}
1687
1688/**
1689 * Returns a list of host video capture devices (webcams, etc).
1690 *
1691 * @returns COM status code
1692 * @param aVideoInputDevices Array of interface pointers to be filled.
1693 */
1694HRESULT Host::getVideoInputDevices(std::vector<ComPtr<IHostVideoInputDevice> > &aVideoInputDevices)
1695{
1696 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1697 HostVideoInputDeviceList list;
1698
1699 HRESULT rc = HostVideoInputDevice::queryHostDevices(m->pParent, &list);
1700 if (FAILED(rc))
1701 return rc;
1702
1703 aVideoInputDevices.resize(list.size());
1704 size_t i = 0;
1705 for (HostVideoInputDeviceList::const_iterator it = list.begin(); it != list.end(); ++it, ++i)
1706 (*it).queryInterfaceTo(aVideoInputDevices[i].asOutParam());
1707
1708 return S_OK;
1709}
1710
1711HRESULT Host::addUSBDeviceSource(const com::Utf8Str &aBackend, const com::Utf8Str &aId, const com::Utf8Str &aAddress,
1712 const std::vector<com::Utf8Str> &aPropertyNames, const std::vector<com::Utf8Str> &aPropertyValues)
1713{
1714#ifdef VBOX_WITH_USB
1715 /* The USB proxy service will do the locking. */
1716 return m->pUSBProxyService->addUSBDeviceSource(aBackend, aId, aAddress, aPropertyNames, aPropertyValues);
1717#else
1718 ReturnComNotImplemented();
1719#endif
1720}
1721
1722HRESULT Host::removeUSBDeviceSource(const com::Utf8Str &aId)
1723{
1724#ifdef VBOX_WITH_USB
1725 /* The USB proxy service will do the locking. */
1726 return m->pUSBProxyService->removeUSBDeviceSource(aId);
1727#else
1728 ReturnComNotImplemented();
1729#endif
1730}
1731
1732// public methods only for internal purposes
1733////////////////////////////////////////////////////////////////////////////////
1734
1735HRESULT Host::i_loadSettings(const settings::Host &data)
1736{
1737 HRESULT rc = S_OK;
1738#ifdef VBOX_WITH_USB
1739 AutoCaller autoCaller(this);
1740 if (FAILED(autoCaller.rc()))
1741 return autoCaller.rc();
1742
1743 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1744
1745 for (settings::USBDeviceFiltersList::const_iterator it = data.llUSBDeviceFilters.begin();
1746 it != data.llUSBDeviceFilters.end();
1747 ++it)
1748 {
1749 const settings::USBDeviceFilter &f = *it;
1750 ComObjPtr<HostUSBDeviceFilter> pFilter;
1751 pFilter.createObject();
1752 rc = pFilter->init(this, f);
1753 if (FAILED(rc))
1754 break;
1755
1756 m->llUSBDeviceFilters.push_back(pFilter);
1757 pFilter->mInList = true;
1758
1759 /* notify the proxy (only when the filter is active) */
1760 if (pFilter->i_getData().mData.fActive)
1761 {
1762 HostUSBDeviceFilter *flt = pFilter; /* resolve ambiguity */
1763 flt->i_getId() = m->pUSBProxyService->insertFilter(&pFilter->i_getData().mUSBFilter);
1764 }
1765 }
1766
1767 rc = m->pUSBProxyService->i_loadSettings(data.llUSBDeviceSources);
1768#else
1769 NOREF(data);
1770#endif /* VBOX_WITH_USB */
1771 return rc;
1772}
1773
1774HRESULT Host::i_saveSettings(settings::Host &data)
1775{
1776#ifdef VBOX_WITH_USB
1777 AutoCaller autoCaller(this);
1778 if (FAILED(autoCaller.rc()))
1779 return autoCaller.rc();
1780
1781 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1782
1783 data.llUSBDeviceFilters.clear();
1784
1785 for (USBDeviceFilterList::const_iterator it = m->llUSBDeviceFilters.begin();
1786 it != m->llUSBDeviceFilters.end();
1787 ++it)
1788 {
1789 ComObjPtr<HostUSBDeviceFilter> pFilter = *it;
1790 settings::USBDeviceFilter f;
1791 pFilter->i_saveSettings(f);
1792 data.llUSBDeviceFilters.push_back(f);
1793 }
1794
1795 return m->pUSBProxyService->i_saveSettings(data.llUSBDeviceSources);
1796#else
1797 NOREF(data);
1798 return S_OK;
1799#endif /* VBOX_WITH_USB */
1800
1801}
1802
1803/**
1804 * Sets the given pointer to point to the static list of DVD or floppy
1805 * drives in the Host instance data, depending on the @a mediumType
1806 * parameter.
1807 *
1808 * This builds the list on the first call; it adds or removes host drives
1809 * that may have changed if fRefresh == true.
1810 *
1811 * The caller must hold the medium tree write lock before calling this.
1812 * To protect the list to which the caller's pointer points, the caller
1813 * must also hold that lock.
1814 *
1815 * @param mediumType Must be DeviceType_Floppy or DeviceType_DVD.
1816 * @param fRefresh Whether to refresh the host drives list even if this is not the first call.
1817 * @param pll Caller's pointer which gets set to the static list of host drives.
1818 * @param treeLock Reference to media tree lock, need to drop it temporarily.
1819 * @returns COM status code
1820 */
1821HRESULT Host::i_getDrives(DeviceType_T mediumType,
1822 bool fRefresh,
1823 MediaList *&pll,
1824 AutoWriteLock &treeLock)
1825{
1826 HRESULT rc = S_OK;
1827 Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
1828
1829 MediaList llNew;
1830 MediaList *pllCached;
1831 bool *pfListBuilt = NULL;
1832
1833 switch (mediumType)
1834 {
1835 case DeviceType_DVD:
1836 if (!m->fDVDDrivesListBuilt || fRefresh)
1837 {
1838 rc = i_buildDVDDrivesList(llNew);
1839 if (FAILED(rc))
1840 return rc;
1841 pfListBuilt = &m->fDVDDrivesListBuilt;
1842 }
1843 pllCached = &m->llDVDDrives;
1844 break;
1845
1846 case DeviceType_Floppy:
1847 if (!m->fFloppyDrivesListBuilt || fRefresh)
1848 {
1849 rc = i_buildFloppyDrivesList(llNew);
1850 if (FAILED(rc))
1851 return rc;
1852 pfListBuilt = &m->fFloppyDrivesListBuilt;
1853 }
1854 pllCached = &m->llFloppyDrives;
1855 break;
1856
1857 default:
1858 return E_INVALIDARG;
1859 }
1860
1861 if (pfListBuilt)
1862 {
1863 // a list was built in llNew above:
1864 if (!*pfListBuilt)
1865 {
1866 // this was the first call (instance bool is still false): then just copy the whole list and return
1867 *pllCached = llNew;
1868 // and mark the instance data as "built"
1869 *pfListBuilt = true;
1870 }
1871 else
1872 {
1873 // list was built, and this was a subsequent call: then compare the old and the new lists
1874
1875 // remove drives from the cached list which are no longer present
1876 for (MediaList::iterator itCached = pllCached->begin();
1877 itCached != pllCached->end();
1878 /*nothing */)
1879 {
1880 Medium *pCached = *itCached;
1881 const Utf8Str strLocationCached = pCached->i_getLocationFull();
1882 bool fFound = false;
1883 for (MediaList::iterator itNew = llNew.begin();
1884 itNew != llNew.end();
1885 ++itNew)
1886 {
1887 Medium *pNew = *itNew;
1888 const Utf8Str strLocationNew = pNew->i_getLocationFull();
1889 if (strLocationNew == strLocationCached)
1890 {
1891 fFound = true;
1892 break;
1893 }
1894 }
1895 if (!fFound)
1896 {
1897 pCached->uninit();
1898 itCached = pllCached->erase(itCached);
1899 }
1900 else
1901 ++itCached;
1902 }
1903
1904 // add drives to the cached list that are not on there yet
1905 for (MediaList::iterator itNew = llNew.begin();
1906 itNew != llNew.end();
1907 ++itNew)
1908 {
1909 Medium *pNew = *itNew;
1910 const Utf8Str strLocationNew = pNew->i_getLocationFull();
1911 bool fFound = false;
1912 for (MediaList::iterator itCached = pllCached->begin();
1913 itCached != pllCached->end();
1914 ++itCached)
1915 {
1916 Medium *pCached = *itCached;
1917 const Utf8Str strLocationCached = pCached->i_getLocationFull();
1918 if (strLocationNew == strLocationCached)
1919 {
1920 fFound = true;
1921 break;
1922 }
1923 }
1924
1925 if (!fFound)
1926 pllCached->push_back(pNew);
1927 }
1928 }
1929 }
1930
1931 // return cached list to caller
1932 pll = pllCached;
1933
1934 // Make sure the media tree lock is released before llNew is cleared,
1935 // as this usually triggers calls to uninit().
1936 treeLock.release();
1937
1938 llNew.clear();
1939
1940 treeLock.acquire();
1941
1942 return rc;
1943}
1944
1945/**
1946 * Goes through the list of host drives that would be returned by getDrives()
1947 * and looks for a host drive with the given UUID. If found, it sets pMedium
1948 * to that drive; otherwise returns VBOX_E_OBJECT_NOT_FOUND.
1949 *
1950 * @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
1951 * @param uuid Medium UUID of host drive to look for.
1952 * @param fRefresh Whether to refresh the host drives list (see getDrives())
1953 * @param pMedium Medium object, if found...
1954 * @return VBOX_E_OBJECT_NOT_FOUND if not found, or S_OK if found, or errors from getDrives().
1955 */
1956HRESULT Host::i_findHostDriveById(DeviceType_T mediumType,
1957 const Guid &uuid,
1958 bool fRefresh,
1959 ComObjPtr<Medium> &pMedium)
1960{
1961 MediaList *pllMedia;
1962
1963 AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
1964 HRESULT rc = i_getDrives(mediumType, fRefresh, pllMedia, treeLock);
1965 if (SUCCEEDED(rc))
1966 {
1967 for (MediaList::iterator it = pllMedia->begin();
1968 it != pllMedia->end();
1969 ++it)
1970 {
1971 Medium *pThis = *it;
1972 AutoCaller mediumCaller(pThis);
1973 AutoReadLock mediumLock(pThis COMMA_LOCKVAL_SRC_POS);
1974 if (pThis->i_getId() == uuid)
1975 {
1976 pMedium = pThis;
1977 return S_OK;
1978 }
1979 }
1980 }
1981
1982 return VBOX_E_OBJECT_NOT_FOUND;
1983}
1984
1985/**
1986 * Goes through the list of host drives that would be returned by getDrives()
1987 * and looks for a host drive with the given name. If found, it sets pMedium
1988 * to that drive; otherwise returns VBOX_E_OBJECT_NOT_FOUND.
1989 *
1990 * @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
1991 * @param strLocationFull Name (path) of host drive to look for.
1992 * @param fRefresh Whether to refresh the host drives list (see getDrives())
1993 * @param pMedium Medium object, if found
1994 * @return VBOX_E_OBJECT_NOT_FOUND if not found, or S_OK if found, or errors from getDrives().
1995 */
1996HRESULT Host::i_findHostDriveByName(DeviceType_T mediumType,
1997 const Utf8Str &strLocationFull,
1998 bool fRefresh,
1999 ComObjPtr<Medium> &pMedium)
2000{
2001 MediaList *pllMedia;
2002
2003 AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
2004 HRESULT rc = i_getDrives(mediumType, fRefresh, pllMedia, treeLock);
2005 if (SUCCEEDED(rc))
2006 {
2007 for (MediaList::iterator it = pllMedia->begin();
2008 it != pllMedia->end();
2009 ++it)
2010 {
2011 Medium *pThis = *it;
2012 AutoCaller mediumCaller(pThis);
2013 AutoReadLock mediumLock(pThis COMMA_LOCKVAL_SRC_POS);
2014 if (pThis->i_getLocationFull() == strLocationFull)
2015 {
2016 pMedium = pThis;
2017 return S_OK;
2018 }
2019 }
2020 }
2021
2022 return VBOX_E_OBJECT_NOT_FOUND;
2023}
2024
2025/**
2026 * Goes through the list of host drives that would be returned by getDrives()
2027 * and looks for a host drive with the given name, location or ID. If found,
2028 * it sets pMedium to that drive; otherwise returns VBOX_E_OBJECT_NOT_FOUND.
2029 *
2030 * @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
2031 * @param strNameOrId Name or full location or UUID of host drive to look for.
2032 * @param pMedium Medium object, if found...
2033 * @return VBOX_E_OBJECT_NOT_FOUND if not found, or S_OK if found, or errors from getDrives().
2034 */
2035HRESULT Host::i_findHostDriveByNameOrId(DeviceType_T mediumType,
2036 const Utf8Str &strNameOrId,
2037 ComObjPtr<Medium> &pMedium)
2038{
2039 AutoWriteLock wlock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
2040
2041 Guid uuid(strNameOrId);
2042 if (uuid.isValid() && !uuid.isZero())
2043 return i_findHostDriveById(mediumType, uuid, true /* fRefresh */, pMedium);
2044
2045 // string is not a syntactically valid UUID: try a name then
2046 return i_findHostDriveByName(mediumType, strNameOrId, true /* fRefresh */, pMedium);
2047}
2048
2049/**
2050 * Called from getDrives() to build the DVD drives list.
2051 * @param pll
2052 * @return
2053 */
2054HRESULT Host::i_buildDVDDrivesList(MediaList &list)
2055{
2056 HRESULT rc = S_OK;
2057
2058 Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
2059
2060 try
2061 {
2062#if defined(RT_OS_WINDOWS)
2063 int sz = GetLogicalDriveStrings(0, NULL);
2064 TCHAR *hostDrives = new TCHAR[sz+1];
2065 GetLogicalDriveStrings(sz, hostDrives);
2066 wchar_t driveName[3] = { '?', ':', '\0' };
2067 TCHAR *p = hostDrives;
2068 do
2069 {
2070 if (GetDriveType(p) == DRIVE_CDROM)
2071 {
2072 driveName[0] = *p;
2073 ComObjPtr<Medium> hostDVDDriveObj;
2074 hostDVDDriveObj.createObject();
2075 hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(driveName));
2076 list.push_back(hostDVDDriveObj);
2077 }
2078 p += _tcslen(p) + 1;
2079 }
2080 while (*p);
2081 delete[] hostDrives;
2082
2083#elif defined(RT_OS_SOLARIS)
2084# ifdef VBOX_USE_LIBHAL
2085 if (!i_getDVDInfoFromHal(list))
2086# endif
2087 {
2088 i_getDVDInfoFromDevTree(list);
2089 }
2090
2091#elif defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD)
2092 if (RT_SUCCESS(m->hostDrives.updateDVDs()))
2093 for (DriveInfoList::const_iterator it = m->hostDrives.DVDBegin();
2094 SUCCEEDED(rc) && it != m->hostDrives.DVDEnd(); ++it)
2095 {
2096 ComObjPtr<Medium> hostDVDDriveObj;
2097 Utf8Str location(it->mDevice);
2098 Utf8Str description(it->mDescription);
2099 if (SUCCEEDED(rc))
2100 rc = hostDVDDriveObj.createObject();
2101 if (SUCCEEDED(rc))
2102 rc = hostDVDDriveObj->init(m->pParent, DeviceType_DVD, location, description);
2103 if (SUCCEEDED(rc))
2104 list.push_back(hostDVDDriveObj);
2105 }
2106#elif defined(RT_OS_DARWIN)
2107 PDARWINDVD cur = DarwinGetDVDDrives();
2108 while (cur)
2109 {
2110 ComObjPtr<Medium> hostDVDDriveObj;
2111 hostDVDDriveObj.createObject();
2112 hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(cur->szName));
2113 list.push_back(hostDVDDriveObj);
2114
2115 /* next */
2116 void *freeMe = cur;
2117 cur = cur->pNext;
2118 RTMemFree(freeMe);
2119 }
2120#else
2121 /* PORTME */
2122#endif
2123 }
2124 catch(std::bad_alloc &)
2125 {
2126 rc = E_OUTOFMEMORY;
2127 }
2128 return rc;
2129}
2130
2131/**
2132 * Called from getDrives() to build the floppy drives list.
2133 * @param list
2134 * @return
2135 */
2136HRESULT Host::i_buildFloppyDrivesList(MediaList &list)
2137{
2138 HRESULT rc = S_OK;
2139
2140 Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
2141
2142 try
2143 {
2144#ifdef RT_OS_WINDOWS
2145 int sz = GetLogicalDriveStrings(0, NULL);
2146 TCHAR *hostDrives = new TCHAR[sz+1];
2147 GetLogicalDriveStrings(sz, hostDrives);
2148 wchar_t driveName[3] = { '?', ':', '\0' };
2149 TCHAR *p = hostDrives;
2150 do
2151 {
2152 if (GetDriveType(p) == DRIVE_REMOVABLE)
2153 {
2154 driveName[0] = *p;
2155 ComObjPtr<Medium> hostFloppyDriveObj;
2156 hostFloppyDriveObj.createObject();
2157 hostFloppyDriveObj->init(m->pParent, DeviceType_Floppy, Bstr(driveName));
2158 list.push_back(hostFloppyDriveObj);
2159 }
2160 p += _tcslen(p) + 1;
2161 }
2162 while (*p);
2163 delete[] hostDrives;
2164#elif defined(RT_OS_LINUX)
2165 if (RT_SUCCESS(m->hostDrives.updateFloppies()))
2166 for (DriveInfoList::const_iterator it = m->hostDrives.FloppyBegin();
2167 SUCCEEDED(rc) && it != m->hostDrives.FloppyEnd(); ++it)
2168 {
2169 ComObjPtr<Medium> hostFloppyDriveObj;
2170 Utf8Str location(it->mDevice);
2171 Utf8Str description(it->mDescription);
2172 if (SUCCEEDED(rc))
2173 rc = hostFloppyDriveObj.createObject();
2174 if (SUCCEEDED(rc))
2175 rc = hostFloppyDriveObj->init(m->pParent, DeviceType_Floppy, location, description);
2176 if (SUCCEEDED(rc))
2177 list.push_back(hostFloppyDriveObj);
2178 }
2179#else
2180 NOREF(list);
2181 /* PORTME */
2182#endif
2183 }
2184 catch(std::bad_alloc &)
2185 {
2186 rc = E_OUTOFMEMORY;
2187 }
2188
2189 return rc;
2190}
2191
2192#ifdef VBOX_WITH_USB
2193USBProxyService* Host::i_usbProxyService()
2194{
2195 return m->pUSBProxyService;
2196}
2197
2198HRESULT Host::i_addChild(HostUSBDeviceFilter *pChild)
2199{
2200 AutoCaller autoCaller(this);
2201 if (FAILED(autoCaller.rc()))
2202 return autoCaller.rc();
2203
2204 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2205
2206 m->llChildren.push_back(pChild);
2207
2208 return S_OK;
2209}
2210
2211HRESULT Host::i_removeChild(HostUSBDeviceFilter *pChild)
2212{
2213 AutoCaller autoCaller(this);
2214 if (FAILED(autoCaller.rc()))
2215 return autoCaller.rc();
2216
2217 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2218
2219 for (USBDeviceFilterList::iterator it = m->llChildren.begin();
2220 it != m->llChildren.end();
2221 ++it)
2222 {
2223 if (*it == pChild)
2224 {
2225 m->llChildren.erase(it);
2226 break;
2227 }
2228 }
2229
2230 return S_OK;
2231}
2232
2233VirtualBox* Host::i_parent()
2234{
2235 return m->pParent;
2236}
2237
2238/**
2239 * Called by setter methods of all USB device filters.
2240 */
2241HRESULT Host::i_onUSBDeviceFilterChange(HostUSBDeviceFilter *aFilter,
2242 BOOL aActiveChanged /* = FALSE */)
2243{
2244 AutoCaller autoCaller(this);
2245 if (FAILED(autoCaller.rc()))
2246 return autoCaller.rc();
2247
2248 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2249
2250 if (aFilter->mInList)
2251 {
2252 if (aActiveChanged)
2253 {
2254 // insert/remove the filter from the proxy
2255 if (aFilter->i_getData().mData.fActive)
2256 {
2257 ComAssertRet(aFilter->i_getId() == NULL, E_FAIL);
2258 aFilter->i_getId() = m->pUSBProxyService->insertFilter(&aFilter->i_getData().mUSBFilter);
2259 }
2260 else
2261 {
2262 ComAssertRet(aFilter->i_getId() != NULL, E_FAIL);
2263 m->pUSBProxyService->removeFilter(aFilter->i_getId());
2264 aFilter->i_getId() = NULL;
2265 }
2266 }
2267 else
2268 {
2269 if (aFilter->i_getData().mData.fActive)
2270 {
2271 // update the filter in the proxy
2272 ComAssertRet(aFilter->i_getId() != NULL, E_FAIL);
2273 m->pUSBProxyService->removeFilter(aFilter->i_getId());
2274 aFilter->i_getId() = m->pUSBProxyService->insertFilter(&aFilter->i_getData().mUSBFilter);
2275 }
2276 }
2277
2278 // save the global settings... yeah, on every single filter property change
2279 // for that we should hold only the VirtualBox lock
2280 alock.release();
2281 AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
2282 return m->pParent->i_saveSettings();
2283 }
2284
2285 return S_OK;
2286}
2287
2288
2289/**
2290 * Interface for obtaining a copy of the USBDeviceFilterList,
2291 * used by the USBProxyService.
2292 *
2293 * @param aGlobalFilters Where to put the global filter list copy.
2294 * @param aMachines Where to put the machine vector.
2295 */
2296void Host::i_getUSBFilters(Host::USBDeviceFilterList *aGlobalFilters)
2297{
2298 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2299
2300 *aGlobalFilters = m->llUSBDeviceFilters;
2301}
2302
2303#endif /* VBOX_WITH_USB */
2304
2305// private methods
2306////////////////////////////////////////////////////////////////////////////////
2307
2308#if defined(RT_OS_SOLARIS) && defined(VBOX_USE_LIBHAL)
2309
2310/**
2311 * Helper function to get the slice number from a device path
2312 *
2313 * @param pszDevLinkPath Pointer to a device path (/dev/(r)dsk/c7d1t0d0s3 etc.)
2314 * @returns Pointer to the slice portion of the given path.
2315 */
2316static char *solarisGetSliceFromPath(const char *pszDevLinkPath)
2317{
2318 char *pszFound = NULL;
2319 char *pszSlice = strrchr(pszDevLinkPath, 's');
2320 char *pszDisk = strrchr(pszDevLinkPath, 'd');
2321 if (pszSlice && pszSlice > pszDisk)
2322 pszFound = pszSlice;
2323 else
2324 pszFound = pszDisk;
2325
2326 if (pszFound && RT_C_IS_DIGIT(pszFound[1]))
2327 return pszFound;
2328
2329 return NULL;
2330}
2331
2332/**
2333 * Walk device links and returns an allocated path for the first one in the snapshot.
2334 *
2335 * @param DevLink Handle to the device link being walked.
2336 * @param pvArg Opaque data containing the pointer to the path.
2337 * @returns Pointer to an allocated device path string.
2338 */
2339static int solarisWalkDevLink(di_devlink_t DevLink, void *pvArg)
2340{
2341 char **ppszPath = (char **)pvArg;
2342 *ppszPath = strdup(di_devlink_path(DevLink));
2343 return DI_WALK_TERMINATE;
2344}
2345
2346/**
2347 * Walk all devices in the system and enumerate CD/DVD drives.
2348 * @param Node Handle to the current node.
2349 * @param pvArg Opaque data (holds list pointer).
2350 * @returns Solaris specific code whether to continue walking or not.
2351 */
2352static int solarisWalkDeviceNodeForDVD(di_node_t Node, void *pvArg)
2353{
2354 PSOLARISDVD *ppDrives = (PSOLARISDVD *)pvArg;
2355
2356 /*
2357 * Check for "removable-media" or "hotpluggable" instead of "SCSI" so that we also include USB CD-ROMs.
2358 * As unfortunately the Solaris drivers only export these common properties.
2359 */
2360 int *pInt = NULL;
2361 if ( di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "removable-media", &pInt) >= 0
2362 || di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "hotpluggable", &pInt) >= 0)
2363 {
2364 if (di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "inquiry-device-type", &pInt) > 0
2365 && ( *pInt == DTYPE_RODIRECT /* CDROM */
2366 || *pInt == DTYPE_OPTICAL)) /* Optical Drive */
2367 {
2368 char *pszProduct = NULL;
2369 if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "inquiry-product-id", &pszProduct) > 0)
2370 {
2371 char *pszVendor = NULL;
2372 if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "inquiry-vendor-id", &pszVendor) > 0)
2373 {
2374 /*
2375 * Found a DVD drive, we need to scan the minor nodes to find the correct
2376 * slice that represents the whole drive. "s2" is always the whole drive for CD/DVDs.
2377 */
2378 int Major = di_driver_major(Node);
2379 di_minor_t Minor = DI_MINOR_NIL;
2380 di_devlink_handle_t DevLink = di_devlink_init(NULL /* name */, 0 /* flags */);
2381 if (DevLink)
2382 {
2383 while ((Minor = di_minor_next(Node, Minor)) != DI_MINOR_NIL)
2384 {
2385 dev_t Dev = di_minor_devt(Minor);
2386 if ( Major != (int)major(Dev)
2387 || di_minor_spectype(Minor) == S_IFBLK
2388 || di_minor_type(Minor) != DDM_MINOR)
2389 {
2390 continue;
2391 }
2392
2393 char *pszMinorPath = di_devfs_minor_path(Minor);
2394 if (!pszMinorPath)
2395 continue;
2396
2397 char *pszDevLinkPath = NULL;
2398 di_devlink_walk(DevLink, NULL, pszMinorPath, DI_PRIMARY_LINK, &pszDevLinkPath, solarisWalkDevLink);
2399 di_devfs_path_free(pszMinorPath);
2400
2401 if (pszDevLinkPath)
2402 {
2403 char *pszSlice = solarisGetSliceFromPath(pszDevLinkPath);
2404 if ( pszSlice && !strcmp(pszSlice, "s2")
2405 && !strncmp(pszDevLinkPath, RT_STR_TUPLE("/dev/rdsk"))) /* We want only raw disks */
2406 {
2407 /*
2408 * We've got a fully qualified DVD drive. Add it to the list.
2409 */
2410 PSOLARISDVD pDrive = (PSOLARISDVD)RTMemAllocZ(sizeof(SOLARISDVD));
2411 if (RT_LIKELY(pDrive))
2412 {
2413 RTStrPrintf(pDrive->szDescription, sizeof(pDrive->szDescription),
2414 "%s %s", pszVendor, pszProduct);
2415 RTStrCopy(pDrive->szRawDiskPath, sizeof(pDrive->szRawDiskPath), pszDevLinkPath);
2416 if (*ppDrives)
2417 pDrive->pNext = *ppDrives;
2418 *ppDrives = pDrive;
2419
2420 /* We're not interested in any of the other slices, stop minor nodes traversal. */
2421 free(pszDevLinkPath);
2422 break;
2423 }
2424 }
2425 free(pszDevLinkPath);
2426 }
2427 }
2428 di_devlink_fini(&DevLink);
2429 }
2430 }
2431 }
2432 }
2433 }
2434 return DI_WALK_CONTINUE;
2435}
2436
2437/**
2438 * Solaris specific function to enumerate CD/DVD drives via the device tree.
2439 * Works on Solaris 10 as well as OpenSolaris without depending on libhal.
2440 */
2441void Host::i_getDVDInfoFromDevTree(std::list<ComObjPtr<Medium> > &list)
2442{
2443 PSOLARISDVD pDrives = NULL;
2444 di_node_t RootNode = di_init("/", DINFOCPYALL);
2445 if (RootNode != DI_NODE_NIL)
2446 di_walk_node(RootNode, DI_WALK_CLDFIRST, &pDrives, solarisWalkDeviceNodeForDVD);
2447
2448 di_fini(RootNode);
2449
2450 while (pDrives)
2451 {
2452 ComObjPtr<Medium> hostDVDDriveObj;
2453 hostDVDDriveObj.createObject();
2454 hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(pDrives->szRawDiskPath), Bstr(pDrives->szDescription));
2455 list.push_back(hostDVDDriveObj);
2456
2457 void *pvDrive = pDrives;
2458 pDrives = pDrives->pNext;
2459 RTMemFree(pvDrive);
2460 }
2461}
2462
2463/* Solaris hosts, loading libhal at runtime */
2464
2465/**
2466 * Helper function to query the hal subsystem for information about DVD drives attached to the
2467 * system.
2468 *
2469 * @returns true if information was successfully obtained, false otherwise
2470 * @retval list drives found will be attached to this list
2471 */
2472bool Host::i_getDVDInfoFromHal(std::list<ComObjPtr<Medium> > &list)
2473{
2474 bool halSuccess = false;
2475 DBusError dbusError;
2476 if (!gLibHalCheckPresence())
2477 return false;
2478 gDBusErrorInit(&dbusError);
2479 DBusConnection *dbusConnection = gDBusBusGet(DBUS_BUS_SYSTEM, &dbusError);
2480 if (dbusConnection != 0)
2481 {
2482 LibHalContext *halContext = gLibHalCtxNew();
2483 if (halContext != 0)
2484 {
2485 if (gLibHalCtxSetDBusConnection(halContext, dbusConnection))
2486 {
2487 if (gLibHalCtxInit(halContext, &dbusError))
2488 {
2489 int numDevices;
2490 char **halDevices = gLibHalFindDeviceStringMatch(halContext,
2491 "storage.drive_type", "cdrom",
2492 &numDevices, &dbusError);
2493 if (halDevices != 0)
2494 {
2495 /* Hal is installed and working, so if no devices are reported, assume
2496 that there are none. */
2497 halSuccess = true;
2498 for (int i = 0; i < numDevices; i++)
2499 {
2500 char *devNode = gLibHalDeviceGetPropertyString(halContext,
2501 halDevices[i], "block.device", &dbusError);
2502#ifdef RT_OS_SOLARIS
2503 /* The CD/DVD ioctls work only for raw device nodes. */
2504 char *tmp = getfullrawname(devNode);
2505 gLibHalFreeString(devNode);
2506 devNode = tmp;
2507#endif
2508
2509 if (devNode != 0)
2510 {
2511// if (validateDevice(devNode, true))
2512// {
2513 Utf8Str description;
2514 char *vendor, *product;
2515 /* We do not check the error here, as this field may
2516 not even exist. */
2517 vendor = gLibHalDeviceGetPropertyString(halContext,
2518 halDevices[i], "info.vendor", 0);
2519 product = gLibHalDeviceGetPropertyString(halContext,
2520 halDevices[i], "info.product", &dbusError);
2521 if ((product != 0 && product[0] != 0))
2522 {
2523 if ((vendor != 0) && (vendor[0] != 0))
2524 {
2525 description = Utf8StrFmt("%s %s",
2526 vendor, product);
2527 }
2528 else
2529 {
2530 description = product;
2531 }
2532 ComObjPtr<Medium> hostDVDDriveObj;
2533 hostDVDDriveObj.createObject();
2534 hostDVDDriveObj->init(m->pParent, DeviceType_DVD,
2535 Bstr(devNode), Bstr(description));
2536 list.push_back(hostDVDDriveObj);
2537 }
2538 else
2539 {
2540 if (product == 0)
2541 {
2542 LogRel(("Host::COMGETTER(DVDDrives): failed to get property \"info.product\" for device %s. dbus error: %s (%s)\n",
2543 halDevices[i], dbusError.name, dbusError.message));
2544 gDBusErrorFree(&dbusError);
2545 }
2546 ComObjPtr<Medium> hostDVDDriveObj;
2547 hostDVDDriveObj.createObject();
2548 hostDVDDriveObj->init(m->pParent, DeviceType_DVD,
2549 Bstr(devNode));
2550 list.push_back(hostDVDDriveObj);
2551 }
2552 if (vendor != 0)
2553 {
2554 gLibHalFreeString(vendor);
2555 }
2556 if (product != 0)
2557 {
2558 gLibHalFreeString(product);
2559 }
2560// }
2561// else
2562// {
2563// LogRel(("Host::COMGETTER(DVDDrives): failed to validate the block device %s as a DVD drive\n"));
2564// }
2565#ifndef RT_OS_SOLARIS
2566 gLibHalFreeString(devNode);
2567#else
2568 free(devNode);
2569#endif
2570 }
2571 else
2572 {
2573 LogRel(("Host::COMGETTER(DVDDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
2574 halDevices[i], dbusError.name, dbusError.message));
2575 gDBusErrorFree(&dbusError);
2576 }
2577 }
2578 gLibHalFreeStringArray(halDevices);
2579 }
2580 else
2581 {
2582 LogRel(("Host::COMGETTER(DVDDrives): failed to get devices with capability \"storage.cdrom\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2583 gDBusErrorFree(&dbusError);
2584 }
2585 if (!gLibHalCtxShutdown(halContext, &dbusError)) /* what now? */
2586 {
2587 LogRel(("Host::COMGETTER(DVDDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n",
2588 dbusError.name, dbusError.message));
2589 gDBusErrorFree(&dbusError);
2590 }
2591 }
2592 else
2593 {
2594 LogRel(("Host::COMGETTER(DVDDrives): failed to initialise libhal context. dbus error: %s (%s)\n",
2595 dbusError.name, dbusError.message));
2596 gDBusErrorFree(&dbusError);
2597 }
2598 gLibHalCtxFree(halContext);
2599 }
2600 else
2601 {
2602 LogRel(("Host::COMGETTER(DVDDrives): failed to set libhal connection to dbus.\n"));
2603 }
2604 }
2605 else
2606 {
2607 LogRel(("Host::COMGETTER(DVDDrives): failed to get a libhal context - out of memory?\n"));
2608 }
2609 gDBusConnectionUnref(dbusConnection);
2610 }
2611 else
2612 {
2613 LogRel(("Host::COMGETTER(DVDDrives): failed to connect to dbus. dbus error: %s (%s)\n",
2614 dbusError.name, dbusError.message));
2615 gDBusErrorFree(&dbusError);
2616 }
2617 return halSuccess;
2618}
2619
2620
2621/**
2622 * Helper function to query the hal subsystem for information about floppy drives attached to the
2623 * system.
2624 *
2625 * @returns true if information was successfully obtained, false otherwise
2626 * @retval list drives found will be attached to this list
2627 */
2628bool Host::i_getFloppyInfoFromHal(std::list< ComObjPtr<Medium> > &list)
2629{
2630 bool halSuccess = false;
2631 DBusError dbusError;
2632 if (!gLibHalCheckPresence())
2633 return false;
2634 gDBusErrorInit(&dbusError);
2635 DBusConnection *dbusConnection = gDBusBusGet(DBUS_BUS_SYSTEM, &dbusError);
2636 if (dbusConnection != 0)
2637 {
2638 LibHalContext *halContext = gLibHalCtxNew();
2639 if (halContext != 0)
2640 {
2641 if (gLibHalCtxSetDBusConnection(halContext, dbusConnection))
2642 {
2643 if (gLibHalCtxInit(halContext, &dbusError))
2644 {
2645 int numDevices;
2646 char **halDevices = gLibHalFindDeviceStringMatch(halContext,
2647 "storage.drive_type", "floppy",
2648 &numDevices, &dbusError);
2649 if (halDevices != 0)
2650 {
2651 /* Hal is installed and working, so if no devices are reported, assume
2652 that there are none. */
2653 halSuccess = true;
2654 for (int i = 0; i < numDevices; i++)
2655 {
2656 char *driveType = gLibHalDeviceGetPropertyString(halContext,
2657 halDevices[i], "storage.drive_type", 0);
2658 if (driveType != 0)
2659 {
2660 if (strcmp(driveType, "floppy") != 0)
2661 {
2662 gLibHalFreeString(driveType);
2663 continue;
2664 }
2665 gLibHalFreeString(driveType);
2666 }
2667 else
2668 {
2669 /* An error occurred. The attribute "storage.drive_type"
2670 probably didn't exist. */
2671 continue;
2672 }
2673 char *devNode = gLibHalDeviceGetPropertyString(halContext,
2674 halDevices[i], "block.device", &dbusError);
2675 if (devNode != 0)
2676 {
2677// if (validateDevice(devNode, false))
2678// {
2679 Utf8Str description;
2680 char *vendor, *product;
2681 /* We do not check the error here, as this field may
2682 not even exist. */
2683 vendor = gLibHalDeviceGetPropertyString(halContext,
2684 halDevices[i], "info.vendor", 0);
2685 product = gLibHalDeviceGetPropertyString(halContext,
2686 halDevices[i], "info.product", &dbusError);
2687 if ((product != 0) && (product[0] != 0))
2688 {
2689 if ((vendor != 0) && (vendor[0] != 0))
2690 {
2691 description = Utf8StrFmt("%s %s",
2692 vendor, product);
2693 }
2694 else
2695 {
2696 description = product;
2697 }
2698 ComObjPtr<Medium> hostFloppyDrive;
2699 hostFloppyDrive.createObject();
2700 hostFloppyDrive->init(m->pParent, DeviceType_DVD,
2701 Bstr(devNode), Bstr(description));
2702 list.push_back(hostFloppyDrive);
2703 }
2704 else
2705 {
2706 if (product == 0)
2707 {
2708 LogRel(("Host::COMGETTER(FloppyDrives): failed to get property \"info.product\" for device %s. dbus error: %s (%s)\n",
2709 halDevices[i], dbusError.name, dbusError.message));
2710 gDBusErrorFree(&dbusError);
2711 }
2712 ComObjPtr<Medium> hostFloppyDrive;
2713 hostFloppyDrive.createObject();
2714 hostFloppyDrive->init(m->pParent, DeviceType_DVD,
2715 Bstr(devNode));
2716 list.push_back(hostFloppyDrive);
2717 }
2718 if (vendor != 0)
2719 {
2720 gLibHalFreeString(vendor);
2721 }
2722 if (product != 0)
2723 {
2724 gLibHalFreeString(product);
2725 }
2726// }
2727// else
2728// {
2729// LogRel(("Host::COMGETTER(FloppyDrives): failed to validate the block device %s as a floppy drive\n"));
2730// }
2731 gLibHalFreeString(devNode);
2732 }
2733 else
2734 {
2735 LogRel(("Host::COMGETTER(FloppyDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
2736 halDevices[i], dbusError.name, dbusError.message));
2737 gDBusErrorFree(&dbusError);
2738 }
2739 }
2740 gLibHalFreeStringArray(halDevices);
2741 }
2742 else
2743 {
2744 LogRel(("Host::COMGETTER(FloppyDrives): failed to get devices with capability \"storage.cdrom\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2745 gDBusErrorFree(&dbusError);
2746 }
2747 if (!gLibHalCtxShutdown(halContext, &dbusError)) /* what now? */
2748 {
2749 LogRel(("Host::COMGETTER(FloppyDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n",
2750 dbusError.name, dbusError.message));
2751 gDBusErrorFree(&dbusError);
2752 }
2753 }
2754 else
2755 {
2756 LogRel(("Host::COMGETTER(FloppyDrives): failed to initialise libhal context. dbus error: %s (%s)\n",
2757 dbusError.name, dbusError.message));
2758 gDBusErrorFree(&dbusError);
2759 }
2760 gLibHalCtxFree(halContext);
2761 }
2762 else
2763 {
2764 LogRel(("Host::COMGETTER(FloppyDrives): failed to set libhal connection to dbus.\n"));
2765 }
2766 }
2767 else
2768 {
2769 LogRel(("Host::COMGETTER(FloppyDrives): failed to get a libhal context - out of memory?\n"));
2770 }
2771 gDBusConnectionUnref(dbusConnection);
2772 }
2773 else
2774 {
2775 LogRel(("Host::COMGETTER(FloppyDrives): failed to connect to dbus. dbus error: %s (%s)\n",
2776 dbusError.name, dbusError.message));
2777 gDBusErrorFree(&dbusError);
2778 }
2779 return halSuccess;
2780}
2781#endif /* RT_OS_SOLARIS and VBOX_USE_HAL */
2782
2783/** @todo get rid of dead code below - RT_OS_SOLARIS and RT_OS_LINUX are never both set */
2784#if defined(RT_OS_SOLARIS)
2785
2786/**
2787 * Helper function to parse the given mount file and add found entries
2788 */
2789void Host::i_parseMountTable(char *mountTable, std::list< ComObjPtr<Medium> > &list)
2790{
2791#ifdef RT_OS_LINUX
2792 FILE *mtab = setmntent(mountTable, "r");
2793 if (mtab)
2794 {
2795 struct mntent *mntent;
2796 char *mnt_type;
2797 char *mnt_dev;
2798 char *tmp;
2799 while ((mntent = getmntent(mtab)))
2800 {
2801 mnt_type = (char*)malloc(strlen(mntent->mnt_type) + 1);
2802 mnt_dev = (char*)malloc(strlen(mntent->mnt_fsname) + 1);
2803 strcpy(mnt_type, mntent->mnt_type);
2804 strcpy(mnt_dev, mntent->mnt_fsname);
2805 // supermount fs case
2806 if (strcmp(mnt_type, "supermount") == 0)
2807 {
2808 tmp = strstr(mntent->mnt_opts, "fs=");
2809 if (tmp)
2810 {
2811 free(mnt_type);
2812 mnt_type = strdup(tmp + strlen("fs="));
2813 if (mnt_type)
2814 {
2815 tmp = strchr(mnt_type, ',');
2816 if (tmp)
2817 *tmp = '\0';
2818 }
2819 }
2820 tmp = strstr(mntent->mnt_opts, "dev=");
2821 if (tmp)
2822 {
2823 free(mnt_dev);
2824 mnt_dev = strdup(tmp + strlen("dev="));
2825 if (mnt_dev)
2826 {
2827 tmp = strchr(mnt_dev, ',');
2828 if (tmp)
2829 *tmp = '\0';
2830 }
2831 }
2832 }
2833 // use strstr here to cover things fs types like "udf,iso9660"
2834 if (strstr(mnt_type, "iso9660") == 0)
2835 {
2836 /** @todo check whether we've already got the drive in our list! */
2837 if (i_validateDevice(mnt_dev, true))
2838 {
2839 ComObjPtr<Medium> hostDVDDriveObj;
2840 hostDVDDriveObj.createObject();
2841 hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(mnt_dev));
2842 list.push_back (hostDVDDriveObj);
2843 }
2844 }
2845 free(mnt_dev);
2846 free(mnt_type);
2847 }
2848 endmntent(mtab);
2849 }
2850#else // RT_OS_SOLARIS
2851 FILE *mntFile = fopen(mountTable, "r");
2852 if (mntFile)
2853 {
2854 struct mnttab mntTab;
2855 while (getmntent(mntFile, &mntTab) == 0)
2856 {
2857 const char *mountName = mntTab.mnt_special;
2858 const char *mountPoint = mntTab.mnt_mountp;
2859 const char *mountFSType = mntTab.mnt_fstype;
2860 if (mountName && mountPoint && mountFSType)
2861 {
2862 // skip devices we are not interested in
2863 if ((*mountName && mountName[0] == '/') && // skip 'fake' devices (like -hosts,
2864 // proc, fd, swap)
2865 (*mountFSType && (strncmp(mountFSType, RT_STR_TUPLE("devfs")) != 0 && // skip devfs
2866 // (i.e. /devices)
2867 strncmp(mountFSType, RT_STR_TUPLE("dev")) != 0 && // skip dev (i.e. /dev)
2868 strncmp(mountFSType, RT_STR_TUPLE("lofs")) != 0))) // skip loop-back file-system (lofs)
2869 {
2870 char *rawDevName = getfullrawname((char *)mountName);
2871 if (i_validateDevice(rawDevName, true))
2872 {
2873 ComObjPtr<Medium> hostDVDDriveObj;
2874 hostDVDDriveObj.createObject();
2875 hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(rawDevName));
2876 list.push_back(hostDVDDriveObj);
2877 }
2878 free(rawDevName);
2879 }
2880 }
2881 }
2882
2883 fclose(mntFile);
2884 }
2885#endif
2886}
2887
2888/**
2889 * Helper function to check whether the given device node is a valid drive
2890 */
2891bool Host::i_validateDevice(const char *deviceNode, bool isCDROM)
2892{
2893 struct stat statInfo;
2894 bool retValue = false;
2895
2896 // sanity check
2897 if (!deviceNode)
2898 {
2899 return false;
2900 }
2901
2902 // first a simple stat() call
2903 if (stat(deviceNode, &statInfo) < 0)
2904 {
2905 return false;
2906 }
2907 else
2908 {
2909 if (isCDROM)
2910 {
2911 if (S_ISCHR(statInfo.st_mode) || S_ISBLK(statInfo.st_mode))
2912 {
2913 int fileHandle;
2914 // now try to open the device
2915 fileHandle = open(deviceNode, O_RDONLY | O_NONBLOCK, 0);
2916 if (fileHandle >= 0)
2917 {
2918 cdrom_subchnl cdChannelInfo;
2919 cdChannelInfo.cdsc_format = CDROM_MSF;
2920 // this call will finally reveal the whole truth
2921#ifdef RT_OS_LINUX
2922 if ((ioctl(fileHandle, CDROMSUBCHNL, &cdChannelInfo) == 0) ||
2923 (errno == EIO) || (errno == ENOENT) ||
2924 (errno == EINVAL) || (errno == ENOMEDIUM))
2925#else
2926 if ((ioctl(fileHandle, CDROMSUBCHNL, &cdChannelInfo) == 0) ||
2927 (errno == EIO) || (errno == ENOENT) ||
2928 (errno == EINVAL))
2929#endif
2930 {
2931 retValue = true;
2932 }
2933 close(fileHandle);
2934 }
2935 }
2936 } else
2937 {
2938 // floppy case
2939 if (S_ISCHR(statInfo.st_mode) || S_ISBLK(statInfo.st_mode))
2940 {
2941 /// @todo do some more testing, maybe a nice IOCTL!
2942 retValue = true;
2943 }
2944 }
2945 }
2946 return retValue;
2947}
2948#endif // RT_OS_SOLARIS
2949
2950#ifdef VBOX_WITH_USB
2951/**
2952 * Checks for the presence and status of the USB Proxy Service.
2953 * Returns S_OK when the Proxy is present and OK, VBOX_E_HOST_ERROR (as a
2954 * warning) if the proxy service is not available due to the way the host is
2955 * configured (at present, that means that usbfs and hal/DBus are not
2956 * available on a Linux host) or E_FAIL and a corresponding error message
2957 * otherwise. Intended to be used by methods that rely on the Proxy Service
2958 * availability.
2959 *
2960 * @note This method may return a warning result code. It is recommended to use
2961 * MultiError to store the return value.
2962 *
2963 * @note Locks this object for reading.
2964 */
2965HRESULT Host::i_checkUSBProxyService()
2966{
2967 AutoCaller autoCaller(this);
2968 if (FAILED(autoCaller.rc()))
2969 return autoCaller.rc();
2970
2971 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2972
2973 AssertReturn(m->pUSBProxyService, E_FAIL);
2974 if (!m->pUSBProxyService->isActive())
2975 {
2976 /* disable the USB controller completely to avoid assertions if the
2977 * USB proxy service could not start. */
2978
2979 switch (m->pUSBProxyService->getLastError())
2980 {
2981 case VERR_FILE_NOT_FOUND: /** @todo what does this mean? */
2982 return setWarning(E_FAIL,
2983 tr("Could not load the Host USB Proxy Service (VERR_FILE_NOT_FOUND). The service might not be installed on the host computer"));
2984 case VERR_VUSB_USB_DEVICE_PERMISSION:
2985 return setWarning(E_FAIL,
2986 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"));
2987 case VERR_VUSB_USBFS_PERMISSION:
2988 return setWarning(E_FAIL,
2989 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"));
2990 case VINF_SUCCESS:
2991 return setWarning(E_FAIL,
2992 tr("The USB Proxy Service has not yet been ported to this host"));
2993 default:
2994 return setWarning(E_FAIL, "%s: %Rrc",
2995 tr("Could not load the Host USB Proxy service"),
2996 m->pUSBProxyService->getLastError());
2997 }
2998 }
2999
3000 return S_OK;
3001}
3002#endif /* VBOX_WITH_USB */
3003
3004HRESULT Host::i_updateNetIfList()
3005{
3006#ifdef VBOX_WITH_HOSTNETIF_API
3007 AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
3008
3009 /** @todo r=klaus it would save lots of clock cycles if for concurrent
3010 * threads executing this code we'd only do one interface enumeration
3011 * and update, and let the other threads use the result as is. However
3012 * if there's a constant hammering of this method, we don't want this
3013 * to cause update starvation. */
3014 HostNetworkInterfaceList list;
3015 int rc = NetIfList(list);
3016 if (rc)
3017 {
3018 Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
3019 return E_FAIL;
3020 }
3021
3022 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3023
3024 AssertReturn(m->pParent, E_FAIL);
3025 /* Make a copy as the original may be partially destroyed later. */
3026 HostNetworkInterfaceList listCopy(list);
3027 HostNetworkInterfaceList::iterator itOld, itNew;
3028# ifdef VBOX_WITH_RESOURCE_USAGE_API
3029 PerformanceCollector *aCollector = m->pParent->i_performanceCollector();
3030# endif
3031 for (itOld = m->llNetIfs.begin(); itOld != m->llNetIfs.end(); ++itOld)
3032 {
3033 bool fGone = true;
3034 Bstr nameOld;
3035 (*itOld)->COMGETTER(Name)(nameOld.asOutParam());
3036 for (itNew = listCopy.begin(); itNew != listCopy.end(); ++itNew)
3037 {
3038 Bstr nameNew;
3039 (*itNew)->COMGETTER(Name)(nameNew.asOutParam());
3040 if (nameNew == nameOld)
3041 {
3042 fGone = false;
3043 (*itNew)->uninit();
3044 listCopy.erase(itNew);
3045 break;
3046 }
3047 }
3048 if (fGone)
3049 {
3050# ifdef VBOX_WITH_RESOURCE_USAGE_API
3051 (*itOld)->i_unregisterMetrics(aCollector, this);
3052 (*itOld)->uninit();
3053# endif
3054 }
3055 }
3056 /*
3057 * Need to set the references to VirtualBox object in all interface objects
3058 * (see @bugref{6439}).
3059 */
3060 for (itNew = list.begin(); itNew != list.end(); ++itNew)
3061 (*itNew)->i_setVirtualBox(m->pParent);
3062 /* At this point listCopy will contain newly discovered interfaces only. */
3063 for (itNew = listCopy.begin(); itNew != listCopy.end(); ++itNew)
3064 {
3065 HostNetworkInterfaceType_T t;
3066 HRESULT hrc = (*itNew)->COMGETTER(InterfaceType)(&t);
3067 if (FAILED(hrc))
3068 {
3069 Bstr n;
3070 (*itNew)->COMGETTER(Name)(n.asOutParam());
3071 LogRel(("Host::updateNetIfList: failed to get interface type for %ls\n", n.raw()));
3072 }
3073 else if (t == HostNetworkInterfaceType_Bridged)
3074 {
3075# ifdef VBOX_WITH_RESOURCE_USAGE_API
3076 (*itNew)->i_registerMetrics(aCollector, this);
3077# endif
3078 }
3079 }
3080 m->llNetIfs = list;
3081 return S_OK;
3082#else
3083 return E_NOTIMPL;
3084#endif
3085}
3086
3087#ifdef VBOX_WITH_RESOURCE_USAGE_API
3088
3089void Host::i_registerDiskMetrics(PerformanceCollector *aCollector)
3090{
3091 pm::CollectorHAL *hal = aCollector->getHAL();
3092 /* Create sub metrics */
3093 Utf8StrFmt fsNameBase("FS/{%s}/Usage", "/");
3094 //Utf8StrFmt fsNameBase("Filesystem/[root]/Usage");
3095 pm::SubMetric *fsRootUsageTotal = new pm::SubMetric(fsNameBase + "/Total",
3096 "Root file system size.");
3097 pm::SubMetric *fsRootUsageUsed = new pm::SubMetric(fsNameBase + "/Used",
3098 "Root file system space currently occupied.");
3099 pm::SubMetric *fsRootUsageFree = new pm::SubMetric(fsNameBase + "/Free",
3100 "Root file system space currently empty.");
3101
3102 pm::BaseMetric *fsRootUsage = new pm::HostFilesystemUsage(hal, this,
3103 fsNameBase, "/",
3104 fsRootUsageTotal,
3105 fsRootUsageUsed,
3106 fsRootUsageFree);
3107 aCollector->registerBaseMetric(fsRootUsage);
3108
3109 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal, 0));
3110 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
3111 new pm::AggregateAvg()));
3112 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
3113 new pm::AggregateMin()));
3114 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
3115 new pm::AggregateMax()));
3116
3117 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed, 0));
3118 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
3119 new pm::AggregateAvg()));
3120 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
3121 new pm::AggregateMin()));
3122 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
3123 new pm::AggregateMax()));
3124
3125 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree, 0));
3126 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
3127 new pm::AggregateAvg()));
3128 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
3129 new pm::AggregateMin()));
3130 aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
3131 new pm::AggregateMax()));
3132
3133 /* For now we are concerned with the root file system only. */
3134 pm::DiskList disksUsage, disksLoad;
3135 int rc = hal->getDiskListByFs("/", disksUsage, disksLoad);
3136 if (RT_FAILURE(rc))
3137 return;
3138 pm::DiskList::iterator it;
3139 for (it = disksLoad.begin(); it != disksLoad.end(); ++it)
3140 {
3141 Utf8StrFmt strName("Disk/%s", it->c_str());
3142 pm::SubMetric *fsLoadUtil = new pm::SubMetric(strName + "/Load/Util",
3143 "Percentage of time disk was busy serving I/O requests.");
3144 pm::BaseMetric *fsLoad = new pm::HostDiskLoadRaw(hal, this, strName + "/Load",
3145 *it, fsLoadUtil);
3146 aCollector->registerBaseMetric(fsLoad);
3147
3148 aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil, 0));
3149 aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
3150 new pm::AggregateAvg()));
3151 aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
3152 new pm::AggregateMin()));
3153 aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
3154 new pm::AggregateMax()));
3155 }
3156 for (it = disksUsage.begin(); it != disksUsage.end(); ++it)
3157 {
3158 Utf8StrFmt strName("Disk/%s", it->c_str());
3159 pm::SubMetric *fsUsageTotal = new pm::SubMetric(strName + "/Usage/Total",
3160 "Disk size.");
3161 pm::BaseMetric *fsUsage = new pm::HostDiskUsage(hal, this, strName + "/Usage",
3162 *it, fsUsageTotal);
3163 aCollector->registerBaseMetric(fsUsage);
3164
3165 aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal, 0));
3166 aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal,
3167 new pm::AggregateAvg()));
3168 aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal,
3169 new pm::AggregateMin()));
3170 aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal,
3171 new pm::AggregateMax()));
3172 }
3173}
3174
3175void Host::i_registerMetrics(PerformanceCollector *aCollector)
3176{
3177 pm::CollectorHAL *hal = aCollector->getHAL();
3178 /* Create sub metrics */
3179 pm::SubMetric *cpuLoadUser = new pm::SubMetric("CPU/Load/User",
3180 "Percentage of processor time spent in user mode.");
3181 pm::SubMetric *cpuLoadKernel = new pm::SubMetric("CPU/Load/Kernel",
3182 "Percentage of processor time spent in kernel mode.");
3183 pm::SubMetric *cpuLoadIdle = new pm::SubMetric("CPU/Load/Idle",
3184 "Percentage of processor time spent idling.");
3185 pm::SubMetric *cpuMhzSM = new pm::SubMetric("CPU/MHz",
3186 "Average of current frequency of all processors.");
3187 pm::SubMetric *ramUsageTotal = new pm::SubMetric("RAM/Usage/Total",
3188 "Total physical memory installed.");
3189 pm::SubMetric *ramUsageUsed = new pm::SubMetric("RAM/Usage/Used",
3190 "Physical memory currently occupied.");
3191 pm::SubMetric *ramUsageFree = new pm::SubMetric("RAM/Usage/Free",
3192 "Physical memory currently available to applications.");
3193 pm::SubMetric *ramVMMUsed = new pm::SubMetric("RAM/VMM/Used",
3194 "Total physical memory used by the hypervisor.");
3195 pm::SubMetric *ramVMMFree = new pm::SubMetric("RAM/VMM/Free",
3196 "Total physical memory free inside the hypervisor.");
3197 pm::SubMetric *ramVMMBallooned = new pm::SubMetric("RAM/VMM/Ballooned",
3198 "Total physical memory ballooned by the hypervisor.");
3199 pm::SubMetric *ramVMMShared = new pm::SubMetric("RAM/VMM/Shared",
3200 "Total physical memory shared between VMs.");
3201
3202
3203 /* Create and register base metrics */
3204 pm::BaseMetric *cpuLoad = new pm::HostCpuLoadRaw(hal, this, cpuLoadUser, cpuLoadKernel,
3205 cpuLoadIdle);
3206 aCollector->registerBaseMetric(cpuLoad);
3207 pm::BaseMetric *cpuMhz = new pm::HostCpuMhz(hal, this, cpuMhzSM);
3208 aCollector->registerBaseMetric(cpuMhz);
3209 pm::BaseMetric *ramUsage = new pm::HostRamUsage(hal, this,
3210 ramUsageTotal,
3211 ramUsageUsed,
3212 ramUsageFree);
3213 aCollector->registerBaseMetric(ramUsage);
3214 pm::BaseMetric *ramVmm = new pm::HostRamVmm(aCollector->getGuestManager(), this,
3215 ramVMMUsed,
3216 ramVMMFree,
3217 ramVMMBallooned,
3218 ramVMMShared);
3219 aCollector->registerBaseMetric(ramVmm);
3220
3221 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser, 0));
3222 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
3223 new pm::AggregateAvg()));
3224 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
3225 new pm::AggregateMin()));
3226 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
3227 new pm::AggregateMax()));
3228
3229 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel, 0));
3230 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
3231 new pm::AggregateAvg()));
3232 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
3233 new pm::AggregateMin()));
3234 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
3235 new pm::AggregateMax()));
3236
3237 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle, 0));
3238 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
3239 new pm::AggregateAvg()));
3240 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
3241 new pm::AggregateMin()));
3242 aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
3243 new pm::AggregateMax()));
3244
3245 aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM, 0));
3246 aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
3247 new pm::AggregateAvg()));
3248 aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
3249 new pm::AggregateMin()));
3250 aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
3251 new pm::AggregateMax()));
3252
3253 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal, 0));
3254 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
3255 new pm::AggregateAvg()));
3256 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
3257 new pm::AggregateMin()));
3258 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
3259 new pm::AggregateMax()));
3260
3261 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed, 0));
3262 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
3263 new pm::AggregateAvg()));
3264 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
3265 new pm::AggregateMin()));
3266 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
3267 new pm::AggregateMax()));
3268
3269 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree, 0));
3270 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
3271 new pm::AggregateAvg()));
3272 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
3273 new pm::AggregateMin()));
3274 aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
3275 new pm::AggregateMax()));
3276
3277 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed, 0));
3278 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed,
3279 new pm::AggregateAvg()));
3280 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed,
3281 new pm::AggregateMin()));
3282 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed,
3283 new pm::AggregateMax()));
3284
3285 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree, 0));
3286 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree,
3287 new pm::AggregateAvg()));
3288 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree,
3289 new pm::AggregateMin()));
3290 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree,
3291 new pm::AggregateMax()));
3292
3293 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned, 0));
3294 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned,
3295 new pm::AggregateAvg()));
3296 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned,
3297 new pm::AggregateMin()));
3298 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned,
3299 new pm::AggregateMax()));
3300
3301 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared, 0));
3302 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared,
3303 new pm::AggregateAvg()));
3304 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared,
3305 new pm::AggregateMin()));
3306 aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared,
3307 new pm::AggregateMax()));
3308 i_registerDiskMetrics(aCollector);
3309}
3310
3311void Host::i_unregisterMetrics(PerformanceCollector *aCollector)
3312{
3313 aCollector->unregisterMetricsFor(this);
3314 aCollector->unregisterBaseMetricsFor(this);
3315}
3316
3317#endif /* VBOX_WITH_RESOURCE_USAGE_API */
3318
3319
3320/* static */
3321void Host::i_generateMACAddress(Utf8Str &mac)
3322{
3323 /*
3324 * Our strategy is as follows: the first three bytes are our fixed
3325 * vendor ID (080027). The remaining 3 bytes will be taken from the
3326 * start of a GUID. This is a fairly safe algorithm.
3327 */
3328 Guid guid;
3329 guid.create();
3330 mac = Utf8StrFmt("080027%02X%02X%02X",
3331 guid.raw()->au8[0], guid.raw()->au8[1], guid.raw()->au8[2]);
3332}
3333
3334/* 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