/**
* Creates the default release logger outputting to the specified file.
*
* @return IPRT status code.
* @param pszLogFile Filename for log output. Optional.
*/
static int VBoxServiceLogCreate(const char *pszLogFile)
{
/* Create release logger (stdout + file). */
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fFlags |= RTLOGFLAGS_USECRLF;
#endif
char szError[RTPATH_MAX + 128] = "";
int rc = RTLogCreateEx(&g_pLoggerRelease, fFlags, "all",
"VBOXSERVICE_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups,
RTLOGDEST_STDOUT,
VBoxServiceLogHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
szError, sizeof(szError), pszLogFile);
if (RT_SUCCESS(rc))
{
/* register this logger as the release logger */
RTLogRelSetDefaultInstance(g_pLoggerRelease);
/* Explicitly flush the log in case of VBOXSERVICE_RELEASE_LOG=buffered. */
RTLogFlush(g_pLoggerRelease);
}
return rc;
}
int VBoxSVCLogRelCreate(const char *pszLogFile, uint32_t cHistory,
uint32_t uHistoryFileTime, uint64_t uHistoryFileSize)
{
/* create release logger */
PRTLOGGER pLoggerReleaseFile;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fFlags |= RTLOGFLAGS_USECRLF;
#endif
char szError[RTPATH_MAX + 128] = "";
int vrc = RTLogCreateEx(&pLoggerReleaseFile, fFlags, "all",
"VBOXSVC_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups, 0 /* fDestFlags */,
vboxsvcHeaderFooter, cHistory, uHistoryFileSize, uHistoryFileTime,
szError, sizeof(szError), pszLogFile);
if (RT_SUCCESS(vrc))
{
/* register this logger as the release logger */
RTLogRelSetDefaultInstance(pLoggerReleaseFile);
/* Explicitly flush the log in case of VBOXWEBSRV_RELEASE_LOG=buffered. */
RTLogFlush(pLoggerReleaseFile);
}
else
{
/* print a message, but do not fail */
RTMsgError("failed to open release log (%s, %Rrc)", szError, vrc);
}
return vrc;
}
int VBoxLogRelCreate(const char *pcszEntity, const char *pcszLogFile,
uint32_t fFlags, const char *pcszGroupSettings,
const char *pcszEnvVarBase, uint32_t fDestFlags,
uint32_t cMaxEntriesPerGroup, uint32_t cHistory,
uint32_t uHistoryFileTime, uint64_t uHistoryFileSize,
char *pszError, size_t cbError)
{
Assert(cbError >= RTPATH_MAX + 128);
/* create release logger */
PRTLOGGER pReleaseLogger;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fFlags |= RTLOGFLAGS_USECRLF;
#endif
g_pszLogEntity = pcszEntity;
int vrc = RTLogCreateEx(&pReleaseLogger, fFlags, "all all.restrict default.unrestricted",
pcszEnvVarBase, RT_ELEMENTS(s_apszGroups), s_apszGroups, fDestFlags,
vboxHeaderFooter, cHistory, uHistoryFileSize, uHistoryFileTime,
pszError, cbError, pcszLogFile);
if (RT_SUCCESS(vrc))
{
/* make sure that we don't flood logfiles */
RTLogSetGroupLimit(pReleaseLogger, cMaxEntriesPerGroup);
/* explicitly flush the log, to have some info when buffering */
RTLogFlush(pReleaseLogger);
/* register this logger as the release logger */
RTLogRelSetDefaultInstance(pReleaseLogger);
}
return vrc;
}
/**
* Creates the default release logger outputting to the specified file.
*
* Pass NULL to disabled logging.
*
* @return IPRT status code.
* @param pszLogFile Filename for log output. NULL disables logging
* (r=bird: No, it doesn't!).
*/
int VGSvcLogCreate(const char *pszLogFile)
{
/* Create release logger (stdout + file). */
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fFlags |= RTLOGFLAGS_USECRLF;
#endif
int rc = RTLogCreateEx(&g_pLoggerRelease, fFlags, "all",
#ifdef DEBUG
"VBOXSERVICE_LOG",
#else
"VBOXSERVICE_RELEASE_LOG",
#endif
RT_ELEMENTS(s_apszGroups), s_apszGroups,
RTLOGDEST_STDOUT | RTLOGDEST_USER,
vgsvcLogHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
NULL /*pErrInfo*/, "%s", pszLogFile ? pszLogFile : "");
if (RT_SUCCESS(rc))
{
/* register this logger as the release logger */
RTLogRelSetDefaultInstance(g_pLoggerRelease);
/* Explicitly flush the log in case of VBOXSERVICE_RELEASE_LOG=buffered. */
RTLogFlush(g_pLoggerRelease);
}
return rc;
}
/**
* Create default logger in order to print output to the specified file.
*
* @return IPRT status code.
*/
static int vbclInitLogger(char *szLogFileName)
{
int rc;
uint32_t fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
uint32_t fDestFlags = RTLOGDEST_STDOUT;
rc = RTLogCreateEx(&g_pLogger,
fFlags, /* Logger instance flags, a combination of the RTLOGFLAGS_* values */
"all", /* The initial group settings */
"VBOXCLIENT_RELEASE_LOG", /* Base name for the environment variables for this instance */
RT_ELEMENTS(s_apszGroups), /* Number of groups in the array */
s_apszGroups, /* Pointer to array of groups. This must stick around for the life of the logger instance */
fDestFlags, /* The destination flags */
NULL, /* Callback function for starting logging and for ending or starting a new file for log history rotation */
szLogFileName ? 10 : 0, /* Number of old log files to keep when performing log history rotation */
szLogFileName ? 100 * _1M : 0, /* Maximum size of log file when performing history rotation */
szLogFileName ? RT_SEC_1DAY : 0, /* Maximum time interval per log file when performing history rotation */
0, /* A buffer which is filled with an error message if something fails */
0, /* The size of the error message buffer */
szLogFileName /* Log filename format string */
);
AssertReturn(RT_SUCCESS(rc), rc);
/* Register this logger as the release logger */
RTLogRelSetDefaultInstance(g_pLogger);
/* Explicitly flush the log in case of VBOXCLIENT_RELEASE_LOG=buffered. */
RTLogFlush(g_pLogger);
return rc;
}
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;
}
