static int vbglR3DnDCreateDropDir(char* pszDropDir, size_t cbSize)
{
/* Validate input */
AssertPtrReturn(pszDropDir, VERR_INVALID_POINTER);
AssertReturn(cbSize, VERR_INVALID_PARAMETER);
/* Get the users document directory (usually $HOME/Documents). */
int rc = RTPathUserDocuments(pszDropDir, cbSize);
if (RT_FAILURE(rc))
return rc;
/* Append our base drop directory. */
rc = RTPathAppend(pszDropDir, cbSize, "VirtualBox Dropped Files");
if (RT_FAILURE(rc))
return rc;
/* Create it when necessary. */
if (!RTDirExists(pszDropDir))
{
rc = RTDirCreateFullPath(pszDropDir, RTFS_UNIX_IRWXU);
if (RT_FAILURE(rc))
return rc;
}
/* The actually drop directory consist of the current time stamp and a
* unique number when necessary. */
char pszTime[64];
RTTIMESPEC time;
if (!RTTimeSpecToString(RTTimeNow(&time), pszTime, sizeof(pszTime)))
return VERR_BUFFER_OVERFLOW;
rc = RTPathAppend(pszDropDir, cbSize, pszTime);
if (RT_FAILURE(rc))
return rc;
/* Create it (only accessible by the current user) */
return RTDirCreateUniqueNumbered(pszDropDir, cbSize, RTFS_UNIX_IRWXU, 3, '-');
}
/**
* Worker for cmdDisplayAll.
*/
static BOOL WINAPI displaySystemStoreCallback(const void *pvSystemStore, DWORD dwFlags, PCERT_SYSTEM_STORE_INFO pStoreInfo,
void *pvReserved, void *pvArg)
{
if (g_cVerbosityLevel > 1)
RTPrintf(" pvSystemStore=%p dwFlags=%#x pStoreInfo=%p pvReserved=%p\n", pvSystemStore, dwFlags, pStoreInfo, pvReserved);
LPCWSTR pwszStoreNm = NULL;
if (dwFlags & CERT_SYSTEM_STORE_RELOCATE_FLAG)
{
const CERT_SYSTEM_STORE_RELOCATE_PARA *pRelPara = (const CERT_SYSTEM_STORE_RELOCATE_PARA *)pvSystemStore;
pwszStoreNm = pRelPara->pwszSystemStore;
RTPrintf(" %#010x '%ls' hKeyBase=%p\n", dwFlags, pwszStoreNm, pRelPara->hKeyBase);
}
else
{
pwszStoreNm = (LPCWSTR)pvSystemStore;
RTPrintf(" %#010x '%ls'\n", dwFlags, pwszStoreNm);
}
/*
* Open the store and list the certificates within.
*/
DWORD dwDst = (dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK);
HCERTSTORE hStore = CertOpenStore(CERT_STORE_PROV_SYSTEM_W,
PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
NULL /* hCryptProv = default */,
dwDst | CERT_STORE_OPEN_EXISTING_FLAG,
pwszStoreNm);
if (hStore)
{
PCCERT_CONTEXT pCertCtx = NULL;
while ((pCertCtx = CertEnumCertificatesInStore(hStore, pCertCtx)) != NULL)
{
if (g_cVerbosityLevel > 1)
RTPrintf(" pCertCtx=%p dwCertEncodingType=%#x cbCertEncoded=%#x pCertInfo=%p\n",
pCertCtx, pCertCtx->dwCertEncodingType, pCertCtx->cbCertEncoded, pCertCtx->pCertInfo);
WCHAR wszName[1024];
if (CertGetNameStringW(pCertCtx, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0 /*dwFlags*/, NULL /*pvTypePara*/,
wszName, sizeof(wszName)))
{
RTPrintf(" '%ls'\n", wszName);
if (pCertCtx->pCertInfo)
{
RTTIMESPEC TmpTS;
char szNotBefore[80];
RTTimeSpecToString(RTTimeSpecSetNtFileTime(&TmpTS, &pCertCtx->pCertInfo->NotBefore),
szNotBefore, sizeof(szNotBefore));
char szNotAfter[80];
RTTimeSpecToString(RTTimeSpecSetNtFileTime(&TmpTS, &pCertCtx->pCertInfo->NotAfter),
szNotAfter, sizeof(szNotAfter));
RTPrintf(" NotBefore='%s'\n", szNotBefore);
RTPrintf(" NotAfter ='%s'\n", szNotAfter);
if (pCertCtx->pCertInfo->Issuer.cbData)
{
if (CertGetNameStringW(pCertCtx, CERT_NAME_SIMPLE_DISPLAY_TYPE, CERT_NAME_ISSUER_FLAG, NULL /*pvTypePara*/,
wszName, sizeof(wszName)))
RTPrintf(" Issuer='%ls'\n", wszName);
else
RTMsgError("CertGetNameStringW(Issuer) failed: %s\n", errorToString(GetLastError()));
}
}
}
else
RTMsgError("CertGetNameStringW(Subject) failed: %s\n", errorToString(GetLastError()));
}
CertCloseStore(hStore, CERT_CLOSE_STORE_CHECK_FLAG);
}
else
RTMsgError("CertOpenStore failed opening %#x:'%ls': %s\n", dwDst, pwszStoreNm, errorToString(GetLastError()));
return TRUE;
}
/**
* Release logger callback.
*
* @return IPRT status code.
* @param pLoggerRelease
* @param enmPhase
* @param pfnLog
*/
static void VBoxServiceLogHeaderFooter(PRTLOGGER pLoggerRelease, 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:
{
pfnLog(pLoggerRelease,
"VBoxService %s r%s (verbosity: %d) %s (%s %s) release log\n"
"Log opened %s\n",
RTBldCfgVersion(), RTBldCfgRevisionStr(), g_cVerbosity, VBOX_BUILD_TARGET,
__DATE__, __TIME__, szTmp);
int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pLoggerRelease, "OS Product: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pLoggerRelease, "OS Release: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pLoggerRelease, "OS Version: %s\n", szTmp);
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pLoggerRelease, "OS Service Pack: %s\n", szTmp);
/* the package type is interesting for Linux distributions */
char szExecName[RTPATH_MAX];
char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
pfnLog(pLoggerRelease,
"Executable: %s\n"
"Process ID: %u\n"
"Package type: %s"
#ifdef VBOX_OSE
" (OSE)"
#endif
"\n",
pszExecName ? pszExecName : "unknown",
RTProcSelf(),
VBOX_PACKAGE_STRING);
break;
}
case RTLOGPHASE_PREROTATE:
pfnLog(pLoggerRelease, "Log rotated - Log started %s\n", szTmp);
break;
case RTLOGPHASE_POSTROTATE:
pfnLog(pLoggerRelease, "Log continuation - Log started %s\n", szTmp);
break;
case RTLOGPHASE_END:
pfnLog(pLoggerRelease, "End of log file - Log started %s\n", szTmp);
break;
default:
/* nothing */
;
}
}
/**
* Creates the default logger instance for a VBox process.
*
* @returns Pointer to the logger instance.
*/
RTDECL(PRTLOGGER) RTLogDefaultInit(void)
{
/*
* Initialize the default logger instance.
* Take care to do this once and not recursively.
*/
static volatile uint32_t fInitializing = 0;
PRTLOGGER pLogger;
int rc;
if (g_pLogger || !ASMAtomicCmpXchgU32(&fInitializing, 1, 0))
return g_pLogger;
#ifdef IN_RING3
/*
* Assert the group definitions.
*/
#define ASSERT_LOG_GROUP(grp) ASSERT_LOG_GROUP2(LOG_GROUP_##grp, #grp)
#define ASSERT_LOG_GROUP2(def, str) \
do { if (strcmp(g_apszGroups[def], str)) {printf("%s='%s' expects '%s'\n", #def, g_apszGroups[def], str); RTAssertDoPanic(); } } while (0)
ASSERT_LOG_GROUP(DEFAULT);
ASSERT_LOG_GROUP(AUDIO_MIXER);
ASSERT_LOG_GROUP(AUDIO_MIXER_BUFFER);
ASSERT_LOG_GROUP(CFGM);
ASSERT_LOG_GROUP(CPUM);
ASSERT_LOG_GROUP(CSAM);
ASSERT_LOG_GROUP(DBGC);
ASSERT_LOG_GROUP(DBGF);
ASSERT_LOG_GROUP(DBGF_INFO);
ASSERT_LOG_GROUP(DEV);
ASSERT_LOG_GROUP(DEV_AC97);
ASSERT_LOG_GROUP(DEV_ACPI);
ASSERT_LOG_GROUP(DEV_APIC);
ASSERT_LOG_GROUP(DEV_FDC);
ASSERT_LOG_GROUP(DEV_HDA);
ASSERT_LOG_GROUP(DEV_HDA_CODEC);
ASSERT_LOG_GROUP(DEV_HPET);
ASSERT_LOG_GROUP(DEV_IDE);
ASSERT_LOG_GROUP(DEV_KBD);
ASSERT_LOG_GROUP(DEV_LPC);
ASSERT_LOG_GROUP(DEV_NE2000);
ASSERT_LOG_GROUP(DEV_PC);
ASSERT_LOG_GROUP(DEV_PC_ARCH);
ASSERT_LOG_GROUP(DEV_PC_BIOS);
ASSERT_LOG_GROUP(DEV_PCI);
ASSERT_LOG_GROUP(DEV_PCNET);
ASSERT_LOG_GROUP(DEV_PIC);
ASSERT_LOG_GROUP(DEV_PIT);
ASSERT_LOG_GROUP(DEV_RTC);
ASSERT_LOG_GROUP(DEV_SB16);
ASSERT_LOG_GROUP(DEV_SERIAL);
ASSERT_LOG_GROUP(DEV_SMC);
ASSERT_LOG_GROUP(DEV_VGA);
ASSERT_LOG_GROUP(DEV_VMM);
ASSERT_LOG_GROUP(DEV_VMM_STDERR);
ASSERT_LOG_GROUP(DIS);
ASSERT_LOG_GROUP(DRV);
ASSERT_LOG_GROUP(DRV_ACPI);
ASSERT_LOG_GROUP(DRV_AUDIO);
ASSERT_LOG_GROUP(DRV_BLOCK);
ASSERT_LOG_GROUP(DRV_FLOPPY);
ASSERT_LOG_GROUP(DRV_HOST_AUDIO);
ASSERT_LOG_GROUP(DRV_HOST_DVD);
ASSERT_LOG_GROUP(DRV_HOST_FLOPPY);
ASSERT_LOG_GROUP(DRV_ISO);
ASSERT_LOG_GROUP(DRV_KBD_QUEUE);
ASSERT_LOG_GROUP(DRV_MOUSE_QUEUE);
ASSERT_LOG_GROUP(DRV_NAT);
ASSERT_LOG_GROUP(DRV_RAW_IMAGE);
ASSERT_LOG_GROUP(DRV_TUN);
ASSERT_LOG_GROUP(DRV_USBPROXY);
ASSERT_LOG_GROUP(DRV_VBOXHDD);
ASSERT_LOG_GROUP(DRV_VRDE_AUDIO);
ASSERT_LOG_GROUP(DRV_VSWITCH);
ASSERT_LOG_GROUP(DRV_VUSB);
ASSERT_LOG_GROUP(EM);
ASSERT_LOG_GROUP(GUI);
ASSERT_LOG_GROUP(HGCM);
ASSERT_LOG_GROUP(HM);
ASSERT_LOG_GROUP(IOM);
ASSERT_LOG_GROUP(LWIP);
ASSERT_LOG_GROUP(MAIN);
ASSERT_LOG_GROUP(MM);
ASSERT_LOG_GROUP(MM_HEAP);
ASSERT_LOG_GROUP(MM_HYPER);
ASSERT_LOG_GROUP(MM_HYPER_HEAP);
ASSERT_LOG_GROUP(MM_PHYS);
ASSERT_LOG_GROUP(MM_POOL);
ASSERT_LOG_GROUP(NAT_SERVICE);
ASSERT_LOG_GROUP(NET_SERVICE);
ASSERT_LOG_GROUP(PATM);
ASSERT_LOG_GROUP(PDM);
ASSERT_LOG_GROUP(PDM_DEVICE);
ASSERT_LOG_GROUP(PDM_DRIVER);
ASSERT_LOG_GROUP(PDM_LDR);
ASSERT_LOG_GROUP(PDM_QUEUE);
ASSERT_LOG_GROUP(PGM);
ASSERT_LOG_GROUP(PGM_POOL);
ASSERT_LOG_GROUP(REM);
ASSERT_LOG_GROUP(REM_DISAS);
ASSERT_LOG_GROUP(REM_HANDLER);
ASSERT_LOG_GROUP(REM_IOPORT);
ASSERT_LOG_GROUP(REM_MMIO);
ASSERT_LOG_GROUP(REM_PRINTF);
ASSERT_LOG_GROUP(REM_RUN);
ASSERT_LOG_GROUP(SELM);
ASSERT_LOG_GROUP(SSM);
ASSERT_LOG_GROUP(STAM);
ASSERT_LOG_GROUP(SUP);
ASSERT_LOG_GROUP(TM);
ASSERT_LOG_GROUP(TRPM);
ASSERT_LOG_GROUP(VM);
ASSERT_LOG_GROUP(VMM);
ASSERT_LOG_GROUP(VRDP);
#undef ASSERT_LOG_GROUP
#undef ASSERT_LOG_GROUP2
#endif /* IN_RING3 */
/*
* Create the default logging instance.
*/
#ifdef IN_RING3
# ifndef IN_GUEST
char szExecName[RTPATH_MAX];
if (!RTProcGetExecutablePath(szExecName, sizeof(szExecName)))
strcpy(szExecName, "VBox");
RTTIMESPEC TimeSpec;
RTTIME Time;
RTTimeExplode(&Time, RTTimeNow(&TimeSpec));
rc = RTLogCreate(&pLogger, 0, NULL, "VBOX_LOG", RT_ELEMENTS(g_apszGroups), &g_apszGroups[0], RTLOGDEST_FILE,
"./%04d-%02d-%02d-%02d-%02d-%02d.%03d-%s-%d.log",
Time.i32Year, Time.u8Month, Time.u8MonthDay, Time.u8Hour, Time.u8Minute, Time.u8Second, Time.u32Nanosecond / 10000000,
RTPathFilename(szExecName), RTProcSelf());
if (RT_SUCCESS(rc))
{
/*
* Write a log header.
*/
char szBuf[RTPATH_MAX];
RTTimeSpecToString(&TimeSpec, szBuf, sizeof(szBuf));
RTLogLoggerEx(pLogger, 0, ~0U, "Log created: %s\n", szBuf);
RTLogLoggerEx(pLogger, 0, ~0U, "Executable: %s\n", szExecName);
/* executable and arguments - tricky and all platform specific. */
# if defined(RT_OS_WINDOWS)
RTLogLoggerEx(pLogger, 0, ~0U, "Commandline: %ls\n", GetCommandLineW());
# elif defined(RT_OS_SOLARIS)
psinfo_t psi;
char szArgFileBuf[80];
RTStrPrintf(szArgFileBuf, sizeof(szArgFileBuf), "/proc/%ld/psinfo", (long)getpid());
FILE* pFile = fopen(szArgFileBuf, "rb");
if (pFile)
{
if (fread(&psi, sizeof(psi), 1, pFile) == 1)
{
# if 0 /* 100% safe:*/
RTLogLoggerEx(pLogger, 0, ~0U, "Args: %s\n", psi.pr_psargs);
# else /* probably safe: */
const char * const *argv = (const char * const *)psi.pr_argv;
for (int iArg = 0; iArg < psi.pr_argc; iArg++)
RTLogLoggerEx(pLogger, 0, ~0U, "Arg[%d]: %s\n", iArg, argv[iArg]);
# endif
}
fclose(pFile);
}
# elif defined(RT_OS_LINUX)
FILE *pFile = fopen("/proc/self/cmdline", "r");
if (pFile)
{
/* braindead */
unsigned iArg = 0;
int ch;
bool fNew = true;
while (!feof(pFile) && (ch = fgetc(pFile)) != EOF)
{
if (fNew)
{
RTLogLoggerEx(pLogger, 0, ~0U, "Arg[%u]: ", iArg++);
fNew = false;
}
if (ch)
RTLogLoggerEx(pLogger, 0, ~0U, "%c", ch);
else
{
RTLogLoggerEx(pLogger, 0, ~0U, "\n");
fNew = true;
}
}
if (!fNew)
RTLogLoggerEx(pLogger, 0, ~0U, "\n");
fclose(pFile);
}
# elif defined(RT_OS_HAIKU)
team_info info;
if (get_team_info(0, &info) == B_OK)
{
/* there is an info.argc, but no way to know arg boundaries */
RTLogLoggerEx(pLogger, 0, ~0U, "Commandline: %.64s\n", info.args);
}
# elif defined(RT_OS_FREEBSD)
/* Retrieve the required length first */
int aiName[4];
aiName[0] = CTL_KERN;
aiName[1] = KERN_PROC;
aiName[2] = KERN_PROC_ARGS; /* Introduced in FreeBSD 4.0 */
aiName[3] = getpid();
size_t cchArgs = 0;
int rcBSD = sysctl(aiName, RT_ELEMENTS(aiName), NULL, &cchArgs, NULL, 0);
if (cchArgs > 0)
{
char *pszArgFileBuf = (char *)RTMemAllocZ(cchArgs + 1 /* Safety */);
if (pszArgFileBuf)
{
/* Retrieve the argument list */
rcBSD = sysctl(aiName, RT_ELEMENTS(aiName), pszArgFileBuf, &cchArgs, NULL, 0);
if (!rcBSD)
{
unsigned iArg = 0;
size_t off = 0;
while (off < cchArgs)
{
size_t cchArg = strlen(&pszArgFileBuf[off]);
RTLogLoggerEx(pLogger, 0, ~0U, "Arg[%u]: %s\n", iArg, &pszArgFileBuf[off]);
/* advance */
off += cchArg + 1;
iArg++;
}
}
RTMemFree(pszArgFileBuf);
}
}
# elif defined(RT_OS_OS2) || defined(RT_OS_DARWIN)
/* commandline? */
# else
# error needs porting.
# endif
}
# else /* IN_GUEST */
/* The user destination is backdoor logging. */
rc = RTLogCreate(&pLogger, 0, NULL, "VBOX_LOG", RT_ELEMENTS(g_apszGroups), &g_apszGroups[0], RTLOGDEST_USER, "VBox.log");
# endif /* IN_GUEST */
#else /* IN_RING0 */
/* Some platforms has trouble allocating memory with interrupts and/or
preemption disabled. Check and fail before we panic. */
# if defined(RT_OS_DARWIN)
if ( !ASMIntAreEnabled()
|| !RTThreadPreemptIsEnabled(NIL_RTTHREAD))
return NULL;
# endif
# ifndef IN_GUEST
rc = RTLogCreate(&pLogger, 0, NULL, "VBOX_LOG", RT_ELEMENTS(g_apszGroups), &g_apszGroups[0], RTLOGDEST_FILE, "VBox-ring0.log");
# else /* IN_GUEST */
rc = RTLogCreate(&pLogger, 0, NULL, "VBOX_LOG", RT_ELEMENTS(g_apszGroups), &g_apszGroups[0], RTLOGDEST_USER, "VBox-ring0.log");
# endif /* IN_GUEST */
if (RT_SUCCESS(rc))
{
/*
* This is where you set your ring-0 logging preferences.
*
* On platforms which don't differ between debugger and kernel
* log printing, STDOUT is gonna be a stub and the DEBUGGER
* destination is the one doing all the work. On platforms
* that do differ (like Darwin), STDOUT is the kernel log.
*/
# if defined(DEBUG_bird)
/*RTLogGroupSettings(pLogger, "all=~0 -default.l6.l5.l4.l3");*/
RTLogFlags(pLogger, "enabled unbuffered pid tid");
# ifndef IN_GUEST
pLogger->fDestFlags |= RTLOGDEST_DEBUGGER | RTLOGDEST_STDOUT;
# endif
# endif
# if defined(DEBUG_sandervl) && !defined(IN_GUEST)
RTLogGroupSettings(pLogger, "+all");
RTLogFlags(pLogger, "enabled unbuffered");
pLogger->fDestFlags |= RTLOGDEST_DEBUGGER;
# endif
# if defined(DEBUG_ramshankar) /* Guest ring-0 as well */
RTLogGroupSettings(pLogger, "+all.e.l.f");
RTLogFlags(pLogger, "enabled unbuffered");
pLogger->fDestFlags |= RTLOGDEST_DEBUGGER;
# endif
# if defined(DEBUG_aleksey) /* Guest ring-0 as well */
//RTLogGroupSettings(pLogger, "net_flt_drv.e.l.f.l3.l4.l5 +net_adp_drv.e.l.f.l3.l4.l5");
RTLogGroupSettings(pLogger, "net_flt_drv.e.l.f.l3.l4.l5.l6");
RTLogFlags(pLogger, "enabled unbuffered");
pLogger->fDestFlags |= RTLOGDEST_DEBUGGER | RTLOGDEST_STDOUT;
# endif
# if defined(DEBUG_andy) /* Guest ring-0 as well */
RTLogGroupSettings(pLogger, "+all.e.l.f");
RTLogFlags(pLogger, "enabled unbuffered pid tid");
pLogger->fDestFlags |= RTLOGDEST_DEBUGGER | RTLOGDEST_STDOUT;
# endif
# if defined(DEBUG_misha) /* Guest ring-0 as well */
RTLogFlags(pLogger, "enabled unbuffered");
pLogger->fDestFlags |= RTLOGDEST_DEBUGGER;
# endif
# if defined(DEBUG_michael) && defined(IN_GUEST)
RTLogGroupSettings(pLogger, "+vga.e.l.f");
RTLogFlags(pLogger, "enabled unbuffered");
pLogger->fDestFlags |= RTLOGDEST_DEBUGGER | RTLOGDEST_STDOUT;
# endif
# if 0 /* vboxdrv logging - ATTENTION: this is what we're referring to guys! Change to '# if 1'. */
RTLogGroupSettings(pLogger, "all=~0 -default.l6.l5.l4.l3");
RTLogFlags(pLogger, "enabled unbuffered tid");
pLogger->fDestFlags |= RTLOGDEST_DEBUGGER | RTLOGDEST_STDOUT;
# endif
}
#endif /* IN_RING0 */
return g_pLogger = RT_SUCCESS(rc) ? pLogger : NULL;
}
static int vboxInitLogging(const char *pszFilename, bool bGenNameSuffix)
{
PRTLOGGER loggerRelease;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
RTUINT fFlags = RTLOGFLAGS_PREFIX_TIME_PROG;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fFlags |= RTLOGFLAGS_USECRLF;
#endif
char szError[RTPATH_MAX + 128] = "";
const char * pszFilenameFmt;
RTLOGDEST enmLogDest;
if(pszFilename)
{
if(bGenNameSuffix)
pszFilenameFmt = "%s.%ld.log";
else
pszFilenameFmt = "%s";
enmLogDest = RTLOGDEST_FILE;
}
else
{
pszFilenameFmt = NULL;
enmLogDest = RTLOGDEST_STDOUT;
}
int vrc = RTLogCreateEx(&loggerRelease, fFlags, "all",
"VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups, enmLogDest,
NULL /* pfnBeginEnd */, 0 /* cHistory */, 0 /* cbHistoryFileMax */, 0 /* uHistoryTimeMax */,
szError, sizeof(szError), pszFilenameFmt, pszFilename, RTTimeMilliTS());
if (RT_SUCCESS(vrc))
{
/* some introductory information */
RTTIMESPEC timeSpec;
char szTmp[256];
RTTimeSpecToString(RTTimeNow(&timeSpec), szTmp, sizeof(szTmp));
RTLogRelLogger(loggerRelease, 0, ~0U,
"VBoxTestGL %s r%u %s (%s %s) release log\n"
#ifdef VBOX_BLEEDING_EDGE
"EXPERIMENTAL build " VBOX_BLEEDING_EDGE "\n"
#endif
"Log opened %s\n",
VBOX_VERSION_STRING, RTBldCfgRevision(), VBOX_BUILD_TARGET,
__DATE__, __TIME__, szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Product: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Release: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Version: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Service Pack: %s\n", szTmp);
// RTLogRelLogger(loggerRelease, 0, ~0U, "Host RAM: %uMB RAM, available: %uMB\n",
// uHostRamMb, uHostRamAvailMb);
/* the package type is interesting for Linux distributions */
char szExecName[RTPATH_MAX];
char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
RTLogRelLogger(loggerRelease, 0, ~0U,
"Executable: %s\n"
"Process ID: %u\n"
"Package type: %s"
#ifdef VBOX_OSE
" (OSE)"
#endif
"\n",
pszExecName ? pszExecName : "unknown",
RTProcSelf(),
VBOX_PACKAGE_STRING);
/* register this logger as the release logger */
RTLogRelSetDefaultInstance(loggerRelease);
return VINF_SUCCESS;
}
return vrc;
}
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 */;
}
}
