VirtualBox

Changeset 43445 in vbox


Ignore:
Timestamp:
Sep 27, 2012 8:28:59 AM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
80964
Message:

Main/Metrics: Host network metrics, linux only (#6345)

Location:
trunk/src/VBox/Main
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/include/HostImpl.h

    r36615 r43445  
    145145#endif
    146146
     147    HRESULT updateNetIfList();
     148
    147149#ifdef VBOX_WITH_RESOURCE_USAGE_API
    148150    void registerMetrics(PerformanceCollector *aCollector);

  • trunk/src/VBox/Main/include/HostNetworkInterfaceImpl.h

    r42551 r43445  
    7979
    8080    HRESULT setVirtualBox(VirtualBox *pVBox);
     81    void registerMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr);
     82    void unregisterMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr);
    8183
    8284private:
    … …  
    112114};
    113115
     116typedef std::list<ComObjPtr<HostNetworkInterface> > HostNetworkInterfaceList;
     117
    114118#endif // ____H_H_HOSTNETWORKINTERFACEIMPL
    115119/* vi: set tabstop=4 shiftwidth=4 expandtab: */

  • trunk/src/VBox/Main/include/Performance.h

    r40358 r43445  
    4040    /* CPU load is measured in 1/1000 of per cent. */
    4141    const uint64_t PM_CPU_LOAD_MULTIPLIER = UINT64_C(100000);
     42    /* Network load is measured in 1/1000 of per cent. */
     43    const uint64_t PM_NETWORK_LOAD_MULTIPLIER = UINT64_C(100000);
     44    /* Sampler precision in milliseconds. */
     45    const uint64_t PM_SAMPLER_PRECISION_MS = 50;
    4246
    4347    /* Sub Metrics **********************************************************/
    … …  
    6367    {
    6468    public:
    65         SubMetric(const char *name, const char *description)
     69        SubMetric(com::Utf8Str name, const char *description)
    6670        : mName(name), mDescription(description) {};
    6771        void query(ULONG *data);
    68         const char *getName() { return mName; };
     72        const char *getName() { return mName.c_str(); };
    6973        const char *getDescription() { return mDescription; };
    7074    private:
    71         const char *mName;
     75        const com::Utf8Str mName;
    7276        const char *mDescription;
    7377    };
    … …  
    357361        /** Returns CPU usage counters in platform-specific units. */
    358362        virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
     363        /** Returns received and transmitted bytes as well as link speed. */
     364        virtual int getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx, uint64_t *speed);
    359365        /** Returns process' CPU usage counter in platform-specific units. */
    360366        virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total);
    … …  
    367373    {
    368374    public:
    369         BaseMetric(CollectorHAL *hal, const char *name, ComPtr<IUnknown> object)
     375        BaseMetric(CollectorHAL *hal, const com::Utf8Str name, ComPtr<IUnknown> object)
    370376            : mPeriod(0), mLength(0), mHAL(hal), mName(name), mObject(object),
    371377              mLastSampleTaken(0), mEnabled(false), mUnregistered(false) {};
    … …  
    390396        ULONG getPeriod() { return mPeriod; };
    391397        ULONG getLength() { return mLength; };
    392         const char *getName() { return mName; };
     398        const char *getName() { return mName.c_str(); };
    393399        ComPtr<IUnknown> getObject() { return mObject; };
    394400        bool associatedWith(ComPtr<IUnknown> object) { return mObject == object; };
    … …  
    398404        ULONG           mLength;
    399405        CollectorHAL    *mHAL;
    400         const char      *mName;
     406        const com::Utf8Str mName;
    401407        ComPtr<IUnknown> mObject;
    402408        uint64_t         mLastSampleTaken;
    … …  
    486492        SubMetric *mAvailable;
    487493    };
     494
     495    class HostNetworkLoadRaw : public BaseMetric
     496    {
     497    public:
     498        HostNetworkLoadRaw(CollectorHAL *hal, ComPtr<IUnknown> object, com::Utf8Str name, com::Utf8Str ifname, SubMetric *rx, SubMetric *tx)
     499            : BaseMetric(hal, name, object), mInterfaceName(ifname), mRx(rx), mTx(tx), mRxPrev(0), mTxPrev(0) {};
     500        ~HostNetworkLoadRaw() { delete mRx; delete mTx; };
     501
     502        void init(ULONG period, ULONG length);
     503
     504        void preCollect(CollectorHints& hints, uint64_t iTick);
     505        void collect();
     506        const char *getUnit() { return "%"; };
     507        ULONG getMinValue() { return 0; };
     508        ULONG getMaxValue() { return PM_NETWORK_LOAD_MULTIPLIER; };
     509        ULONG getScale() { return PM_NETWORK_LOAD_MULTIPLIER / 100; }
     510
     511    private:
     512        com::Utf8Str  mInterfaceName;
     513        SubMetric    *mRx;
     514        SubMetric    *mTx;
     515        uint64_t      mRxPrev;
     516        uint64_t      mTxPrev;
     517    };
     518
    488519
    489520#ifndef VBOX_COLLECTOR_TEST_CASE

  • trunk/src/VBox/Main/src-server/HostImpl.cpp

    r43387 r43445  
    179179    VirtualBox              *pParent;
    180180
     181    HostNetworkInterfaceList llNetIfs;                  // list of network interfaces
     182
    181183#ifdef VBOX_WITH_USB
    182184    USBDeviceFilterList     llChildren;                 // all USB device filters
    … …  
    272274    registerMetrics(aParent->performanceCollector());
    273275#endif /* VBOX_WITH_RESOURCE_USAGE_API */
     276    /* Create the list of network interfaces so their metrics get registered. */
     277    updateNetIfList();
    274278
    275279#if defined (RT_OS_WINDOWS)
    … …  
    437441
    438442#ifdef VBOX_WITH_RESOURCE_USAGE_API
    439     unregisterMetrics (m->pParent->performanceCollector());
     443    PerformanceCollector *aCollector = m->pParent->performanceCollector();
     444    unregisterMetrics (aCollector);
     445    HostNetworkInterfaceList::iterator it;
     446    for (it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
     447        (*it)->unregisterMetrics(aCollector, this);
    440448#endif /* VBOX_WITH_RESOURCE_USAGE_API */
     449    m->llNetIfs.clear();
    441450
    442451#ifdef VBOX_WITH_USB
    … …  
    584593    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    585594
     595    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     596# ifdef VBOX_WITH_HOSTNETIF_API
     597    int rc = updateNetIfList();
     598    if (rc)
     599    {
     600        Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
     601    }
     602
     603    SafeIfaceArray<IHostNetworkInterface> networkInterfaces (m->llNetIfs);
     604    networkInterfaces.detachTo(ComSafeArrayOutArg(aNetworkInterfaces));
     605
     606    return S_OK;
     607
     608# else
    586609    std::list<ComObjPtr<HostNetworkInterface> > list;
    587 
    588 # ifdef VBOX_WITH_HOSTNETIF_API
    589     int rc = NetIfList(list);
    590     if (rc)
    591     {
    592         Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
    593     }
    594 # else
    595610
    596611#  if defined(RT_OS_DARWIN)
    … …  
    739754    }
    740755#  endif /* RT_OS_LINUX */
    741 # endif
    742 
    743     std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
    744     for (it = list.begin(); it != list.end(); ++it)
    745     {
    746         (*it)->setVirtualBox(m->pParent);
    747     }
    748756
    749757    SafeIfaceArray<IHostNetworkInterface> networkInterfaces (list);
    … …  
    752760    return S_OK;
    753761
     762# endif
    754763#else
    755764    /* Not implemented / supported on this platform. */
    … …  
    13911400        return E_POINTER;
    13921401
     1402    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1403
    13931404    *networkInterface = NULL;
    13941405    ComObjPtr<HostNetworkInterface> found;
    1395     std::list <ComObjPtr<HostNetworkInterface> > list;
    1396     int rc = NetIfList(list);
     1406    int rc = updateNetIfList();
    13971407    if (RT_FAILURE(rc))
    13981408    {
    … …  
    14001410        return E_FAIL;
    14011411    }
    1402     std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
    1403     for (it = list.begin(); it != list.end(); ++it)
     1412    HostNetworkInterfaceList::iterator it;
     1413    for (it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
    14041414    {
    14051415        Bstr n;
    … …  
    14121422        return setError(E_INVALIDARG,
    14131423                        HostNetworkInterface::tr("The host network interface with the given name could not be found"));
    1414 
    1415     found->setVirtualBox(m->pParent);
    14161424
    14171425    return found.queryInterfaceTo(networkInterface);
    … …  
    14291437        return E_POINTER;
    14301438
     1439    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1440
    14311441    *networkInterface = NULL;
    14321442    ComObjPtr<HostNetworkInterface> found;
    1433     std::list <ComObjPtr<HostNetworkInterface> > list;
    1434     int rc = NetIfList(list);
     1443    int rc = updateNetIfList();
    14351444    if (RT_FAILURE(rc))
    14361445    {
    … …  
    14381447        return E_FAIL;
    14391448    }
    1440     std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
    1441     for (it = list.begin(); it != list.end(); ++it)
     1449    HostNetworkInterfaceList::iterator it;
     1450    for (it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
    14421451    {
    14431452        Bstr g;
    … …  
    14511460                        HostNetworkInterface::tr("The host network interface with the given GUID could not be found"));
    14521461
    1453     found->setVirtualBox(m->pParent);
    1454 
    14551462    return found.queryInterfaceTo(networkInterface);
    14561463#endif
    … …  
    14611468{
    14621469#ifdef VBOX_WITH_HOSTNETIF_API
    1463     std::list <ComObjPtr<HostNetworkInterface> > allList;
    1464     int rc = NetIfList(allList);
     1470    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1471
     1472    int rc = updateNetIfList();
    14651473    if (RT_FAILURE(rc))
    14661474        return E_FAIL;
    14671475
    1468     std::list <ComObjPtr<HostNetworkInterface> > resultList;
    1469 
    1470     std::list <ComObjPtr<HostNetworkInterface> >::iterator it;
    1471     for (it = allList.begin(); it != allList.end(); ++it)
     1476    HostNetworkInterfaceList resultList;
     1477
     1478    HostNetworkInterfaceList::iterator it;
     1479    for (it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
    14721480    {
    14731481        HostNetworkInterfaceType_T t;
    … …  
    14771485
    14781486        if (t == type)
    1479         {
    1480             (*it)->setVirtualBox(m->pParent);
    14811487            resultList.push_back (*it);
    1482         }
    14831488    }
    14841489
    … …  
    28112816#endif /* VBOX_WITH_USB */
    28122817
     2818HRESULT Host::updateNetIfList()
     2819{
     2820#ifdef VBOX_WITH_HOSTNETIF_API
     2821    AssertReturn(AutoCaller(this).state() == InInit ||
     2822                 isWriteLockOnCurrentThread(), E_FAIL);
     2823
     2824    HostNetworkInterfaceList list, listCopy;
     2825    int rc = NetIfList(list);
     2826    if (rc)
     2827    {
     2828        Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
     2829        return E_FAIL;
     2830    }
     2831    AssertReturn(m->pParent, E_FAIL);
     2832    /* Make a copy as the original may be partially destroyed later. */
     2833    listCopy = list;
     2834    HostNetworkInterfaceList::iterator itOld, itNew;
     2835    PerformanceCollector *aCollector = m->pParent->performanceCollector();
     2836    for (itOld = m->llNetIfs.begin(); itOld != m->llNetIfs.end(); ++itOld)
     2837    {
     2838        bool fGone = true;
     2839        Bstr nameOld;
     2840        (*itOld)->COMGETTER(Name) (nameOld.asOutParam());
     2841        for (itNew = listCopy.begin(); itNew != listCopy.end(); ++itNew)
     2842        {
     2843            Bstr nameNew;
     2844            (*itNew)->COMGETTER(Name) (nameNew.asOutParam());
     2845            if (nameNew == nameOld)
     2846            {
     2847                fGone = false;
     2848                listCopy.erase(itNew);
     2849                break;
     2850            }
     2851        }
     2852        if (fGone)
     2853            (*itOld)->unregisterMetrics(aCollector, this);
     2854    }
     2855    /* At this point listCopy will contain newly discovered interfaces only. */
     2856    for (itNew = listCopy.begin(); itNew != listCopy.end(); ++itNew)
     2857    {
     2858        (*itNew)->setVirtualBox(m->pParent);
     2859        (*itNew)->registerMetrics(aCollector, this);
     2860    }
     2861    m->llNetIfs = list;
     2862    return S_OK;
     2863#else
     2864    return E_NOTIMPL;
     2865#endif
     2866}
     2867
    28132868#ifdef VBOX_WITH_RESOURCE_USAGE_API
    28142869
    … …  
    28422897
    28432898    /* Create and register base metrics */
    2844     IUnknown *objptr;
    2845     ComObjPtr<Host> tmp = this;
    2846     tmp.queryInterfaceTo(&objptr);
    2847     pm::BaseMetric *cpuLoad = new pm::HostCpuLoadRaw(hal, objptr, cpuLoadUser, cpuLoadKernel,
     2899    pm::BaseMetric *cpuLoad = new pm::HostCpuLoadRaw(hal, this, cpuLoadUser, cpuLoadKernel,
    28482900                                          cpuLoadIdle);
    28492901    aCollector->registerBaseMetric (cpuLoad);
    2850     pm::BaseMetric *cpuMhz = new pm::HostCpuMhz(hal, objptr, cpuMhzSM);
     2902    pm::BaseMetric *cpuMhz = new pm::HostCpuMhz(hal, this, cpuMhzSM);
    28512903    aCollector->registerBaseMetric (cpuMhz);
    2852     pm::BaseMetric *ramUsage = new pm::HostRamUsage(hal, objptr,
     2904    pm::BaseMetric *ramUsage = new pm::HostRamUsage(hal, this,
    28532905                                                    ramUsageTotal,
    28542906                                                    ramUsageUsed,
    28552907                                                    ramUsageFree);
    28562908    aCollector->registerBaseMetric (ramUsage);
    2857     pm::BaseMetric *ramVmm = new pm::HostRamVmm(aCollector->getGuestManager(), objptr,
     2909    pm::BaseMetric *ramVmm = new pm::HostRamVmm(aCollector->getGuestManager(), this,
    28582910                                                ramVMMUsed,
    28592911                                                ramVMMFree,

  • trunk/src/VBox/Main/src-server/HostNetworkInterfaceImpl.cpp

    r42551 r43445  
    2222#include "Logging.h"
    2323#include "netif.h"
     24#include "Performance.h"
     25#include "PerformanceImpl.h"
    2426
    2527#include <iprt/cpp/utils.h>
    … …  
    8385
    8486    return S_OK;
     87}
     88
     89void HostNetworkInterface::registerMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
     90{
     91    LogFlowThisFunc(("mInterfaceName={%ls}, mGuid={%s}\n",
     92                      mInterfaceName.raw(), mGuid.toString().c_str()));
     93    pm::CollectorHAL *hal = aCollector->getHAL();
     94    /* Create sub metrics */
     95    Utf8StrFmt strName("Net/%ls/Load", mInterfaceName.raw());
     96    pm::SubMetric *networkLoadRx   = new pm::SubMetric(strName + "/Rx",
     97        "Percentage of network interface bandwidth used.");
     98    pm::SubMetric *networkLoadTx   = new pm::SubMetric(strName + "/Tx",
     99        "Percentage of network interface bandwidth used.");
     100
     101    /* Create and register base metrics */
     102    pm::BaseMetric *networkLoad = new pm::HostNetworkLoadRaw(hal, objptr, strName, Utf8Str(mInterfaceName), networkLoadRx, networkLoadTx);
     103    aCollector->registerBaseMetric(networkLoad);
     104
     105    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx, 0));
     106    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
     107                                              new pm::AggregateAvg()));
     108    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
     109                                              new pm::AggregateMin()));
     110    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
     111                                              new pm::AggregateMax()));
     112
     113    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx, 0));
     114    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
     115                                              new pm::AggregateAvg()));
     116    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
     117                                              new pm::AggregateMin()));
     118    aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
     119                                              new pm::AggregateMax()));
     120}
     121
     122void HostNetworkInterface::unregisterMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
     123{
     124    LogFlowThisFunc(("mInterfaceName={%ls}, mGuid={%s}\n",
     125                      mInterfaceName.raw(), mGuid.toString().c_str()));
     126    aCollector->unregisterMetricsFor(objptr);
     127    aCollector->unregisterBaseMetricsFor(objptr);
    85128}
    86129
    … …  
    553596    AutoCaller autoCaller(this);
    554597    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     598    AssertReturn(mVBox != pVBox, S_OK);
     599
    555600    unconst(mVBox) = pVBox;
    556601

  • trunk/src/VBox/Main/src-server/Performance.cpp

    r40568 r43445  
    5555
    5656int CollectorHAL::getRawHostCpuLoad(uint64_t * /* user */, uint64_t * /* kernel */, uint64_t * /* idle */)
     57{
     58    return E_NOTIMPL;
     59}
     60
     61int CollectorHAL::getRawHostNetworkLoad(const char * /* name */, uint64_t * /* rx */, uint64_t * /* tx */, uint64_t */* speed */)
    5762{
    5863    return E_NOTIMPL;
    … …  
    554559    if (isEnabled())
    555560    {
    556         if (nowAt - mLastSampleTaken >= mPeriod * 1000)
     561        if (mLastSampleTaken == 0)
    557562        {
    558563            mLastSampleTaken = nowAt;
    … …  
    561566            return true;
    562567        }
     568        /*
     569         * We use low resolution timers which may fire just a little bit early.
     570         * We compensate for that by jumping into the future by several
     571         * milliseconds (see @bugref{6345}).
     572         */
     573        if (nowAt - mLastSampleTaken + PM_SAMPLER_PRECISION_MS >= mPeriod * 1000)
     574        {
     575            /*
     576             * We don't want the beat to drift. This is why the timestamp of
     577             * the last taken sample is not the actual time but the time we
     578             * should have taken the measurement at.
     579             */
     580            mLastSampleTaken += mPeriod * 1000;
     581            Log4(("{%p} " LOG_FN_FMT ": Collecting %s for obj(%p)...\n",
     582                        this, __PRETTY_FUNCTION__, getName(), (void *)mObject));
     583            return true;
     584        }
     585        Log4(("{%p} " LOG_FN_FMT ": Enabled but too early to collect %s for obj(%p)\n",
     586              this, __PRETTY_FUNCTION__, getName(), (void *)mObject));
    563587    }
    564588    return false;
    … …  
    623647        mKernelPrev = kernel;
    624648        mIdlePrev   = idle;
     649    }
     650}
     651
     652void HostNetworkLoadRaw::init(ULONG period, ULONG length)
     653{
     654    mPeriod = period;
     655    mLength = length;
     656    mRx->init(mLength);
     657    mTx->init(mLength);
     658    uint64_t speed;
     659    int rc = mHAL->getRawHostNetworkLoad(mInterfaceName.c_str(), &mRxPrev, &mTxPrev, &speed);
     660    AssertRC(rc);
     661}
     662
     663void HostNetworkLoadRaw::preCollect(CollectorHints& /* hints */, uint64_t /* iTick */)
     664{
     665}
     666
     667void HostNetworkLoadRaw::collect()
     668{
     669    uint64_t rx, tx, speed;
     670
     671    int rc = mHAL->getRawHostNetworkLoad(mInterfaceName.c_str(), &rx, &tx, &speed);
     672    if (RT_SUCCESS(rc))
     673    {
     674        uint64_t rxDiff = rx - mRxPrev;
     675        uint64_t txDiff = tx - mTxPrev;
     676
     677        if (RT_UNLIKELY(speed * getPeriod() == 0))
     678        {
     679            Assert(speed * getPeriod());
     680            LogFlowThisFunc(("Impossible! speed=%llu period=%d.\n", speed, getPeriod()));
     681            mRx->put(0);
     682            mTx->put(0);
     683        }
     684        else
     685        {
     686            mRx->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * rxDiff / (speed * getPeriod())));
     687            mTx->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * txDiff / (speed * getPeriod())));
     688        }
     689
     690        mRxPrev = rx;
     691        mTxPrev = tx;
    625692    }
    626693}

  • trunk/src/VBox/Main/src-server/PerformanceImpl.cpp

    r40358 r43445  
    6666    "CPU/MHz:min",
    6767    "CPU/MHz:max",
     68    "Net/*/Load/Rx",
     69    "Net/*/Load/Rx:avg",
     70    "Net/*/Load/Rx:min",
     71    "Net/*/Load/Rx:max",
     72    "Net/*/Load/Tx",
     73    "Net/*/Load/Tx:avg",
     74    "Net/*/Load/Tx:min",
     75    "Net/*/Load/Tx:max",
    6876    "RAM/Usage/Total",
    6977    "RAM/Usage/Total:avg",

  • trunk/src/VBox/Main/src-server/linux/PerformanceLinux.cpp

    r37713 r43445  
    4040
    4141    virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
     42    virtual int getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx, uint64_t *speed);
    4243    virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total);
    4344private:
    … …  
    217218}
    218219
    219 }
    220 
     220int CollectorLinux::getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx, uint64_t *speed)
     221{
     222    int rc = VINF_SUCCESS;
     223    char szIfName[/*IFNAMSIZ*/ 16 + 36];
     224    long long unsigned int u64Rx, u64Tx, u64Speed;
     225
     226    RTStrPrintf(szIfName, sizeof(szIfName), "/sys/class/net/%s/statistics/rx_bytes", name);
     227    FILE *f = fopen(szIfName, "r");
     228    if (f)
     229    {
     230        if (fscanf(f, "%llu", &u64Rx) == 1)
     231            *rx = u64Rx;
     232        else
     233            rc = VERR_FILE_IO_ERROR;
     234        fclose(f);
     235        RTStrPrintf(szIfName, sizeof(szIfName), "/sys/class/net/%s/statistics/tx_bytes", name);
     236        f = fopen(szIfName, "r");
     237        if (f)
     238        {
     239            if (fscanf(f, "%llu", &u64Tx) == 1)
     240                *tx = u64Tx;
     241            else
     242                rc = VERR_FILE_IO_ERROR;
     243            fclose(f);
     244            RTStrPrintf(szIfName, sizeof(szIfName), "/sys/class/net/%s/speed", name);
     245            f = fopen(szIfName, "r");
     246            if (f)
     247            {
     248                if (fscanf(f, "%llu", &u64Speed) == 1)
     249                    *speed = u64Speed * (1000000/8); /* Convert to bytes/sec */
     250                else
     251                    rc = VERR_FILE_IO_ERROR;
     252                fclose(f);
     253            }
     254            else
     255                rc = VERR_ACCESS_DENIED;
     256        }
     257        else
     258            rc = VERR_ACCESS_DENIED;
     259    }
     260    else
     261        rc = VERR_ACCESS_DENIED;
     262
     263    return rc;
     264}
     265
     266}
     267

  • trunk/src/VBox/Main/testcase/tstAPI.cpp

    r42261 r43445  
    11871187            networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
    11881188            RTPrintf("Found %d network interfaces, testing with %ls...\n", hostNetworkInterfaces.size(), interfaceName.raw());
    1189             Guid interfaceGuid;
     1189            Bstr interfaceGuid;
    11901190            networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
    11911191            // Find the interface by its name
    11921192            networkInterface.setNull();
    11931193            CHECK_ERROR_BREAK(host,
    1194                               FindHostNetworkInterfaceByName(interfaceName, networkInterface.asOutParam()));
    1195             Guid interfaceGuid2;
     1194                              FindHostNetworkInterfaceByName(interfaceName.raw(), networkInterface.asOutParam()));
     1195            Bstr interfaceGuid2;
    11961196            networkInterface->COMGETTER(Id)(interfaceGuid2.asOutParam());
    11971197            if (interfaceGuid2 != interfaceGuid)
    … …  
    12001200            networkInterface.setNull();
    12011201            CHECK_ERROR_BREAK(host,
    1202                               FindHostNetworkInterfaceById(interfaceGuid, networkInterface.asOutParam()));
     1202                              FindHostNetworkInterfaceById(interfaceGuid.raw(), networkInterface.asOutParam()));
    12031203            Bstr interfaceName2;
    12041204            networkInterface->COMGETTER(Name)(interfaceName2.asOutParam());
    12051205            if (interfaceName != interfaceName2)
    1206                 RTPrintf("Failed to retrieve an interface by GUID %ls.\n", Bstr(interfaceGuid.toString()).raw());
     1206                RTPrintf("Failed to retrieve an interface by GUID %ls.\n", interfaceGuid.raw());
    12071207        }
    12081208        else
    … …  
    12131213#endif
    12141214
     1215#if 0 && defined(VBOX_WITH_RESOURCE_USAGE_API)
     1216    do {
     1217        // Get collector
     1218        ComPtr<IPerformanceCollector> collector;
     1219        CHECK_ERROR_BREAK(virtualBox,
     1220                          COMGETTER(PerformanceCollector)(collector.asOutParam()));
     1221
     1222
     1223        // Fill base metrics array
     1224        Bstr baseMetricNames[] = { L"Net/eth0/Load" };
     1225        com::SafeArray<BSTR> baseMetrics(1);
     1226        baseMetricNames[0].cloneTo(&baseMetrics[0]);
     1227
     1228        // Get host
     1229        ComPtr<IHost> host;
     1230        CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
     1231
     1232        // Get host network interfaces
     1233        // com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
     1234        // CHECK_ERROR_BREAK(host,
     1235        //                   COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces)));
     1236
     1237        // Setup base metrics
     1238        // Note that one needs to set up metrics after a session is open for a machine.
     1239        com::SafeIfaceArray<IPerformanceMetric> affectedMetrics;
     1240        com::SafeIfaceArray<IUnknown> objects(1);
     1241        host.queryInterfaceTo(&objects[0]);
     1242        CHECK_ERROR_BREAK(collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
     1243                                                   ComSafeArrayAsInParam(objects), 1u, 10u,
     1244                                                   ComSafeArrayAsOutParam(affectedMetrics)));
     1245        listAffectedMetrics(virtualBox,
     1246                            ComSafeArrayAsInParam(affectedMetrics));
     1247        affectedMetrics.setNull();
     1248
     1249        RTPrintf("Sleeping for 5 seconds...\n");
     1250        RTThreadSleep(5000); // Sleep for 5 seconds
     1251
     1252        RTPrintf("\nMetrics collected: --------------------\n");
     1253        queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
     1254    } while (false);
     1255#endif /* VBOX_WITH_RESOURCE_USAGE_API */
    12151256#if 0 && defined(VBOX_WITH_RESOURCE_USAGE_API)
    12161257    do {
    … …  
    14261467    RTPrintf("\n");
    14271468#endif
    1428 #if 1
     1469#if 0
    14291470    // check of network bandwidth control
    14301471    ///////////////////////////////////////////////////////////////////////////

  • trunk/src/VBox/Main/testcase/tstCollector.cpp

    r38636 r43445  
    142142}
    143143
     144int testNetwork(pm::CollectorHAL *collector)
     145{
     146    pm::CollectorHints hints;
     147    uint64_t hostRxStart, hostTxStart, speedStart;
     148    uint64_t hostRxStop, hostTxStop, speedStop;
     149
     150    RTPrintf("\ntstCollector: TESTING - Network load, sleeping for 5 sec...\n");
     151
     152    int rc = collector->preCollect(hints, 0);
     153    if (RT_FAILURE(rc))
     154    {
     155        RTPrintf("tstCollector: preCollect() -> %Rrc\n", rc);
     156        return 1;
     157    }
     158    rc = collector->getRawHostNetworkLoad("eth0", &hostRxStart, &hostTxStart, &speedStart);
     159    if (RT_FAILURE(rc))
     160    {
     161        RTPrintf("tstCollector: getRawHostNetworkLoad() -> %Rrc\n", rc);
     162        return 1;
     163    }
     164
     165    RTThreadSleep(5000); // Sleep for five seconds
     166
     167    rc = collector->preCollect(hints, 0);
     168    if (RT_FAILURE(rc))
     169    {
     170        RTPrintf("tstCollector: preCollect() -> %Rrc\n", rc);
     171        return 1;
     172    }
     173    rc = collector->getRawHostNetworkLoad("eth0", &hostRxStop, &hostTxStop, &speedStop);
     174    if (RT_FAILURE(rc))
     175    {
     176        RTPrintf("tstCollector: getRawHostNetworkLoad() -> %Rrc\n", rc);
     177        return 1;
     178    }
     179    if (speedStart != speedStop)
     180        RTPrintf("tstCollector: getRawHostNetworkLoad() returned different bandwidth (%llu != %llu)\n", speedStart, speedStop);
     181    RTPrintf("tstCollector: host network speed = %llu bytes/sec (%llu mbit/sec)\n",
     182             speedStop, speedStop/(1000000/8));
     183    RTPrintf("tstCollector: host network rx    = %llu bytes/sec (%llu mbit/sec, %d %%*100)\n",
     184             (hostRxStop - hostRxStart)/5, (hostRxStop - hostRxStart)/(5000000/8),
     185             (hostRxStop - hostRxStart) * 10000 / (speedStop * 5));
     186    RTPrintf("tstCollector: host network tx    = %llu bytes/sec (%llu mbit/sec, %d %%*100)\n",
     187             (hostTxStop - hostTxStart)/5, (hostTxStop - hostTxStart)/(5000000/8),
     188             (hostTxStop - hostTxStart) * 10000 / (speedStop * 5));
     189
     190    return 0;
     191}
     192
    144193int main(int argc, char *argv[])
    145194{
    … …  
    320369    RTPrintf("tstCollector: process mem used   = %lu kB\n", processUsed);
    321370#endif
     371#if 1
     372    rc = testNetwork(collector);
     373#endif
     374#if 0
    322375    RTPrintf("\ntstCollector: TESTING - Performance\n\n");
    323376
    324377    measurePerformance(collector, argv[0], 100);
     378#endif
    325379
    326380    delete collector;
Note: See TracChangeset for help on using the changeset viewer.

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