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 */; } }