HRESULT SystemProperties::i_setLoggingLevel(const com::Utf8Str &aLoggingLevel)
{
Utf8Str useLoggingLevel(aLoggingLevel);
if (useLoggingLevel.isEmpty())
useLoggingLevel = VBOXSVC_LOG_DEFAULT;
int rc = RTLogGroupSettings(RTLogRelGetDefaultInstance(), useLoggingLevel.c_str());
// If failed and not the default logging level - try to use the default logging level.
if (RT_FAILURE(rc))
{
// If failed write message to the release log.
LogRel(("Cannot set passed logging level=%s Error=%Rrc \n", useLoggingLevel.c_str(), rc));
// If attempted logging level not the default one then try the default one.
if (!useLoggingLevel.equals(VBOXSVC_LOG_DEFAULT))
{
rc = RTLogGroupSettings(RTLogRelGetDefaultInstance(), VBOXSVC_LOG_DEFAULT);
// If failed report this to the release log.
if (RT_FAILURE(rc))
LogRel(("Cannot set default logging level Error=%Rrc \n", rc));
}
// On any failure - set default level as the one to be stored.
useLoggingLevel = VBOXSVC_LOG_DEFAULT;
}
// Set to passed value or if default used/attempted (even if error condition) use empty string.
m->strLoggingLevel = (useLoggingLevel.equals(VBOXSVC_LOG_DEFAULT) ? "" : useLoggingLevel);
return RT_SUCCESS(rc) ? S_OK : E_FAIL;
}
/**
* Changes the buffering setting of the default release logger.
*
* This can be used for optimizing longish logging sequences.
*
* @returns The old state.
* @param fBuffered The new state.
*/
RTDECL(bool) RTLogRelSetBuffering(bool fBuffered)
{
PRTLOGGER pLogger = RTLogRelGetDefaultInstance();
if (pLogger)
return RTLogSetBuffering(pLogger, fBuffered);
return false;
}
/** log and dbg_log_flags parameter getter. */
static int vboxguestLinuxParamLogFlagsGet(char *pszBuf, struct kernel_param *pParam)
{
PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
*pszBuf = '\0';
if (pLogger)
RTLogGetFlags(pLogger, pszBuf, _4K);
return strlen(pszBuf);
}
/** log and dbg_log parameter getter. */
static int vgdrvLinuxParamLogGrpGet(char *pszBuf, struct kernel_param *pParam)
{
PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
*pszBuf = '\0';
if (pLogger)
RTLogGetGroupSettings(pLogger, pszBuf, _4K);
return strlen(pszBuf);
}
/** log and dbg_log_flags parameter setter. */
static int vboxguestLinuxParamLogFlagsSet(const char *pszValue, struct kernel_param *pParam)
{
if (g_fLoggerCreated)
{
PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
if (pLogger)
RTLogFlags(pLogger, pszValue);
}
else if (pParam->name[0] != 'd')
strlcpy(&g_szLogFlags[0], pszValue, sizeof(g_szLogFlags));
return 0;
}
/**
* Write to a logger instance, defaulting to the release one.
*
* This function will check whether the instance, group and flags makes up a
* logging kind which is currently enabled before writing anything to the log.
*
* @param pLogger Pointer to logger instance. If NULL the default release instance is attempted.
* @param fFlags The logging flags.
* @param iGroup The group.
* The value ~0U is reserved for compatibility with RTLogLogger[V] and is
* only for internal usage!
* @param pszFormat Format string.
* @param args Format arguments.
*/
RTDECL(void) RTLogRelLoggerV(PRTLOGGER pLogger, unsigned fFlags, unsigned iGroup, const char *pszFormat, va_list args)
{
/*
* A NULL logger means default instance.
*/
if (!pLogger)
{
pLogger = RTLogRelGetDefaultInstance();
if (!pLogger)
return;
}
RTLogLoggerExV(pLogger, fFlags, iGroup, pszFormat, args);
}
/**
* atexit callback.
*
* This makes sure any loggers are flushed and will later also work the
* termination callback chain.
*/
static void rtR3ExitCallback(void)
{
ASMAtomicWriteBool(&g_frtAtExitCalled, true);
if (g_cUsers > 0)
{
PRTLOGGER pLogger = RTLogGetDefaultInstance();
if (pLogger)
RTLogFlush(pLogger);
pLogger = RTLogRelGetDefaultInstance();
if (pLogger)
RTLogFlush(pLogger);
}
}
/**
* Checkes for logger prefixes and selects the right logger.
*
* @returns Target logger.
* @param ppsz Pointer to the string pointer.
*/
static PRTLOGGER dbgfR3LogResolvedLogger(const char **ppsz)
{
PRTLOGGER pLogger;
const char *psz = *ppsz;
if (!strncmp(psz, RT_STR_TUPLE("release:")))
{
*ppsz += sizeof("release:") - 1;
pLogger = RTLogRelGetDefaultInstance();
}
else
{
if (!strncmp(psz, RT_STR_TUPLE("debug:")))
*ppsz += sizeof("debug:") - 1;
pLogger = RTLogDefaultInstance();
}
return pLogger;
}
HRESULT MachineDebugger::getLogRelDestinations(com::Utf8Str &aLogRelDestinations)
{
return i_logStringProps(RTLogRelGetDefaultInstance(), RTLogGetDestinations, "RTLogGetDestinations", &aLogRelDestinations);
}
HRESULT MachineDebugger::getLogRelGroups(com::Utf8Str &aLogRelGroups)
{
return i_logStringProps(RTLogRelGetDefaultInstance(), RTLogGetGroupSettings, "RTLogGetGroupSettings", &aLogRelGroups);
}
/**
* Worker for RTAssertMsg2V and RTAssertMsg2AddV
*
* @param fInitial True if it's RTAssertMsg2V, otherwise false.
* @param pszFormat The message format string.
* @param va The format arguments.
*/
static void rtAssertMsg2Worker(bool fInitial, const char *pszFormat, va_list va)
{
va_list vaCopy;
size_t cch;
/*
* The global first.
*/
if (fInitial)
{
va_copy(vaCopy, va);
cch = RTStrPrintfV(g_szRTAssertMsg2, sizeof(g_szRTAssertMsg2), pszFormat, vaCopy);
ASMAtomicWriteU32(&g_cchRTAssertMsg2, (uint32_t)cch);
va_end(vaCopy);
}
else
{
cch = ASMAtomicReadU32(&g_cchRTAssertMsg2);
if (cch < sizeof(g_szRTAssertMsg2) - 4)
{
va_copy(vaCopy, va);
cch += RTStrPrintfV(&g_szRTAssertMsg2[cch], sizeof(g_szRTAssertMsg2) - cch, pszFormat, vaCopy);
ASMAtomicWriteU32(&g_cchRTAssertMsg2, (uint32_t)cch);
va_end(vaCopy);
}
}
/*
* If not quiet, make some noise.
*/
if (!RTAssertAreQuiet())
{
RTERRVARS SavedErrVars;
RTErrVarsSave(&SavedErrVars);
#ifdef IN_RING0
# ifdef IN_GUEST_R0
va_copy(vaCopy, va);
RTLogBackdoorPrintfV(pszFormat, vaCopy);
va_end(vaCopy);
# endif
/** @todo fully integrate this with the logger... play safe a bit for now. */
rtR0AssertNativeMsg2V(fInitial, pszFormat, va);
#else /* !IN_RING0 */
# if !defined(IN_RING3) && !defined(LOG_NO_COM)
# if 0 /* Enable this iff you have a COM port and really want this debug info. */
va_copy(vaCopy, va);
RTLogComPrintfV(pszFormat, vaCopy);
va_end(vaCopy);
# endif
# endif
PRTLOGGER pLog = RTLogRelGetDefaultInstance();
if (pLog)
{
va_copy(vaCopy, va);
RTLogRelPrintfV(pszFormat, vaCopy);
va_end(vaCopy);
# ifndef IN_RC /* flushing is done automatically in RC */
RTLogFlush(pLog);
# endif
}
pLog = RTLogDefaultInstance();
if (pLog)
{
va_copy(vaCopy, va);
RTLogPrintfV(pszFormat, vaCopy);
va_end(vaCopy);
# ifndef IN_RC /* flushing is done automatically in RC */
RTLogFlush(pLog);
#endif
}
# ifdef IN_RING3
/* print to stderr, helps user and gdb debugging. */
char szMsg[sizeof(g_szRTAssertMsg2)];
va_copy(vaCopy, va);
RTStrPrintfV(szMsg, sizeof(szMsg), pszFormat, vaCopy);
va_end(vaCopy);
fprintf(stderr, "%s", szMsg);
fflush(stderr);
# endif
#endif /* !IN_RING0 */
RTErrVarsRestore(&SavedErrVars);
}
}
RTDECL(void) RTAssertMsg1(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction)
{
/*
* Fill in the globals.
*/
ASMAtomicUoWritePtr(&g_pszRTAssertExpr, pszExpr);
ASMAtomicUoWritePtr(&g_pszRTAssertFile, pszFile);
ASMAtomicUoWritePtr(&g_pszRTAssertFunction, pszFunction);
ASMAtomicUoWriteU32(&g_u32RTAssertLine, uLine);
RTStrPrintf(g_szRTAssertMsg1, sizeof(g_szRTAssertMsg1),
"\n!!Assertion Failed!!\n"
"Expression: %s\n"
"Location : %s(%d) %s\n",
pszExpr, pszFile, uLine, pszFunction);
/*
* If not quiet, make noise.
*/
if (!RTAssertAreQuiet())
{
RTERRVARS SavedErrVars;
RTErrVarsSave(&SavedErrVars);
#ifdef IN_RING0
# ifdef IN_GUEST_R0
RTLogBackdoorPrintf("\n!!Assertion Failed!!\n"
"Expression: %s\n"
"Location : %s(%d) %s\n",
pszExpr, pszFile, uLine, pszFunction);
# endif
/** @todo fully integrate this with the logger... play safe a bit for now. */
rtR0AssertNativeMsg1(pszExpr, uLine, pszFile, pszFunction);
#else /* !IN_RING0 */
# if !defined(IN_RING3) && !defined(LOG_NO_COM)
# if 0 /* Enable this iff you have a COM port and really want this debug info. */
RTLogComPrintf("\n!!Assertion Failed!!\n"
"Expression: %s\n"
"Location : %s(%d) %s\n",
pszExpr, pszFile, uLine, pszFunction);
# endif
# endif
PRTLOGGER pLog = RTLogRelGetDefaultInstance();
if (pLog)
{
RTLogRelPrintf("\n!!Assertion Failed!!\n"
"Expression: %s\n"
"Location : %s(%d) %s\n",
pszExpr, pszFile, uLine, pszFunction);
# ifndef IN_RC /* flushing is done automatically in RC */
RTLogFlush(pLog);
# endif
}
# ifndef LOG_ENABLED
if (!pLog)
# endif
{
pLog = RTLogDefaultInstance();
if (pLog)
{
RTLogPrintf("\n!!Assertion Failed!!\n"
"Expression: %s\n"
"Location : %s(%d) %s\n",
pszExpr, pszFile, uLine, pszFunction);
# ifndef IN_RC /* flushing is done automatically in RC */
RTLogFlush(pLog);
# endif
}
}
# ifdef IN_RING3
/* print to stderr, helps user and gdb debugging. */
fprintf(stderr,
"\n!!Assertion Failed!!\n"
"Expression: %s\n"
"Location : %s(%d) %s\n",
VALID_PTR(pszExpr) ? pszExpr : "<none>",
VALID_PTR(pszFile) ? pszFile : "<none>",
uLine,
VALID_PTR(pszFunction) ? pszFunction : "");
fflush(stderr);
# endif
#endif /* !IN_RING0 */
RTErrVarsRestore(&SavedErrVars);
}
}
/**
* The main loop for the VBoxClient daemon.
* @todo Clean up for readability.
*/
int main(int argc, char *argv[])
{
bool fDaemonise = true, fRespawn = true;
int rc;
const char *pcszFileName;
/* Initialise our runtime before all else. */
rc = RTR3InitExe(argc, &argv, 0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
/* This should never be called twice in one process - in fact one Display
* object should probably never be used from multiple threads anyway. */
if (!XInitThreads())
VBClFatalError(("Failed to initialize X11 threads\n"));
/* Get our file name for error output. */
pcszFileName = RTPathFilename(argv[0]);
if (!pcszFileName)
pcszFileName = "VBoxClient";
/* Parse our option(s) */
/** @todo Use RTGetOpt() if the arguments become more complex. */
for (int i = 1; i < argc; ++i)
{
rc = VERR_INVALID_PARAMETER;
if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--nodaemon"))
{
/* If the user is running in "no daemon" mode anyway, send critical
* logging to stdout as well. */
PRTLOGGER pReleaseLog = RTLogRelGetDefaultInstance();
if (pReleaseLog)
rc = RTLogDestinations(pReleaseLog, "stdout");
if (pReleaseLog && RT_FAILURE(rc))
RTPrintf("%s: failed to redivert error output, rc=%Rrc\n",
pcszFileName, rc);
fDaemonise = false;
}
else if (!strcmp(argv[i], "--no-respawn"))
{
fRespawn = false;
}
else if (!strcmp(argv[i], "--clipboard"))
{
if (g_pService)
break;
g_pService = VBClGetClipboardService();
}
else if (!strcmp(argv[i], "--display"))
{
if (g_pService)
break;
g_pService = VBClGetDisplayService();
}
else if (!strcmp(argv[i], "--seamless"))
{
if (g_pService)
break;
g_pService = VBClGetSeamlessService();
}
else if (!strcmp(argv[i], "--checkhostversion"))
{
if (g_pService)
break;
g_pService = VBClGetHostVersionService();
}
#ifdef VBOX_WITH_DRAG_AND_DROP
else if (!strcmp(argv[i], "--draganddrop"))
{
if (g_pService)
break;
g_pService = VBClGetDragAndDropService();
}
#endif /* VBOX_WITH_DRAG_AND_DROP */
else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help"))
{
vboxClientUsage(pcszFileName);
return 0;
}
else if (!strcmp(argv[i], "-V") || !strcmp(argv[i], "--version"))
{
RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
return 0;
}
else
{
RTPrintf("%s: unrecognized option `%s'\n", pcszFileName, argv[i]);
RTPrintf("Try `%s --help' for more information\n", pcszFileName);
return 1;
}
rc = VINF_SUCCESS;
}
if (RT_FAILURE(rc) || !g_pService)
{
vboxClientUsage(pcszFileName);
return 1;
}
rc = RTCritSectInit(&g_critSect);
if (RT_FAILURE(rc))
VBClFatalError(("Initialising critical section: %Rrc\n", rc));
rc = RTPathUserHome(g_szPidFile, sizeof(g_szPidFile));
if (RT_FAILURE(rc))
VBClFatalError(("Getting home directory for pid-file: %Rrc\n", rc));
rc = RTPathAppend(g_szPidFile, sizeof(g_szPidFile),
(*g_pService)->getPidFilePath());
if (RT_FAILURE(rc))
VBClFatalError(("Creating pid-file path: %Rrc\n", rc));
if (fDaemonise)
rc = VbglR3Daemonize(false /* fNoChDir */, false /* fNoClose */, fRespawn, &cRespawn);
if (RT_FAILURE(rc))
VBClFatalError(("Daemonizing: %Rrc\n", rc));
if (g_szPidFile[0])
rc = VbglR3PidFile(g_szPidFile, &g_hPidFile);
if (rc == VERR_FILE_LOCK_VIOLATION) /* Already running. */
return 0;
if (RT_FAILURE(rc))
VBClFatalError(("Creating pid-file: %Rrc\n", rc));
/* Set signal handlers to clean up on exit. */
vboxClientSetSignalHandlers();
#ifndef VBOXCLIENT_WITHOUT_X11
/* Set an X11 error handler, so that we don't die when we get unavoidable
* errors. */
XSetErrorHandler(vboxClientXLibErrorHandler);
/* Set an X11 I/O error handler, so that we can shutdown properly on
* fatal errors. */
XSetIOErrorHandler(vboxClientXLibIOErrorHandler);
#endif
rc = (*g_pService)->init(g_pService);
if (RT_FAILURE(rc))
VBClFatalError(("Initialising service: %Rrc\n", rc));
rc = (*g_pService)->run(g_pService, fDaemonise);
if (RT_FAILURE(rc))
VBClFatalError(("Service main loop failed: %Rrc\n", rc));
VBClCleanUp();
return 0;
}
