source: vbox/trunk/src/VBox/Frontends/VBoxBalloonCtrl/VBoxWatchdogUtils.cpp@ 41105

/* $Id: */
/** @file
 * VBoxWatchdogUtils - Misc. utility functions for modules.
 */

/*
 * Copyright (C) 2011-2012 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */


/*******************************************************************************
*   Header Files                                                               *
*******************************************************************************/
#include <VBox/com/array.h>
#include "VBoxWatchdogInternal.h"


/**
 * Retrieves a metric from a specified machine.
 *
 * @return  IPRT status code.
 * @param   pMachine                Pointer to the machine's internal structure.
 * @param   strName                 Name of metric to retrieve.
 * @param   pulData                 Pointer to value to retrieve the actual metric value.
 */
int getMetric(PVBOXWATCHDOG_MACHINE pMachine, const Bstr& strName, LONG *pulData)
{
    AssertPtrReturn(pMachine, VERR_INVALID_POINTER);
    AssertPtrReturn(pulData, VERR_INVALID_POINTER);

    /* Input. */
    com::SafeArray<BSTR> metricNames(1);
    com::SafeIfaceArray<IUnknown> metricObjects(1);
    pMachine->machine.queryInterfaceTo(&metricObjects[0]);

    /* Output. */
    com::SafeArray<BSTR>          retNames;
    com::SafeIfaceArray<IUnknown> retObjects;
    com::SafeArray<BSTR>          retUnits;
    com::SafeArray<ULONG>         retScales;
    com::SafeArray<ULONG>         retSequenceNumbers;
    com::SafeArray<ULONG>         retIndices;
    com::SafeArray<ULONG>         retLengths;
    com::SafeArray<LONG>          retData;

    /* Query current memory free. */
    strName.cloneTo(&metricNames[0]);
#ifdef VBOX_WATCHDOG_GLOBAL_PERFCOL
    Assert(!g_pPerfCollector.isNull());
    HRESULT hrc = g_pPerfCollector->QueryMetricsData(
#else
    Assert(!pMachine->collector.isNull());
    HRESULT hrc = pMachine->collector->QueryMetricsData(
#endif
                                                ComSafeArrayAsInParam(metricNames),
                                                ComSafeArrayAsInParam(metricObjects),
                                                ComSafeArrayAsOutParam(retNames),
                                                ComSafeArrayAsOutParam(retObjects),
                                                ComSafeArrayAsOutParam(retUnits),
                                                ComSafeArrayAsOutParam(retScales),
                                                ComSafeArrayAsOutParam(retSequenceNumbers),
                                                ComSafeArrayAsOutParam(retIndices),
                                                ComSafeArrayAsOutParam(retLengths),
                                                ComSafeArrayAsOutParam(retData));
#if 0
    /* Useful for metrics debugging. */
    for (unsigned j = 0; j < retNames.size(); j++)
    {
        Bstr metricUnit(retUnits[j]);
        Bstr metricName(retNames[j]);
        RTPrintf("%-20ls ", metricName.raw());
        const char *separator = "";
        for (unsigned k = 0; k < retLengths[j]; k++)
        {
            if (retScales[j] == 1)
                RTPrintf("%s%d %ls", separator, retData[retIndices[j] + k], metricUnit.raw());
            else
                RTPrintf("%s%d.%02d%ls", separator, retData[retIndices[j] + k] / retScales[j],
                         (retData[retIndices[j] + k] * 100 / retScales[j]) % 100, metricUnit.raw());
            separator = ", ";
        }
        RTPrintf("\n");
    }
#endif

    if (SUCCEEDED(hrc))
        *pulData = retData.size() ? retData[retIndices[0]] : 0;

    return SUCCEEDED(hrc) ? VINF_SUCCESS : VINF_NOT_SUPPORTED;
}

/**
 * Returns the payload of a machine.
 *
 * @return  void*                   Pointer to payload data. Mutable!
 * @param   pMachine                Machine to get payload for.
 * @param   pszModule               Module name to get payload from.
 */
void* getPayload(PVBOXWATCHDOG_MACHINE pMachine, const char *pszModule)
{
    AssertPtrReturn(pMachine, NULL);
    AssertPtrReturn(pszModule, NULL);
    mapPayloadIter it = pMachine->payload.find(pszModule);
    if (it == pMachine->payload.end())
        return NULL;
    Assert(it->second.cbData);
    return it->second.pvData;
}

int payloadAlloc(PVBOXWATCHDOG_MACHINE pMachine, const char *pszModule,
                 size_t cbSize, void **ppszPayload)
{
    AssertPtrReturn(pMachine, VERR_INVALID_POINTER);
    AssertPtrReturn(pszModule, VERR_INVALID_POINTER);
    AssertReturn(cbSize, VERR_INVALID_PARAMETER);

    void *pvData = RTMemAlloc(cbSize);
    AssertPtrReturn(pvData, VERR_NO_MEMORY);

    mapPayloadIter it = pMachine->payload.find(pszModule);
    AssertReturn(it == pMachine->payload.end(), VERR_INVALID_PARAMETER);

    VBOXWATCHDOG_MODULE_PAYLOAD p;
    p.pvData = pvData;
    p.cbData = cbSize;

    if (ppszPayload)
        *ppszPayload = p.pvData;

    pMachine->payload.insert(std::make_pair(pszModule, p));

    return VINF_SUCCESS;
}

void payloadFree(PVBOXWATCHDOG_MACHINE pMachine, const char *pszModule)
{
    AssertPtrReturnVoid(pMachine);
    AssertPtrReturnVoid(pszModule);

    mapPayloadIter it = pMachine->payload.find(pszModule);
    if (it != pMachine->payload.end())
    {
        RTMemFree(it->second.pvData);
        pMachine->payload.erase(it);
    }
}

PVBOXWATCHDOG_MACHINE getMachine(const Bstr& strUuid)
{
    mapVMIter it = g_mapVM.find(strUuid);
    if (it != g_mapVM.end())
        return &it->second;
    return NULL;
}

MachineState_T getMachineState(const PVBOXWATCHDOG_MACHINE pMachine)
{
    AssertPtrReturn(pMachine, MachineState_Null);
    MachineState_T machineState;
    Assert(!pMachine->machine.isNull());
    HRESULT rc = pMachine->machine->COMGETTER(State)(&machineState);
    if (SUCCEEDED(rc))
        return machineState;
    return MachineState_Null;
}