CollectorWin::CollectorWin() : CollectorHAL(), mhNtDll(0)
{
mpfnGetSystemTimes = (PFNGST)GetProcAddress(
GetModuleHandle(TEXT("kernel32.dll")),
"GetSystemTimes");
if (!mpfnGetSystemTimes)
{
/* Fall back to deprecated NtQuerySystemInformation */
if (!(mhNtDll = LoadLibrary(TEXT("ntdll.dll"))))
{
LogRel(("Failed to load NTDLL.DLL with error 0x%x. GetSystemTimes() is"
" not available either. CPU and VM metrics will not be collected.\n",
GetLastError()));
mpfnNtQuerySystemInformation = 0;
}
else if (!(mpfnNtQuerySystemInformation = (PFNNQSI)GetProcAddress(mhNtDll,
"NtQuerySystemInformation")))
{
LogRel(("Neither GetSystemTimes() nor NtQuerySystemInformation() is"
" not available. CPU and VM metrics will not be collected.\n"));
mpfnNtQuerySystemInformation = 0;
}
}
uint64_t cb;
int rc = RTSystemQueryTotalRam(&cb);
if (RT_FAILURE(rc))
totalRAM = 0;
else
totalRAM = (ULONG)(cb / 1024);
}
/** Print the total memory size in bytes. */
static RTEXITCODE handlerMemSize(int argc, char **argv)
{
NOREF(argc); NOREF(argv);
uint64_t cb;
int rc = RTSystemQueryTotalRam(&cb);
if (RT_SUCCESS(rc))
{
int cch = RTPrintf("%llu\n", cb);
return cch > 0 ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
}
RTPrintf("%Rrc\n", rc);
return RTEXITCODE_FAILURE;
}
int CollectorWin::getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available)
{
uint64_t cb;
int rc = RTSystemQueryTotalRam(&cb);
if (RT_SUCCESS(rc))
{
*total = (ULONG)(cb / 1024);
rc = RTSystemQueryAvailableRam(&cb);
if (RT_SUCCESS(rc))
{
*available = (ULONG)(cb / 1024);
*used = *total - *available;
}
}
return rc;
}
CollectorDarwin::CollectorDarwin()
{
uint64_t cb;
int rc = RTSystemQueryTotalRam(&cb);
if (RT_FAILURE(rc))
totalRAM = 0;
else
totalRAM = (ULONG)(cb / 1024);
nCpus = RTMpGetOnlineCount();
Assert(nCpus);
if (nCpus == 0)
{
/* It is rather unsual to have no CPUs, but the show must go on. */
nCpus = 1;
}
}
CollectorLinux::CollectorLinux()
{
long hz = sysconf(_SC_CLK_TCK);
if (hz == -1)
{
LogRel(("CollectorLinux failed to obtain HZ from kernel, assuming 100.\n"));
mHZ = 100;
}
else
mHZ = hz;
LogFlowThisFunc(("mHZ=%u\n", mHZ));
uint64_t cb;
int rc = RTSystemQueryTotalRam(&cb);
if (RT_FAILURE(rc))
totalRAM = 0;
else
totalRAM = (ULONG)(cb / 1024);
}
CollectorWin::CollectorWin() : CollectorHAL(), mpfnNtQuerySystemInformation(NULL)
{
/* Note! Both kernel32.dll and ntdll.dll can be assumed to always be present. */
mpfnGetSystemTimes = (PFNGST)RTLdrGetSystemSymbol("kernel32.dll", "GetSystemTimes");
if (!mpfnGetSystemTimes)
{
/* Fall back to deprecated NtQuerySystemInformation */
mpfnNtQuerySystemInformation = (PFNNQSI)RTLdrGetSystemSymbol("ntdll.dll", "NtQuerySystemInformation");
if (!mpfnNtQuerySystemInformation)
LogRel(("Warning! Neither GetSystemTimes() nor NtQuerySystemInformation() is not available.\n"
" CPU and VM metrics will not be collected! (lasterr %u)\n", GetLastError()));
}
uint64_t cb;
int rc = RTSystemQueryTotalRam(&cb);
if (RT_FAILURE(rc))
totalRAM = 0;
else
totalRAM = (ULONG)(cb / 1024);
}
CollectorSolaris::CollectorSolaris()
: mKC(0),
mSysPages(0),
mZFSCache(0),
mZfsLib(0),
mCpus(0)
{
if ((mKC = kstat_open()) == 0)
{
Log(("kstat_open() -> %d\n", errno));
return;
}
if ((mSysPages = kstat_lookup(mKC, (char *)"unix", 0, (char *)"system_pages")) == 0)
{
Log(("kstat_lookup(system_pages) -> %d\n", errno));
return;
}
if ((mZFSCache = kstat_lookup(mKC, (char *)"zfs", 0, (char *)"arcstats")) == 0)
{
Log(("kstat_lookup(system_pages) -> %d\n", errno));
}
/* Try to load libzfs dynamically, it may be missing. */
mZfsSo = dlopen("libzfs.so", RTLD_LAZY);
if (mZfsSo)
{
mZfsInit = (PFNZFSINIT)(uintptr_t)dlsym(mZfsSo, "libzfs_init");
mZfsFini = (PFNZFSFINI)(uintptr_t)dlsym(mZfsSo, "libzfs_fini");
mZfsOpen = (PFNZFSOPEN)(uintptr_t)dlsym(mZfsSo, "zfs_open");
mZfsClose = (PFNZFSCLOSE)(uintptr_t)dlsym(mZfsSo, "zfs_close");
mZfsPropGetInt = (PFNZFSPROPGETINT)(uintptr_t)dlsym(mZfsSo, "zfs_prop_get_int");
mZpoolOpen = (PFNZPOOLOPEN)(uintptr_t)dlsym(mZfsSo, "zpool_open");
mZpoolClose = (PFNZPOOLCLOSE)(uintptr_t)dlsym(mZfsSo, "zpool_close");
mZpoolGetConfig = (PFNZPOOLGETCONFIG)(uintptr_t)dlsym(mZfsSo, "zpool_get_config");
mZpoolVdevName = (PFNZPOOLVDEVNAME)(uintptr_t)dlsym(mZfsSo, "zpool_vdev_name");
if ( mZfsInit
&& mZfsOpen
&& mZfsClose
&& mZfsPropGetInt
&& mZpoolOpen
&& mZpoolClose
&& mZpoolGetConfig
&& mZpoolVdevName)
mZfsLib = mZfsInit();
else
LogRel(("Incompatible libzfs? libzfs_init=%p zfs_open=%p zfs_close=%p zfs_prop_get_int=%p\n",
mZfsInit, mZfsOpen, mZfsClose, mZfsPropGetInt));
}
updateFilesystemMap();
/* Notice that mCpus member will be initialized by HostCpuLoadRaw::init() */
uint64_t cb;
int rc = RTSystemQueryTotalRam(&cb);
if (RT_FAILURE(rc))
totalRAM = 0;
else
totalRAM = (ULONG)(cb / 1024);
}
int main()
{
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTSystemQueryOsInfo", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* Simple stuff.
*/
char szInfo[_4K];
rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "PRODUCT: \"%s\", rc=%Rrc\n", szInfo, rc);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "RELEASE: \"%s\", rc=%Rrc\n", szInfo, rc);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "VERSION: \"%s\", rc=%Rrc\n", szInfo, rc);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "SERVICE_PACK: \"%s\", rc=%Rrc\n", szInfo, rc);
uint64_t cbTotal;
rc = RTSystemQueryTotalRam(&cbTotal);
RTTestIPrintf(RTTESTLVL_ALWAYS, "Total RAM: %'RU64 Bytes (%RU64 KB, %RU64 MB)\n",
cbTotal, cbTotal / _1K, cbTotal / _1M);
uint64_t cbAvailable;
rc = RTSystemQueryAvailableRam(&cbAvailable);
RTTestIPrintf(RTTESTLVL_ALWAYS, "Available RAM: %'RU64 Bytes (%RU64 KB, %RU64 MB)\n",
cbAvailable, cbAvailable / _1K, cbAvailable / _1M);
/*
* Check that unsupported stuff is terminated correctly.
*/
for (int i = RTSYSOSINFO_INVALID + 1; i < RTSYSOSINFO_END; i++)
{
memset(szInfo, ' ', sizeof(szInfo));
rc = RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, sizeof(szInfo));
if ( rc == VERR_NOT_SUPPORTED
&& szInfo[0] != '\0')
RTTestIFailed("level=%d; unterminated buffer on VERR_NOT_SUPPORTED\n", i);
else if (RT_SUCCESS(rc) || rc == VERR_BUFFER_OVERFLOW)
RTTESTI_CHECK(RTStrEnd(szInfo, sizeof(szInfo)) != NULL);
else if (rc != VERR_NOT_SUPPORTED)
RTTestIFailed("level=%d unexpected rc=%Rrc\n", i, rc);
}
/*
* Check buffer overflow
*/
RTAssertSetQuiet(true);
RTAssertSetMayPanic(false);
for (int i = RTSYSDMISTR_INVALID + 1; i < RTSYSDMISTR_END; i++)
{
RTTESTI_CHECK_RC(RTSystemQueryDmiString((RTSYSDMISTR)i, szInfo, 0), VERR_INVALID_PARAMETER);
/* Get the length of the info and check that we get overflow errors for
everything less that it. */
rc = RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, sizeof(szInfo));
if (RT_FAILURE(rc))
continue;
size_t const cchInfo = strlen(szInfo);
for (size_t cch = 1; cch < sizeof(szInfo) && cch < cchInfo; cch++)
{
memset(szInfo, 0x7f, sizeof(szInfo));
RTTESTI_CHECK_RC(RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, cch), VERR_BUFFER_OVERFLOW);
/* check the padding. */
for (size_t off = cch; off < sizeof(szInfo); off++)
if (szInfo[off] != 0x7f)
{
RTTestIFailed("level=%d, rc=%Rrc, cch=%zu, off=%zu: Wrote too much!\n", i, rc, cch, off);
break;
}
/* check for zero terminator. */
if (!RTStrEnd(szInfo, cch))
RTTestIFailed("level=%d, rc=%Rrc, cch=%zu: Buffer not terminated!\n", i, rc, cch);
}
/* Check that the exact length works. */
rc = RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, cchInfo + 1);
if (rc != VINF_SUCCESS)
RTTestIFailed("level=%d: rc=%Rrc when specifying exactly right buffer length (%zu)\n", i, rc, cchInfo + 1);
}
return RTTestSummaryAndDestroy(hTest);
}
static void vboxHeaderFooter(PRTLOGGER pReleaseLogger, RTLOGPHASE enmPhase, PFNRTLOGPHASEMSG pfnLog)
{
/* some introductory information */
static RTTIMESPEC s_TimeSpec;
char szTmp[256];
if (enmPhase == RTLOGPHASE_BEGIN)
RTTimeNow(&s_TimeSpec);
RTTimeSpecToString(&s_TimeSpec, szTmp, sizeof(szTmp));
switch (enmPhase)
{
case RTLOGPHASE_BEGIN:
{
bool fOldBuffered = RTLogSetBuffering(pReleaseLogger, true /*fBuffered*/);
pfnLog(pReleaseLogger,
"VirtualBox %s %s r%u %s (%s %s) release log\n"
#ifdef VBOX_BLEEDING_EDGE
"EXPERIMENTAL build " VBOX_BLEEDING_EDGE "\n"
#endif
"Log opened %s\n",
g_pszLogEntity, VBOX_VERSION_STRING, RTBldCfgRevision(),
RTBldCfgTargetDotArch(), __DATE__, __TIME__, szTmp);
int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "OS Product: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "OS Release: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "OS Version: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "OS Service Pack: %s\n", szTmp);
vrc = RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_NAME, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "DMI Product Name: %s\n", szTmp);
vrc = RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_VERSION, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "DMI Product Version: %s\n", szTmp);
uint64_t cbHostRam = 0, cbHostRamAvail = 0;
vrc = RTSystemQueryTotalRam(&cbHostRam);
if (RT_SUCCESS(vrc))
vrc = RTSystemQueryAvailableRam(&cbHostRamAvail);
if (RT_SUCCESS(vrc))
pfnLog(pReleaseLogger, "Host RAM: %lluMB RAM, available: %lluMB\n",
cbHostRam / _1M, cbHostRamAvail / _1M);
/* the package type is interesting for Linux distributions */
char szExecName[RTPATH_MAX];
char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
pfnLog(pReleaseLogger,
"Executable: %s\n"
"Process ID: %u\n"
"Package type: %s"
#ifdef VBOX_OSE
" (OSE)"
#endif
"\n",
pszExecName ? pszExecName : "unknown",
RTProcSelf(),
VBOX_PACKAGE_STRING);
RTLogSetBuffering(pReleaseLogger, fOldBuffered);
break;
}
case RTLOGPHASE_PREROTATE:
pfnLog(pReleaseLogger, "Log rotated - Log started %s\n", szTmp);
break;
case RTLOGPHASE_POSTROTATE:
pfnLog(pReleaseLogger, "Log continuation - Log started %s\n", szTmp);
break;
case RTLOGPHASE_END:
pfnLog(pReleaseLogger, "End of log file - Log started %s\n", szTmp);
break;
default:
/* nothing */;
}
}
