/**
* Try fetch the DMI strings from the system.
*/
static void fwCommonUseHostDMIStrings(void)
{
int rc;
rc = RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_NAME,
g_szHostDmiSystemProduct, sizeof(g_szHostDmiSystemProduct));
if (RT_SUCCESS(rc))
{
s_szDefDmiSystemProduct = g_szHostDmiSystemProduct;
LogRel(("DMI: Using DmiSystemProduct from host: %s\n", g_szHostDmiSystemProduct));
}
rc = RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_VERSION,
g_szHostDmiSystemVersion, sizeof(g_szHostDmiSystemVersion));
if (RT_SUCCESS(rc))
{
s_szDefDmiSystemVersion = g_szHostDmiSystemVersion;
LogRel(("DMI: Using DmiSystemVersion from host: %s\n", g_szHostDmiSystemVersion));
}
}
/**
* Generates a kind of report of the hardware, software and whatever else we
* think might be useful to know about the testbox.
*/
static RTEXITCODE handlerReport(int argc, char **argv)
{
NOREF(argc); NOREF(argv);
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
/*
* For now, a simple CPUID dump. Need to figure out how to share code
* like this with other bits, putting it in IPRT.
*/
RTPrintf("CPUID Dump\n"
"Leaf eax ebx ecx edx\n"
"---------------------------------------------\n");
static uint32_t const s_auRanges[] =
{
UINT32_C(0x00000000),
UINT32_C(0x80000000),
UINT32_C(0x80860000),
UINT32_C(0xc0000000),
UINT32_C(0x40000000),
};
for (uint32_t iRange = 0; iRange < RT_ELEMENTS(s_auRanges); iRange++)
{
uint32_t const uFirst = s_auRanges[iRange];
uint32_t uEax, uEbx, uEcx, uEdx;
ASMCpuIdExSlow(uFirst, 0, 0, 0, &uEax, &uEbx, &uEcx, &uEdx);
if (uEax >= uFirst && uEax < uFirst + 100)
{
uint32_t const cLeafs = RT_MIN(uEax - uFirst + 1, 32);
for (uint32_t iLeaf = 0; iLeaf < cLeafs; iLeaf++)
{
uint32_t uLeaf = uFirst + iLeaf;
ASMCpuIdExSlow(uLeaf, 0, 0, 0, &uEax, &uEbx, &uEcx, &uEdx);
/* Clear APIC IDs to avoid submitting new reports all the time. */
if (uLeaf == 1)
uEbx &= UINT32_C(0x00ffffff);
if (uLeaf == 0xb)
uEdx = 0;
if (uLeaf == 0x8000001e)
uEax = 0;
/* Clear some other node/cpu/core/thread ids. */
if (uLeaf == 0x8000001e)
{
uEbx &= UINT32_C(0xffffff00);
uEcx &= UINT32_C(0xffffff00);
}
RTPrintf("%08x: %08x %08x %08x %08x\n", uLeaf, uEax, uEbx, uEcx, uEdx);
}
}
}
RTPrintf("\n");
/*
* DMI info.
*/
RTPrintf("DMI Info\n"
"--------\n");
static const struct { const char *pszName; RTSYSDMISTR enmDmiStr; } s_aDmiStrings[] =
{
{ "Product Name", RTSYSDMISTR_PRODUCT_NAME },
{ "Product version", RTSYSDMISTR_PRODUCT_VERSION },
{ "Product UUID", RTSYSDMISTR_PRODUCT_UUID },
{ "Product Serial", RTSYSDMISTR_PRODUCT_SERIAL },
{ "System Manufacturer", RTSYSDMISTR_MANUFACTURER },
};
for (uint32_t iDmiString = 0; iDmiString < RT_ELEMENTS(s_aDmiStrings); iDmiString++)
{
char szTmp[4096];
RT_ZERO(szTmp);
int rc = RTSystemQueryDmiString(s_aDmiStrings[iDmiString].enmDmiStr, szTmp, sizeof(szTmp) - 1);
if (RT_SUCCESS(rc))
RTPrintf("%25s: %s\n", s_aDmiStrings[iDmiString].pszName, RTStrStrip(szTmp));
else
RTPrintf("%25s: %s [rc=%Rrc]\n", s_aDmiStrings[iDmiString].pszName, RTStrStrip(szTmp), rc);
}
RTPrintf("\n");
#else
#endif
/*
* Dump the environment.
*/
RTPrintf("Environment\n"
"-----------\n");
RTENV hEnv;
int rc = RTEnvClone(&hEnv, RTENV_DEFAULT);
if (RT_SUCCESS(rc))
{
uint32_t cVars = RTEnvCountEx(hEnv);
for (uint32_t iVar = 0; iVar < cVars; iVar++)
{
char szVar[1024];
char szValue[16384];
rc = RTEnvGetByIndexEx(hEnv, iVar, szVar, sizeof(szVar), szValue, sizeof(szValue));
/* zap the value of variables that are subject to change. */
if ( (RT_SUCCESS(rc) || rc == VERR_BUFFER_OVERFLOW)
&& ( !strcmp(szVar, "TESTBOX_SCRIPT_REV")
|| !strcmp(szVar, "TESTBOX_ID")
|| !strcmp(szVar, "TESTBOX_SCRATCH_SIZE")
|| !strcmp(szVar, "TESTBOX_TIMEOUT")
|| !strcmp(szVar, "TESTBOX_TIMEOUT_ABS")
|| !strcmp(szVar, "TESTBOX_TEST_SET_ID")
)
)
strcpy(szValue, "<volatile>");
if (RT_SUCCESS(rc))
RTPrintf("%25s=%s\n", szVar, szValue);
else if (rc == VERR_BUFFER_OVERFLOW)
RTPrintf("%25s=%s [VERR_BUFFER_OVERFLOW]\n", szVar, szValue);
else
RTPrintf("rc=%Rrc\n", rc);
}
RTEnvDestroy(hEnv);
}
/** @todo enumerate volumes and whatnot. */
int cch = RTPrintf("\n");
return cch > 0 ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
}
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 */;
}
}
