HRESULT Guest::internalGetStatistics(ULONG *aCpuUser, ULONG *aCpuKernel, ULONG *aCpuIdle,
ULONG *aMemTotal, ULONG *aMemFree, ULONG *aMemBalloon,
ULONG *aMemShared, ULONG *aMemCache, ULONG *aPageTotal,
ULONG *aMemAllocTotal, ULONG *aMemFreeTotal,
ULONG *aMemBalloonTotal, ULONG *aMemSharedTotal)
{
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
*aCpuUser = mCurrentGuestStat[GUESTSTATTYPE_CPUUSER];
*aCpuKernel = mCurrentGuestStat[GUESTSTATTYPE_CPUKERNEL];
*aCpuIdle = mCurrentGuestStat[GUESTSTATTYPE_CPUIDLE];
*aMemTotal = mCurrentGuestStat[GUESTSTATTYPE_MEMTOTAL] * (_4K/_1K); /* page (4K) -> 1KB units */
*aMemFree = mCurrentGuestStat[GUESTSTATTYPE_MEMFREE] * (_4K/_1K); /* page (4K) -> 1KB units */
*aMemBalloon = mCurrentGuestStat[GUESTSTATTYPE_MEMBALLOON] * (_4K/_1K); /* page (4K) -> 1KB units */
*aMemCache = mCurrentGuestStat[GUESTSTATTYPE_MEMCACHE] * (_4K/_1K); /* page (4K) -> 1KB units */
*aPageTotal = mCurrentGuestStat[GUESTSTATTYPE_PAGETOTAL] * (_4K/_1K); /* page (4K) -> 1KB units */
/* Play safe or smth? */
*aMemAllocTotal = 0;
*aMemFreeTotal = 0;
*aMemBalloonTotal = 0;
*aMemSharedTotal = 0;
*aMemShared = 0;
/* MUST release all locks before calling any PGM statistics queries,
* as they are executed by EMT and that might deadlock us by VMM device
* activity which waits for the Guest object lock. */
alock.release();
Console::SafeVMPtr ptrVM(mParent);
if (!ptrVM.isOk())
return E_FAIL;
uint64_t cbFreeTotal, cbAllocTotal, cbBalloonedTotal, cbSharedTotal;
int rc = PGMR3QueryGlobalMemoryStats(ptrVM.rawUVM(), &cbAllocTotal, &cbFreeTotal, &cbBalloonedTotal, &cbSharedTotal);
AssertRCReturn(rc, E_FAIL);
*aMemAllocTotal = (ULONG)(cbAllocTotal / _1K); /* bytes -> KB */
*aMemFreeTotal = (ULONG)(cbFreeTotal / _1K);
*aMemBalloonTotal = (ULONG)(cbBalloonedTotal / _1K);
*aMemSharedTotal = (ULONG)(cbSharedTotal / _1K);
/* Query the missing per-VM memory statistics. */
uint64_t cbTotalMemIgn, cbPrivateMemIgn, cbSharedMem, cbZeroMemIgn;
rc = PGMR3QueryMemoryStats(ptrVM.rawUVM(), &cbTotalMemIgn, &cbPrivateMemIgn, &cbSharedMem, &cbZeroMemIgn);
AssertRCReturn(rc, E_FAIL);
*aMemShared = (ULONG)(cbSharedMem / _1K);
return S_OK;
}
STDMETHODIMP Guest::InternalGetStatistics(ULONG *aCpuUser, ULONG *aCpuKernel, ULONG *aCpuIdle,
ULONG *aMemTotal, ULONG *aMemFree, ULONG *aMemBalloon, ULONG *aMemShared,
ULONG *aMemCache, ULONG *aPageTotal,
ULONG *aMemAllocTotal, ULONG *aMemFreeTotal, ULONG *aMemBalloonTotal, ULONG *aMemSharedTotal)
{
CheckComArgOutPointerValid(aCpuUser);
CheckComArgOutPointerValid(aCpuKernel);
CheckComArgOutPointerValid(aCpuIdle);
CheckComArgOutPointerValid(aMemTotal);
CheckComArgOutPointerValid(aMemFree);
CheckComArgOutPointerValid(aMemBalloon);
CheckComArgOutPointerValid(aMemShared);
CheckComArgOutPointerValid(aMemCache);
CheckComArgOutPointerValid(aPageTotal);
CheckComArgOutPointerValid(aMemAllocTotal);
CheckComArgOutPointerValid(aMemFreeTotal);
CheckComArgOutPointerValid(aMemBalloonTotal);
CheckComArgOutPointerValid(aMemSharedTotal);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
*aCpuUser = mCurrentGuestStat[GUESTSTATTYPE_CPUUSER];
*aCpuKernel = mCurrentGuestStat[GUESTSTATTYPE_CPUKERNEL];
*aCpuIdle = mCurrentGuestStat[GUESTSTATTYPE_CPUIDLE];
*aMemTotal = mCurrentGuestStat[GUESTSTATTYPE_MEMTOTAL] * (_4K/_1K); /* page (4K) -> 1KB units */
*aMemFree = mCurrentGuestStat[GUESTSTATTYPE_MEMFREE] * (_4K/_1K); /* page (4K) -> 1KB units */
*aMemBalloon = mCurrentGuestStat[GUESTSTATTYPE_MEMBALLOON] * (_4K/_1K); /* page (4K) -> 1KB units */
*aMemCache = mCurrentGuestStat[GUESTSTATTYPE_MEMCACHE] * (_4K/_1K); /* page (4K) -> 1KB units */
*aPageTotal = mCurrentGuestStat[GUESTSTATTYPE_PAGETOTAL] * (_4K/_1K); /* page (4K) -> 1KB units */
/* MUST release all locks before calling any PGM statistics queries,
* as they are executed by EMT and that might deadlock us by VMM device
* activity which waits for the Guest object lock. */
alock.release();
Console::SafeVMPtr pVM (mParent);
if (pVM.isOk())
{
uint64_t uFreeTotal, uAllocTotal, uBalloonedTotal, uSharedTotal;
*aMemFreeTotal = 0;
int rc = PGMR3QueryGlobalMemoryStats(pVM.raw(), &uAllocTotal, &uFreeTotal, &uBalloonedTotal, &uSharedTotal);
AssertRC(rc);
if (rc == VINF_SUCCESS)
{
*aMemAllocTotal = (ULONG)(uAllocTotal / _1K); /* bytes -> KB */
*aMemFreeTotal = (ULONG)(uFreeTotal / _1K);
*aMemBalloonTotal = (ULONG)(uBalloonedTotal / _1K);
*aMemSharedTotal = (ULONG)(uSharedTotal / _1K);
}
else
return E_FAIL;
/* Query the missing per-VM memory statistics. */
*aMemShared = 0;
uint64_t uTotalMem, uPrivateMem, uSharedMem, uZeroMem;
rc = PGMR3QueryMemoryStats(pVM.raw(), &uTotalMem, &uPrivateMem, &uSharedMem, &uZeroMem);
if (rc == VINF_SUCCESS)
{
*aMemShared = (ULONG)(uSharedMem / _1K);
}
else
return E_FAIL;
}
else
{
*aMemAllocTotal = 0;
*aMemFreeTotal = 0;
*aMemBalloonTotal = 0;
*aMemSharedTotal = 0;
*aMemShared = 0;
return E_FAIL;
}
return S_OK;
}
void Guest::updateStats(uint64_t iTick)
{
uint64_t uFreeTotal, uAllocTotal, uBalloonedTotal, uSharedTotal;
uint64_t uTotalMem, uPrivateMem, uSharedMem, uZeroMem;
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
ULONG aGuestStats[GUESTSTATTYPE_MAX];
RT_ZERO(aGuestStats);
ULONG validStats = mGuestValidStats;
/* Check if we have anything to report */
if (validStats)
{
mGuestValidStats = pm::GUESTSTATMASK_NONE;
memcpy(aGuestStats, mCurrentGuestStat, sizeof(aGuestStats));
}
alock.release();
/*
* Calling SessionMachine may take time as the object resides in VBoxSVC
* process. This is why we took a snapshot of currently collected stats
* and released the lock.
*/
uFreeTotal = 0;
uAllocTotal = 0;
uBalloonedTotal = 0;
uSharedTotal = 0;
uTotalMem = 0;
uPrivateMem = 0;
uSharedMem = 0;
uZeroMem = 0;
Console::SafeVMPtr pVM(mParent);
if (pVM.isOk())
{
int rc;
/*
* There is no point in collecting VM shared memory if other memory
* statistics are not available yet. Or is it?
*/
if (validStats)
{
/* Query the missing per-VM memory statistics. */
rc = PGMR3QueryMemoryStats(pVM.raw(), &uTotalMem, &uPrivateMem, &uSharedMem, &uZeroMem);
if (rc == VINF_SUCCESS)
{
validStats |= pm::GUESTSTATMASK_MEMSHARED;
}
}
if (mCollectVMMStats)
{
rc = PGMR3QueryGlobalMemoryStats(pVM.raw(), &uAllocTotal, &uFreeTotal, &uBalloonedTotal, &uSharedTotal);
AssertRC(rc);
if (rc == VINF_SUCCESS)
{
validStats |= pm::GUESTSTATMASK_ALLOCVMM|pm::GUESTSTATMASK_FREEVMM|
pm::GUESTSTATMASK_BALOONVMM|pm::GUESTSTATMASK_SHAREDVMM;
}
}
}
mParent->reportGuestStatistics(validStats,
aGuestStats[GUESTSTATTYPE_CPUUSER],
aGuestStats[GUESTSTATTYPE_CPUKERNEL],
aGuestStats[GUESTSTATTYPE_CPUIDLE],
/* Convert the units for RAM usage stats: page (4K) -> 1KB units */
mCurrentGuestStat[GUESTSTATTYPE_MEMTOTAL] * (_4K/_1K),
mCurrentGuestStat[GUESTSTATTYPE_MEMFREE] * (_4K/_1K),
mCurrentGuestStat[GUESTSTATTYPE_MEMBALLOON] * (_4K/_1K),
(ULONG)(uSharedMem / _1K), /* bytes -> KB */
mCurrentGuestStat[GUESTSTATTYPE_MEMCACHE] * (_4K/_1K),
mCurrentGuestStat[GUESTSTATTYPE_PAGETOTAL] * (_4K/_1K),
(ULONG)(uAllocTotal / _1K), /* bytes -> KB */
(ULONG)(uFreeTotal / _1K),
(ULONG)(uBalloonedTotal / _1K),
(ULONG)(uSharedTotal / _1K));
}
void Guest::i_updateStats(uint64_t iTick)
{
uint64_t cbFreeTotal = 0;
uint64_t cbAllocTotal = 0;
uint64_t cbBalloonedTotal = 0;
uint64_t cbSharedTotal = 0;
uint64_t cbSharedMem = 0;
ULONG uNetStatRx = 0;
ULONG uNetStatTx = 0;
ULONG aGuestStats[GUESTSTATTYPE_MAX];
RT_ZERO(aGuestStats);
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
ULONG validStats = mVmValidStats;
/* Check if we have anything to report */
if (validStats)
{
mVmValidStats = pm::VMSTATMASK_NONE;
memcpy(aGuestStats, mCurrentGuestStat, sizeof(aGuestStats));
}
alock.release();
/*
* Calling SessionMachine may take time as the object resides in VBoxSVC
* process. This is why we took a snapshot of currently collected stats
* and released the lock.
*/
Console::SafeVMPtrQuiet ptrVM(mParent);
if (ptrVM.isOk())
{
int rc;
/*
* There is no point in collecting VM shared memory if other memory
* statistics are not available yet. Or is there?
*/
if (validStats)
{
/* Query the missing per-VM memory statistics. */
uint64_t cbTotalMemIgn, cbPrivateMemIgn, cbZeroMemIgn;
rc = PGMR3QueryMemoryStats(ptrVM.rawUVM(), &cbTotalMemIgn, &cbPrivateMemIgn, &cbSharedMem, &cbZeroMemIgn);
if (rc == VINF_SUCCESS)
validStats |= pm::VMSTATMASK_GUEST_MEMSHARED;
}
if (mCollectVMMStats)
{
rc = PGMR3QueryGlobalMemoryStats(ptrVM.rawUVM(), &cbAllocTotal, &cbFreeTotal, &cbBalloonedTotal, &cbSharedTotal);
AssertRC(rc);
if (rc == VINF_SUCCESS)
validStats |= pm::VMSTATMASK_VMM_ALLOC | pm::VMSTATMASK_VMM_FREE
| pm::VMSTATMASK_VMM_BALOON | pm::VMSTATMASK_VMM_SHARED;
}
uint64_t uRxPrev = mNetStatRx;
uint64_t uTxPrev = mNetStatTx;
mNetStatRx = mNetStatTx = 0;
rc = STAMR3Enum(ptrVM.rawUVM(), "/Public/Net/*/Bytes*", i_staticEnumStatsCallback, this);
AssertRC(rc);
uint64_t uTsNow = RTTimeNanoTS();
uint64_t cNsPassed = uTsNow - mNetStatLastTs;
if (cNsPassed >= 1000)
{
mNetStatLastTs = uTsNow;
uNetStatRx = (ULONG)((mNetStatRx - uRxPrev) * 1000000 / (cNsPassed / 1000)); /* in bytes per second */
uNetStatTx = (ULONG)((mNetStatTx - uTxPrev) * 1000000 / (cNsPassed / 1000)); /* in bytes per second */
validStats |= pm::VMSTATMASK_NET_RX | pm::VMSTATMASK_NET_TX;
LogFlowThisFunc(("Net Rx=%llu Tx=%llu Ts=%llu Delta=%llu\n", mNetStatRx, mNetStatTx, uTsNow, cNsPassed));
}
else
{
/* Can happen on resume or if we're using a non-monotonic clock
source for the timer and the time is adjusted. */
mNetStatRx = uRxPrev;
mNetStatTx = uTxPrev;
LogThisFunc(("Net Ts=%llu cNsPassed=%llu - too small interval\n", uTsNow, cNsPassed));
}
}
mParent->i_reportVmStatistics(validStats,
aGuestStats[GUESTSTATTYPE_CPUUSER],
aGuestStats[GUESTSTATTYPE_CPUKERNEL],
aGuestStats[GUESTSTATTYPE_CPUIDLE],
/* Convert the units for RAM usage stats: page (4K) -> 1KB units */
mCurrentGuestStat[GUESTSTATTYPE_MEMTOTAL] * (_4K/_1K),
mCurrentGuestStat[GUESTSTATTYPE_MEMFREE] * (_4K/_1K),
mCurrentGuestStat[GUESTSTATTYPE_MEMBALLOON] * (_4K/_1K),
(ULONG)(cbSharedMem / _1K), /* bytes -> KB */
mCurrentGuestStat[GUESTSTATTYPE_MEMCACHE] * (_4K/_1K),
mCurrentGuestStat[GUESTSTATTYPE_PAGETOTAL] * (_4K/_1K),
(ULONG)(cbAllocTotal / _1K), /* bytes -> KB */
(ULONG)(cbFreeTotal / _1K),
(ULONG)(cbBalloonedTotal / _1K),
(ULONG)(cbSharedTotal / _1K),
uNetStatRx,
uNetStatTx);
}
