diff options
Diffstat (limited to 'src/VBox/Runtime/common/log/log.cpp')
| -rw-r--r-- | src/VBox/Runtime/common/log/log.cpp | 4337 |
1 files changed, 4337 insertions, 0 deletions
diff --git a/src/VBox/Runtime/common/log/log.cpp b/src/VBox/Runtime/common/log/log.cpp new file mode 100644 index 00000000..18a272e4 --- /dev/null +++ b/src/VBox/Runtime/common/log/log.cpp @@ -0,0 +1,4337 @@ +/* $Id: log.cpp $ */ +/** @file + * Runtime VBox - Logger. + */ + +/* + * Copyright (C) 2006-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included + * in the VirtualBox distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + * + * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0 + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/log.h> +#include "internal/iprt.h" + +#include <iprt/alloc.h> +#include <iprt/crc.h> +#include <iprt/process.h> +#include <iprt/semaphore.h> +#include <iprt/thread.h> +#include <iprt/mp.h> +#ifdef IN_RING3 +# include <iprt/env.h> +# include <iprt/file.h> +# include <iprt/lockvalidator.h> +# include <iprt/path.h> +#endif +#include <iprt/time.h> +#include <iprt/asm.h> +#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86) +# include <iprt/asm-amd64-x86.h> +#endif +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/param.h> + +#include <iprt/stdarg.h> +#include <iprt/string.h> +#include <iprt/ctype.h> +#ifdef IN_RING3 +# include <iprt/alloca.h> +# ifndef IPRT_NO_CRT +# include <stdio.h> +# endif +#endif + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** @def RTLOG_RINGBUF_DEFAULT_SIZE + * The default ring buffer size. */ +/** @def RTLOG_RINGBUF_MAX_SIZE + * The max ring buffer size. */ +/** @def RTLOG_RINGBUF_MIN_SIZE + * The min ring buffer size. */ +#ifdef IN_RING0 +# define RTLOG_RINGBUF_DEFAULT_SIZE _64K +# define RTLOG_RINGBUF_MAX_SIZE _4M +# define RTLOG_RINGBUF_MIN_SIZE _1K +#elif defined(IN_RING3) || defined(DOXYGEN_RUNNING) +# define RTLOG_RINGBUF_DEFAULT_SIZE _512K +# define RTLOG_RINGBUF_MAX_SIZE _1G +# define RTLOG_RINGBUF_MIN_SIZE _4K +#endif +/** The start of ring buffer eye catcher (16 bytes). */ +#define RTLOG_RINGBUF_EYE_CATCHER "START RING BUF\0" +AssertCompile(sizeof(RTLOG_RINGBUF_EYE_CATCHER) == 16); +/** The end of ring buffer eye catcher (16 bytes). This also ensures that the ring buffer + * forms are properly terminated C string (leading zero chars). */ +#define RTLOG_RINGBUF_EYE_CATCHER_END "\0\0\0END RING BUF" +AssertCompile(sizeof(RTLOG_RINGBUF_EYE_CATCHER_END) == 16); + +/** The default buffer size. */ +#ifdef IN_RING0 +# define RTLOG_BUFFER_DEFAULT_SIZE _16K +#else +# define RTLOG_BUFFER_DEFAULT_SIZE _128K +#endif +/** Buffer alignment used RTLogCreateExV. */ +#define RTLOG_BUFFER_ALIGN 64 + + +/** Resolved a_pLoggerInt to the default logger if NULL, returning @a a_rcRet if + * no default logger could be created. */ +#define RTLOG_RESOLVE_DEFAULT_RET(a_pLoggerInt, a_rcRet) do {\ + if (a_pLoggerInt) { /*maybe*/ } \ + else \ + { \ + a_pLoggerInt = (PRTLOGGERINTERNAL)rtLogDefaultInstanceCommon(); \ + if (a_pLoggerInt) { /*maybe*/ } \ + else \ + return (a_rcRet); \ + } \ + } while (0) + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * Internal logger data. + * + * @remarks Don't make casual changes to this structure. + */ +typedef struct RTLOGGERINTERNAL +{ + /** The public logger core. */ + RTLOGGER Core; + + /** The structure revision (RTLOGGERINTERNAL_REV). */ + uint32_t uRevision; + /** The size of the internal logger structure. */ + uint32_t cbSelf; + + /** Logger instance flags - RTLOGFLAGS. */ + uint64_t fFlags; + /** Destination flags - RTLOGDEST. */ + uint32_t fDestFlags; + + /** Number of buffer descriptors. */ + uint8_t cBufDescs; + /** Index of the current buffer descriptor. */ + uint8_t idxBufDesc; + /** Pointer to buffer the descriptors. */ + PRTLOGBUFFERDESC paBufDescs; + /** Pointer to the current buffer the descriptor. */ + PRTLOGBUFFERDESC pBufDesc; + + /** Spinning mutex semaphore. Can be NIL. */ + RTSEMSPINMUTEX hSpinMtx; + /** Pointer to the flush function. */ + PFNRTLOGFLUSH pfnFlush; + + /** Custom prefix callback. */ + PFNRTLOGPREFIX pfnPrefix; + /** Prefix callback argument. */ + void *pvPrefixUserArg; + /** This is set if a prefix is pending. */ + bool fPendingPrefix; + /** Alignment padding. */ + bool afPadding1[2]; + /** Set if fully created. Used to avoid confusing in a few functions used to + * parse logger settings from environment variables. */ + bool fCreated; + + /** The max number of groups that there is room for in afGroups and papszGroups. + * Used by RTLogCopyGroupAndFlags(). */ + uint32_t cMaxGroups; + /** Pointer to the group name array. + * (The data is readonly and provided by the user.) */ + const char * const *papszGroups; + + /** The number of log entries per group. NULL if + * RTLOGFLAGS_RESTRICT_GROUPS is not specified. */ + uint32_t *pacEntriesPerGroup; + /** The max number of entries per group. */ + uint32_t cMaxEntriesPerGroup; + + /** @name Ring buffer logging + * The ring buffer records the last cbRingBuf - 1 of log output. The + * other configured log destinations are not touched until someone calls + * RTLogFlush(), when the ring buffer content is written to them all. + * + * The aim here is a fast logging destination, that avoids wasting storage + * space saving disk space when dealing with huge log volumes where the + * interesting bits usually are found near the end of the log. This is + * typically the case for scenarios that crashes or hits assertions. + * + * RTLogFlush() is called implicitly when hitting an assertion. While on a + * crash the most debuggers are able to make calls these days, it's usually + * possible to view the ring buffer memory. + * + * @{ */ + /** Ring buffer size (including both eye catchers). */ + uint32_t cbRingBuf; + /** Number of bytes passing thru the ring buffer since last RTLogFlush call. + * (This is used to avoid writing out the same bytes twice.) */ + uint64_t volatile cbRingBufUnflushed; + /** Ring buffer pointer (points at RTLOG_RINGBUF_EYE_CATCHER). */ + char *pszRingBuf; + /** Current ring buffer position (where to write the next char). */ + char * volatile pchRingBufCur; + /** @} */ + + /** Program time base for ring-0 (copy of g_u64ProgramStartNanoTS). */ + uint64_t nsR0ProgramStart; + /** Thread name for use in ring-0 with RTLOGFLAGS_PREFIX_THREAD. */ + char szR0ThreadName[16]; + +#ifdef IN_RING3 + /** @name File logging bits for the logger. + * @{ */ + /** Pointer to the function called when starting logging, and when + * ending or starting a new log file as part of history rotation. + * This can be NULL. */ + PFNRTLOGPHASE pfnPhase; + /** Pointer to the output interface used. */ + PCRTLOGOUTPUTIF pOutputIf; + /** Opaque user data passed to the callbacks in the output interface. */ + void *pvOutputIfUser; + + /** Handle to log file (if open) - only used by the default output interface to avoid additional layers of indirection. */ + RTFILE hFile; + /** Log file history settings: maximum amount of data to put in a file. */ + uint64_t cbHistoryFileMax; + /** Log file history settings: current amount of data in a file. */ + uint64_t cbHistoryFileWritten; + /** Log file history settings: maximum time to use a file (in seconds). */ + uint32_t cSecsHistoryTimeSlot; + /** Log file history settings: in what time slot was the file created. */ + uint32_t uHistoryTimeSlotStart; + /** Log file history settings: number of older files to keep. + * 0 means no history. */ + uint32_t cHistory; + /** Pointer to filename. */ + char szFilename[RTPATH_MAX]; + /** Flag whether the log file was opened successfully. */ + bool fLogOpened; + /** @} */ +#endif /* IN_RING3 */ + + /** Number of groups in the afGroups and papszGroups members. */ + uint32_t cGroups; + /** Group flags array - RTLOGGRPFLAGS. + * This member have variable length and may extend way beyond + * the declared size of 1 entry. */ + RT_FLEXIBLE_ARRAY_EXTENSION + uint32_t afGroups[RT_FLEXIBLE_ARRAY]; +} RTLOGGERINTERNAL; + +/** The revision of the internal logger structure. */ +# define RTLOGGERINTERNAL_REV UINT32_C(13) + +AssertCompileMemberAlignment(RTLOGGERINTERNAL, cbRingBufUnflushed, sizeof(uint64_t)); +#ifdef IN_RING3 +AssertCompileMemberAlignment(RTLOGGERINTERNAL, hFile, sizeof(void *)); +AssertCompileMemberAlignment(RTLOGGERINTERNAL, cbHistoryFileMax, sizeof(uint64_t)); +#endif + + +/** Pointer to internal logger bits. */ +typedef struct RTLOGGERINTERNAL *PRTLOGGERINTERNAL; +/** + * Arguments passed to the output function. + */ +typedef struct RTLOGOUTPUTPREFIXEDARGS +{ + /** The logger instance. */ + PRTLOGGERINTERNAL pLoggerInt; + /** The flags. (used for prefixing.) */ + unsigned fFlags; + /** The group. (used for prefixing.) */ + unsigned iGroup; + /** Used by RTLogBulkNestedWrite. */ + const char *pszInfix; +} RTLOGOUTPUTPREFIXEDARGS, *PRTLOGOUTPUTPREFIXEDARGS; + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static unsigned rtlogGroupFlags(const char *psz); +#ifdef IN_RING3 +static int rtR3LogOpenFileDestination(PRTLOGGERINTERNAL pLoggerInt, PRTERRINFO pErrInfo); +#endif +static void rtLogRingBufFlush(PRTLOGGERINTERNAL pLoggerInt); +static void rtlogFlush(PRTLOGGERINTERNAL pLoggerInt, bool fNeedSpace); +#ifdef IN_RING3 +static FNRTLOGPHASEMSG rtlogPhaseMsgLocked; +static FNRTLOGPHASEMSG rtlogPhaseMsgNormal; +#endif +static DECLCALLBACK(size_t) rtLogOutputPrefixed(void *pv, const char *pachChars, size_t cbChars); +static void rtlogLoggerExFLocked(PRTLOGGERINTERNAL pLoggerInt, unsigned fFlags, unsigned iGroup, const char *pszFormat, ...); + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Default logger instance. */ +static PRTLOGGER g_pLogger; +/** Default release logger instance. */ +static PRTLOGGER g_pRelLogger; +#ifdef IN_RING3 +/** The RTThreadGetWriteLockCount() change caused by the logger mutex semaphore. */ +static uint32_t volatile g_cLoggerLockCount; +#endif + +#ifdef IN_RING0 +/** Number of per-thread loggers. */ +static int32_t volatile g_cPerThreadLoggers; +/** Per-thread loggers. + * This is just a quick TLS hack suitable for debug logging only. + * If we run out of entries, just unload and reload the driver. */ +static struct RTLOGGERPERTHREAD +{ + /** The thread. */ + RTNATIVETHREAD volatile NativeThread; + /** The (process / session) key. */ + uintptr_t volatile uKey; + /** The logger instance.*/ + PRTLOGGER volatile pLogger; +} g_aPerThreadLoggers[8] = +{ + { NIL_RTNATIVETHREAD, 0, 0}, + { NIL_RTNATIVETHREAD, 0, 0}, + { NIL_RTNATIVETHREAD, 0, 0}, + { NIL_RTNATIVETHREAD, 0, 0}, + { NIL_RTNATIVETHREAD, 0, 0}, + { NIL_RTNATIVETHREAD, 0, 0}, + { NIL_RTNATIVETHREAD, 0, 0}, + { NIL_RTNATIVETHREAD, 0, 0} +}; +#endif /* IN_RING0 */ + +/** + * Logger flags instructions. + */ +static struct +{ + const char *pszInstr; /**< The name */ + size_t cchInstr; /**< The size of the name. */ + uint64_t fFlag; /**< The flag value. */ + bool fInverted; /**< Inverse meaning? */ + uint32_t fFixedDest; /**< RTLOGDEST_FIXED_XXX flags blocking this. */ +} const g_aLogFlags[] = +{ + { "disabled", sizeof("disabled" ) - 1, RTLOGFLAGS_DISABLED, false, 0 }, + { "enabled", sizeof("enabled" ) - 1, RTLOGFLAGS_DISABLED, true, 0 }, + { "buffered", sizeof("buffered" ) - 1, RTLOGFLAGS_BUFFERED, false, 0 }, + { "unbuffered", sizeof("unbuffered" ) - 1, RTLOGFLAGS_BUFFERED, true, 0 }, + { "usecrlf", sizeof("usecrlf" ) - 1, RTLOGFLAGS_USECRLF, false, 0 }, + { "uself", sizeof("uself" ) - 1, RTLOGFLAGS_USECRLF, true, 0 }, + { "append", sizeof("append" ) - 1, RTLOGFLAGS_APPEND, false, RTLOGDEST_FIXED_FILE }, + { "overwrite", sizeof("overwrite" ) - 1, RTLOGFLAGS_APPEND, true, RTLOGDEST_FIXED_FILE }, + { "rel", sizeof("rel" ) - 1, RTLOGFLAGS_REL_TS, false, 0 }, + { "abs", sizeof("abs" ) - 1, RTLOGFLAGS_REL_TS, true, 0 }, + { "dec", sizeof("dec" ) - 1, RTLOGFLAGS_DECIMAL_TS, false, 0 }, + { "hex", sizeof("hex" ) - 1, RTLOGFLAGS_DECIMAL_TS, true, 0 }, + { "writethru", sizeof("writethru" ) - 1, RTLOGFLAGS_WRITE_THROUGH, false, 0 }, + { "writethrough", sizeof("writethrough") - 1, RTLOGFLAGS_WRITE_THROUGH, false, 0 }, + { "flush", sizeof("flush" ) - 1, RTLOGFLAGS_FLUSH, false, 0 }, + { "lockcnts", sizeof("lockcnts" ) - 1, RTLOGFLAGS_PREFIX_LOCK_COUNTS, false, 0 }, + { "cpuid", sizeof("cpuid" ) - 1, RTLOGFLAGS_PREFIX_CPUID, false, 0 }, + { "pid", sizeof("pid" ) - 1, RTLOGFLAGS_PREFIX_PID, false, 0 }, + { "flagno", sizeof("flagno" ) - 1, RTLOGFLAGS_PREFIX_FLAG_NO, false, 0 }, + { "flag", sizeof("flag" ) - 1, RTLOGFLAGS_PREFIX_FLAG, false, 0 }, + { "groupno", sizeof("groupno" ) - 1, RTLOGFLAGS_PREFIX_GROUP_NO, false, 0 }, + { "group", sizeof("group" ) - 1, RTLOGFLAGS_PREFIX_GROUP, false, 0 }, + { "tid", sizeof("tid" ) - 1, RTLOGFLAGS_PREFIX_TID, false, 0 }, + { "thread", sizeof("thread" ) - 1, RTLOGFLAGS_PREFIX_THREAD, false, 0 }, + { "custom", sizeof("custom" ) - 1, RTLOGFLAGS_PREFIX_CUSTOM, false, 0 }, + { "timeprog", sizeof("timeprog" ) - 1, RTLOGFLAGS_PREFIX_TIME_PROG, false, 0 }, + { "time", sizeof("time" ) - 1, RTLOGFLAGS_PREFIX_TIME, false, 0 }, + { "msprog", sizeof("msprog" ) - 1, RTLOGFLAGS_PREFIX_MS_PROG, false, 0 }, + { "tsc", sizeof("tsc" ) - 1, RTLOGFLAGS_PREFIX_TSC, false, 0 }, /* before ts! */ + { "ts", sizeof("ts" ) - 1, RTLOGFLAGS_PREFIX_TS, false, 0 }, + /* We intentionally omit RTLOGFLAGS_RESTRICT_GROUPS. */ +}; + +/** + * Logger destination instructions. + */ +static struct +{ + const char *pszInstr; /**< The name. */ + size_t cchInstr; /**< The size of the name. */ + uint32_t fFlag; /**< The corresponding destination flag. */ +} const g_aLogDst[] = +{ + { RT_STR_TUPLE("file"), RTLOGDEST_FILE }, /* Must be 1st! */ + { RT_STR_TUPLE("dir"), RTLOGDEST_FILE }, /* Must be 2nd! */ + { RT_STR_TUPLE("history"), 0 }, /* Must be 3rd! */ + { RT_STR_TUPLE("histsize"), 0 }, /* Must be 4th! */ + { RT_STR_TUPLE("histtime"), 0 }, /* Must be 5th! */ + { RT_STR_TUPLE("ringbuf"), RTLOGDEST_RINGBUF }, /* Must be 6th! */ + { RT_STR_TUPLE("stdout"), RTLOGDEST_STDOUT }, + { RT_STR_TUPLE("stderr"), RTLOGDEST_STDERR }, + { RT_STR_TUPLE("debugger"), RTLOGDEST_DEBUGGER }, + { RT_STR_TUPLE("com"), RTLOGDEST_COM }, + { RT_STR_TUPLE("nodeny"), RTLOGDEST_F_NO_DENY }, + { RT_STR_TUPLE("vmmrel"), RTLOGDEST_VMM_REL }, /* before vmm */ + { RT_STR_TUPLE("vmm"), RTLOGDEST_VMM }, + { RT_STR_TUPLE("user"), RTLOGDEST_USER }, + /* The RTLOGDEST_FIXED_XXX flags are omitted on purpose. */ +}; + +#ifdef IN_RING3 +/** Log rotation backoff table - millisecond sleep intervals. + * Important on Windows host, especially for VBoxSVC release logging. Only a + * medium term solution, until a proper fix for log file handling is available. + * 10 seconds total. + */ +static const uint32_t g_acMsLogBackoff[] = +{ 10, 10, 10, 20, 50, 100, 200, 200, 200, 200, 500, 500, 500, 500, 1000, 1000, 1000, 1000, 1000, 1000, 1000 }; +#endif + + +/** + * Locks the logger instance. + * + * @returns See RTSemSpinMutexRequest(). + * @param pLoggerInt The logger instance. + */ +DECLINLINE(int) rtlogLock(PRTLOGGERINTERNAL pLoggerInt) +{ + AssertMsgReturn(pLoggerInt->Core.u32Magic == RTLOGGER_MAGIC, ("%#x != %#x\n", pLoggerInt->Core.u32Magic, RTLOGGER_MAGIC), + VERR_INVALID_MAGIC); + AssertMsgReturn(pLoggerInt->uRevision == RTLOGGERINTERNAL_REV, ("%#x != %#x\n", pLoggerInt->uRevision, RTLOGGERINTERNAL_REV), + VERR_LOG_REVISION_MISMATCH); + AssertMsgReturn(pLoggerInt->cbSelf == sizeof(*pLoggerInt), ("%#x != %#x\n", pLoggerInt->cbSelf, sizeof(*pLoggerInt)), + VERR_LOG_REVISION_MISMATCH); + if (pLoggerInt->hSpinMtx != NIL_RTSEMSPINMUTEX) + { + int rc = RTSemSpinMutexRequest(pLoggerInt->hSpinMtx); + if (RT_FAILURE(rc)) + return rc; + } + return VINF_SUCCESS; +} + + +/** + * Unlocks the logger instance. + * @param pLoggerInt The logger instance. + */ +DECLINLINE(void) rtlogUnlock(PRTLOGGERINTERNAL pLoggerInt) +{ + if (pLoggerInt->hSpinMtx != NIL_RTSEMSPINMUTEX) + RTSemSpinMutexRelease(pLoggerInt->hSpinMtx); + return; +} + + +/********************************************************************************************************************************* +* Logger Instance Management. * +*********************************************************************************************************************************/ + +/** + * Common worker for RTLogDefaultInstance and RTLogDefaultInstanceEx. + */ +DECL_NO_INLINE(static, PRTLOGGER) rtLogDefaultInstanceCreateNew(void) +{ + PRTLOGGER pRet = NULL; + + /* + * It's soo easy to end up in a infinite recursion here when enabling 'all' + * the logging groups. So, only allow one thread to instantiate the default + * logger, muting other attempts at logging while it's being created. + */ + static volatile bool s_fCreating = false; + if (ASMAtomicCmpXchgBool(&s_fCreating, true, false)) + { + pRet = RTLogDefaultInit(); + if (pRet) + { + bool fRc = ASMAtomicCmpXchgPtr(&g_pLogger, pRet, NULL); + if (!fRc) + { + RTLogDestroy(pRet); + pRet = g_pLogger; + } + } + ASMAtomicWriteBool(&s_fCreating, true); + } + return pRet; +} + + +/** + * Common worker for RTLogDefaultInstance and RTLogDefaultInstanceEx. + */ +DECL_FORCE_INLINE(PRTLOGGER) rtLogDefaultInstanceCommon(void) +{ + PRTLOGGER pRet; + +#ifdef IN_RING0 + /* + * Check per thread loggers first. + */ + if (g_cPerThreadLoggers) + { + const RTNATIVETHREAD Self = RTThreadNativeSelf(); + int32_t i = RT_ELEMENTS(g_aPerThreadLoggers); + while (i-- > 0) + if (g_aPerThreadLoggers[i].NativeThread == Self) + return g_aPerThreadLoggers[i].pLogger; + } +#endif /* IN_RING0 */ + + /* + * If no per thread logger, use the default one. + */ + pRet = g_pLogger; + if (RT_LIKELY(pRet)) + { /* likely */ } + else + pRet = rtLogDefaultInstanceCreateNew(); + return pRet; +} + + +RTDECL(PRTLOGGER) RTLogDefaultInstance(void) +{ + return rtLogDefaultInstanceCommon(); +} +RT_EXPORT_SYMBOL(RTLogDefaultInstance); + + +/** + * Worker for RTLogDefaultInstanceEx, RTLogGetDefaultInstanceEx, + * RTLogRelGetDefaultInstanceEx and RTLogCheckGroupFlags. + */ +DECL_FORCE_INLINE(PRTLOGGERINTERNAL) rtLogCheckGroupFlagsWorker(PRTLOGGERINTERNAL pLoggerInt, uint32_t fFlagsAndGroup) +{ + if (pLoggerInt->fFlags & RTLOGFLAGS_DISABLED) + pLoggerInt = NULL; + else + { + uint32_t const fFlags = RT_LO_U16(fFlagsAndGroup); + uint16_t const iGroup = RT_HI_U16(fFlagsAndGroup); + if ( iGroup != UINT16_MAX + && ( (pLoggerInt->afGroups[iGroup < pLoggerInt->cGroups ? iGroup : 0] & (fFlags | RTLOGGRPFLAGS_ENABLED)) + != (fFlags | RTLOGGRPFLAGS_ENABLED))) + pLoggerInt = NULL; + } + return pLoggerInt; +} + + +RTDECL(PRTLOGGER) RTLogDefaultInstanceEx(uint32_t fFlagsAndGroup) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)rtLogDefaultInstanceCommon(); + if (pLoggerInt) + pLoggerInt = rtLogCheckGroupFlagsWorker(pLoggerInt, fFlagsAndGroup); + AssertCompileMemberOffset(RTLOGGERINTERNAL, Core, 0); + return (PRTLOGGER)pLoggerInt; +} +RT_EXPORT_SYMBOL(RTLogDefaultInstanceEx); + + +/** + * Common worker for RTLogGetDefaultInstance and RTLogGetDefaultInstanceEx. + */ +DECL_FORCE_INLINE(PRTLOGGER) rtLogGetDefaultInstanceCommon(void) +{ +#ifdef IN_RING0 + /* + * Check per thread loggers first. + */ + if (g_cPerThreadLoggers) + { + const RTNATIVETHREAD Self = RTThreadNativeSelf(); + int32_t i = RT_ELEMENTS(g_aPerThreadLoggers); + while (i-- > 0) + if (g_aPerThreadLoggers[i].NativeThread == Self) + return g_aPerThreadLoggers[i].pLogger; + } +#endif /* IN_RING0 */ + + return g_pLogger; +} + + +RTDECL(PRTLOGGER) RTLogGetDefaultInstance(void) +{ + return rtLogGetDefaultInstanceCommon(); +} +RT_EXPORT_SYMBOL(RTLogGetDefaultInstance); + + +RTDECL(PRTLOGGER) RTLogGetDefaultInstanceEx(uint32_t fFlagsAndGroup) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)rtLogGetDefaultInstanceCommon(); + if (pLoggerInt) + pLoggerInt = rtLogCheckGroupFlagsWorker(pLoggerInt, fFlagsAndGroup); + AssertCompileMemberOffset(RTLOGGERINTERNAL, Core, 0); + return (PRTLOGGER)pLoggerInt; +} +RT_EXPORT_SYMBOL(RTLogGetDefaultInstanceEx); + + +RTDECL(PRTLOGGER) RTLogSetDefaultInstance(PRTLOGGER pLogger) +{ +#if defined(IN_RING3) && (defined(IN_RT_STATIC) || defined(IPRT_NO_CRT)) + /* Set the pointers for emulating "weak symbols" the first time we're + called with something useful: */ + if (pLogger != NULL && g_pfnRTLogGetDefaultInstanceEx == NULL) + { + g_pfnRTLogGetDefaultInstance = RTLogGetDefaultInstance; + g_pfnRTLogGetDefaultInstanceEx = RTLogGetDefaultInstanceEx; + } +#endif + return ASMAtomicXchgPtrT(&g_pLogger, pLogger, PRTLOGGER); +} +RT_EXPORT_SYMBOL(RTLogSetDefaultInstance); + + +#ifdef IN_RING0 +/** + * Changes the default logger instance for the current thread. + * + * @returns IPRT status code. + * @param pLogger The logger instance. Pass NULL for deregistration. + * @param uKey Associated key for cleanup purposes. If pLogger is NULL, + * all instances with this key will be deregistered. So in + * order to only deregister the instance associated with the + * current thread use 0. + */ +RTR0DECL(int) RTLogSetDefaultInstanceThread(PRTLOGGER pLogger, uintptr_t uKey) +{ + int rc; + RTNATIVETHREAD Self = RTThreadNativeSelf(); + if (pLogger) + { + int32_t i; + unsigned j; + + AssertReturn(pLogger->u32Magic == RTLOGGER_MAGIC, VERR_INVALID_MAGIC); + + /* + * Iterate the table to see if there is already an entry for this thread. + */ + i = RT_ELEMENTS(g_aPerThreadLoggers); + while (i-- > 0) + if (g_aPerThreadLoggers[i].NativeThread == Self) + { + ASMAtomicWritePtr((void * volatile *)&g_aPerThreadLoggers[i].uKey, (void *)uKey); + g_aPerThreadLoggers[i].pLogger = pLogger; + return VINF_SUCCESS; + } + + /* + * Allocate a new table entry. + */ + i = ASMAtomicIncS32(&g_cPerThreadLoggers); + if (i > (int32_t)RT_ELEMENTS(g_aPerThreadLoggers)) + { + ASMAtomicDecS32(&g_cPerThreadLoggers); + return VERR_BUFFER_OVERFLOW; /* horrible error code! */ + } + + for (j = 0; j < 10; j++) + { + i = RT_ELEMENTS(g_aPerThreadLoggers); + while (i-- > 0) + { + AssertCompile(sizeof(RTNATIVETHREAD) == sizeof(void*)); + if ( g_aPerThreadLoggers[i].NativeThread == NIL_RTNATIVETHREAD + && ASMAtomicCmpXchgPtr((void * volatile *)&g_aPerThreadLoggers[i].NativeThread, (void *)Self, (void *)NIL_RTNATIVETHREAD)) + { + ASMAtomicWritePtr((void * volatile *)&g_aPerThreadLoggers[i].uKey, (void *)uKey); + ASMAtomicWritePtr(&g_aPerThreadLoggers[i].pLogger, pLogger); + return VINF_SUCCESS; + } + } + } + + ASMAtomicDecS32(&g_cPerThreadLoggers); + rc = VERR_INTERNAL_ERROR; + } + else + { + /* + * Search the array for the current thread. + */ + int32_t i = RT_ELEMENTS(g_aPerThreadLoggers); + while (i-- > 0) + if ( g_aPerThreadLoggers[i].NativeThread == Self + || g_aPerThreadLoggers[i].uKey == uKey) + { + ASMAtomicWriteNullPtr((void * volatile *)&g_aPerThreadLoggers[i].uKey); + ASMAtomicWriteNullPtr(&g_aPerThreadLoggers[i].pLogger); + ASMAtomicWriteHandle(&g_aPerThreadLoggers[i].NativeThread, NIL_RTNATIVETHREAD); + ASMAtomicDecS32(&g_cPerThreadLoggers); + } + + rc = VINF_SUCCESS; + } + return rc; +} +RT_EXPORT_SYMBOL(RTLogSetDefaultInstanceThread); +#endif /* IN_RING0 */ + + +RTDECL(PRTLOGGER) RTLogRelGetDefaultInstance(void) +{ + return g_pRelLogger; +} +RT_EXPORT_SYMBOL(RTLogRelGetDefaultInstance); + + +RTDECL(PRTLOGGER) RTLogRelGetDefaultInstanceEx(uint32_t fFlagsAndGroup) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)g_pRelLogger; + if (pLoggerInt) + pLoggerInt = rtLogCheckGroupFlagsWorker(pLoggerInt, fFlagsAndGroup); + return (PRTLOGGER)pLoggerInt; +} +RT_EXPORT_SYMBOL(RTLogRelGetDefaultInstanceEx); + + +RTDECL(PRTLOGGER) RTLogRelSetDefaultInstance(PRTLOGGER pLogger) +{ +#if defined(IN_RING3) && (defined(IN_RT_STATIC) || defined(IPRT_NO_CRT)) + /* Set the pointers for emulating "weak symbols" the first time we're + called with something useful: */ + if (pLogger != NULL && g_pfnRTLogRelGetDefaultInstanceEx == NULL) + { + g_pfnRTLogRelGetDefaultInstance = RTLogRelGetDefaultInstance; + g_pfnRTLogRelGetDefaultInstanceEx = RTLogRelGetDefaultInstanceEx; + } +#endif + return ASMAtomicXchgPtrT(&g_pRelLogger, pLogger, PRTLOGGER); +} +RT_EXPORT_SYMBOL(RTLogRelSetDefaultInstance); + + +RTDECL(PRTLOGGER) RTLogCheckGroupFlags(PRTLOGGER pLogger, uint32_t fFlagsAndGroup) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + if (pLoggerInt) + pLoggerInt = rtLogCheckGroupFlagsWorker(pLoggerInt, fFlagsAndGroup); + return (PRTLOGGER)pLoggerInt; +} +RT_EXPORT_SYMBOL(RTLogCheckGroupFlags); + + +/********************************************************************************************************************************* +* Default file I/O interface * +*********************************************************************************************************************************/ + +#ifdef IN_RING3 +static DECLCALLBACK(int) rtLogOutputIfDefOpen(PCRTLOGOUTPUTIF pIf, void *pvUser, const char *pszFilename, uint32_t fFlags) +{ + RT_NOREF(pIf); + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pvUser; + + return RTFileOpen(&pLoggerInt->hFile, pszFilename, fFlags); +} + + +static DECLCALLBACK(int) rtLogOutputIfDefClose(PCRTLOGOUTPUTIF pIf, void *pvUser) +{ + RT_NOREF(pIf); + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pvUser; + + int rc = VINF_SUCCESS; + if (pLoggerInt->hFile != NIL_RTFILE) + rc = RTFileClose(pLoggerInt->hFile); + + pLoggerInt->hFile = NIL_RTFILE; + return rc; +} + + +static DECLCALLBACK(int) rtLogOutputIfDefDelete(PCRTLOGOUTPUTIF pIf, void *pvUser, const char *pszFilename) +{ + RT_NOREF(pIf, pvUser); + return RTFileDelete(pszFilename); +} + + +static DECLCALLBACK(int) rtLogOutputIfDefRename(PCRTLOGOUTPUTIF pIf, void *pvUser, const char *pszFilenameOld, + const char *pszFilenameNew, uint32_t fFlags) +{ + RT_NOREF(pIf, pvUser); + return RTFileRename(pszFilenameOld, pszFilenameNew, fFlags); +} + + +static DECLCALLBACK(int) rtLogOutputIfDefQuerySize(PCRTLOGOUTPUTIF pIf, void *pvUser, uint64_t *pcbSize) +{ + RT_NOREF(pIf); + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pvUser; + + if (pLoggerInt->hFile != NIL_RTFILE) + return RTFileQuerySize(pLoggerInt->hFile, pcbSize); + + *pcbSize = 0; + return VINF_SUCCESS; +} + + +static DECLCALLBACK(int) rtLogOutputIfDefWrite(PCRTLOGOUTPUTIF pIf, void *pvUser, const void *pvBuf, + size_t cbWrite, size_t *pcbWritten) +{ + RT_NOREF(pIf); + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pvUser; + + if (pLoggerInt->hFile != NIL_RTFILE) + return RTFileWrite(pLoggerInt->hFile, pvBuf, cbWrite, pcbWritten); + + return VINF_SUCCESS; +} + + +static DECLCALLBACK(int) rtLogOutputIfDefFlush(PCRTLOGOUTPUTIF pIf, void *pvUser) +{ + RT_NOREF(pIf); + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pvUser; + + if (pLoggerInt->hFile != NIL_RTFILE) + return RTFileFlush(pLoggerInt->hFile); + + return VINF_SUCCESS; +} + + +/** + * The default file output interface. + */ +static const RTLOGOUTPUTIF g_LogOutputIfDef = +{ + rtLogOutputIfDefOpen, + rtLogOutputIfDefClose, + rtLogOutputIfDefDelete, + rtLogOutputIfDefRename, + rtLogOutputIfDefQuerySize, + rtLogOutputIfDefWrite, + rtLogOutputIfDefFlush +}; +#endif + + +/********************************************************************************************************************************* +* Ring Buffer * +*********************************************************************************************************************************/ + +/** + * Adjusts the ring buffer. + * + * @returns IPRT status code. + * @param pLoggerInt The logger instance. + * @param cbNewSize The new ring buffer size (0 == default). + * @param fForce Whether to do this even if the logger instance hasn't + * really been fully created yet (i.e. during RTLogCreate). + */ +static int rtLogRingBufAdjust(PRTLOGGERINTERNAL pLoggerInt, uint32_t cbNewSize, bool fForce) +{ + /* + * If this is early logger init, don't do anything. + */ + if (!pLoggerInt->fCreated && !fForce) + return VINF_SUCCESS; + + /* + * Lock the logger and make the necessary changes. + */ + int rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + if (cbNewSize == 0) + cbNewSize = RTLOG_RINGBUF_DEFAULT_SIZE; + if ( pLoggerInt->cbRingBuf != cbNewSize + || !pLoggerInt->pchRingBufCur) + { + uintptr_t offOld = pLoggerInt->pchRingBufCur - pLoggerInt->pszRingBuf; + if (offOld < sizeof(RTLOG_RINGBUF_EYE_CATCHER)) + offOld = sizeof(RTLOG_RINGBUF_EYE_CATCHER); + else if (offOld >= cbNewSize) + { + memmove(pLoggerInt->pszRingBuf, &pLoggerInt->pszRingBuf[offOld - cbNewSize], cbNewSize); + offOld = sizeof(RTLOG_RINGBUF_EYE_CATCHER); + } + + void *pvNew = RTMemRealloc(pLoggerInt->pchRingBufCur, cbNewSize); + if (pvNew) + { + pLoggerInt->pszRingBuf = (char *)pvNew; + pLoggerInt->pchRingBufCur = (char *)pvNew + offOld; + pLoggerInt->cbRingBuf = cbNewSize; + memcpy(pvNew, RTLOG_RINGBUF_EYE_CATCHER, sizeof(RTLOG_RINGBUF_EYE_CATCHER)); + memcpy((char *)pvNew + cbNewSize - sizeof(RTLOG_RINGBUF_EYE_CATCHER_END), + RTLOG_RINGBUF_EYE_CATCHER_END, sizeof(RTLOG_RINGBUF_EYE_CATCHER_END)); + rc = VINF_SUCCESS; + } + else + rc = VERR_NO_MEMORY; + } + rtlogUnlock(pLoggerInt); + } + + return rc; +} + + +/** + * Writes text to the ring buffer. + * + * @param pInt The internal logger data structure. + * @param pachText The text to write. + * @param cchText The number of chars (bytes) to write. + */ +static void rtLogRingBufWrite(PRTLOGGERINTERNAL pInt, const char *pachText, size_t cchText) +{ + /* + * Get the ring buffer data, adjusting it to only describe the writable + * part of the buffer. + */ + char * const pchStart = &pInt->pszRingBuf[sizeof(RTLOG_RINGBUF_EYE_CATCHER)]; + size_t const cchBuf = pInt->cbRingBuf - sizeof(RTLOG_RINGBUF_EYE_CATCHER) - sizeof(RTLOG_RINGBUF_EYE_CATCHER_END); + char *pchCur = pInt->pchRingBufCur; + size_t cchLeft = pchCur - pchStart; + if (RT_LIKELY(cchLeft < cchBuf)) + cchLeft = cchBuf - cchLeft; + else + { + /* May happen in ring-0 where a thread or two went ahead without getting the lock. */ + pchCur = pchStart; + cchLeft = cchBuf; + } + Assert(cchBuf < pInt->cbRingBuf); + + if (cchText < cchLeft) + { + /* + * The text fits in the remaining space. + */ + memcpy(pchCur, pachText, cchText); + pchCur[cchText] = '\0'; + pInt->pchRingBufCur = &pchCur[cchText]; + pInt->cbRingBufUnflushed += cchText; + } + else + { + /* + * The text wraps around. Taking the simple but inefficient approach + * to input texts that are longer than the ring buffer since that + * is unlikely to the be a frequent case. + */ + /* Fill to the end of the buffer. */ + memcpy(pchCur, pachText, cchLeft); + pachText += cchLeft; + cchText -= cchLeft; + pInt->cbRingBufUnflushed += cchLeft; + pInt->pchRingBufCur = pchStart; + + /* Ring buffer overflows (the plainly inefficient bit). */ + while (cchText >= cchBuf) + { + memcpy(pchStart, pachText, cchBuf); + pachText += cchBuf; + cchText -= cchBuf; + pInt->cbRingBufUnflushed += cchBuf; + } + + /* The final bit, if any. */ + if (cchText > 0) + { + memcpy(pchStart, pachText, cchText); + pInt->cbRingBufUnflushed += cchText; + } + pchStart[cchText] = '\0'; + pInt->pchRingBufCur = &pchStart[cchText]; + } +} + + +/** + * Flushes the ring buffer to all the other log destinations. + * + * @param pLoggerInt The logger instance which ring buffer should be flushed. + */ +static void rtLogRingBufFlush(PRTLOGGERINTERNAL pLoggerInt) +{ + const char *pszPreamble; + size_t cchPreamble; + const char *pszFirst; + size_t cchFirst; + const char *pszSecond; + size_t cchSecond; + + /* + * Get the ring buffer data, adjusting it to only describe the writable + * part of the buffer. + */ + uint64_t cchUnflushed = pLoggerInt->cbRingBufUnflushed; + char * const pszBuf = &pLoggerInt->pszRingBuf[sizeof(RTLOG_RINGBUF_EYE_CATCHER)]; + size_t const cchBuf = pLoggerInt->cbRingBuf - sizeof(RTLOG_RINGBUF_EYE_CATCHER) - sizeof(RTLOG_RINGBUF_EYE_CATCHER_END); + size_t offCur = pLoggerInt->pchRingBufCur - pszBuf; + size_t cchAfter; + if (RT_LIKELY(offCur < cchBuf)) + cchAfter = cchBuf - offCur; + else /* May happen in ring-0 where a thread or two went ahead without getting the lock. */ + { + offCur = 0; + cchAfter = cchBuf; + } + + pLoggerInt->cbRingBufUnflushed = 0; + + /* + * Figure out whether there are one or two segments that needs writing, + * making the last segment is terminated. (The first is always + * terminated because of the eye-catcher at the end of the buffer.) + */ + if (cchUnflushed == 0) + return; + pszBuf[offCur] = '\0'; + if (cchUnflushed >= cchBuf) + { + pszFirst = &pszBuf[offCur + 1]; + cchFirst = cchAfter ? cchAfter - 1 : 0; + pszSecond = pszBuf; + cchSecond = offCur; + pszPreamble = "\n*FLUSH RING BUF*\n"; + cchPreamble = sizeof("\n*FLUSH RING BUF*\n") - 1; + } + else if ((size_t)cchUnflushed <= offCur) + { + cchFirst = (size_t)cchUnflushed; + pszFirst = &pszBuf[offCur - cchFirst]; + pszSecond = ""; + cchSecond = 0; + pszPreamble = ""; + cchPreamble = 0; + } + else + { + cchFirst = (size_t)cchUnflushed - offCur; + pszFirst = &pszBuf[cchBuf - cchFirst]; + pszSecond = pszBuf; + cchSecond = offCur; + pszPreamble = ""; + cchPreamble = 0; + } + + /* + * Write the ring buffer to all other destiations. + */ + if (pLoggerInt->fDestFlags & RTLOGDEST_USER) + { + if (cchPreamble) + RTLogWriteUser(pszPreamble, cchPreamble); + if (cchFirst) + RTLogWriteUser(pszFirst, cchFirst); + if (cchSecond) + RTLogWriteUser(pszSecond, cchSecond); + } + +# if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64) + if (pLoggerInt->fDestFlags & RTLOGDEST_VMM) + { + if (cchPreamble) + RTLogWriteVmm(pszPreamble, cchPreamble, false /*fReleaseLog*/); + if (cchFirst) + RTLogWriteVmm(pszFirst, cchFirst, false /*fReleaseLog*/); + if (cchSecond) + RTLogWriteVmm(pszSecond, cchSecond, false /*fReleaseLog*/); + } + + if (pLoggerInt->fDestFlags & RTLOGDEST_VMM_REL) + { + if (cchPreamble) + RTLogWriteVmm(pszPreamble, cchPreamble, true /*fReleaseLog*/); + if (cchFirst) + RTLogWriteVmm(pszFirst, cchFirst, true /*fReleaseLog*/); + if (cchSecond) + RTLogWriteVmm(pszSecond, cchSecond, true /*fReleaseLog*/); + } +# endif + + if (pLoggerInt->fDestFlags & RTLOGDEST_DEBUGGER) + { + if (cchPreamble) + RTLogWriteDebugger(pszPreamble, cchPreamble); + if (cchFirst) + RTLogWriteDebugger(pszFirst, cchFirst); + if (cchSecond) + RTLogWriteDebugger(pszSecond, cchSecond); + } + +# ifdef IN_RING3 + if (pLoggerInt->fDestFlags & RTLOGDEST_FILE) + { + if (pLoggerInt->fLogOpened) + { + if (cchPreamble) + pLoggerInt->pOutputIf->pfnWrite(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, + pszPreamble, cchPreamble, NULL /*pcbWritten*/); + if (cchFirst) + pLoggerInt->pOutputIf->pfnWrite(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, + pszFirst, cchFirst, NULL /*pcbWritten*/); + if (cchSecond) + pLoggerInt->pOutputIf->pfnWrite(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, + pszSecond, cchSecond, NULL /*pcbWritten*/); + if (pLoggerInt->fFlags & RTLOGFLAGS_FLUSH) + pLoggerInt->pOutputIf->pfnFlush(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser); + } + if (pLoggerInt->cHistory) + pLoggerInt->cbHistoryFileWritten += cchFirst + cchSecond; + } +# endif + + if (pLoggerInt->fDestFlags & RTLOGDEST_STDOUT) + { + if (cchPreamble) + RTLogWriteStdOut(pszPreamble, cchPreamble); + if (cchFirst) + RTLogWriteStdOut(pszFirst, cchFirst); + if (cchSecond) + RTLogWriteStdOut(pszSecond, cchSecond); + } + + if (pLoggerInt->fDestFlags & RTLOGDEST_STDERR) + { + if (cchPreamble) + RTLogWriteStdErr(pszPreamble, cchPreamble); + if (cchFirst) + RTLogWriteStdErr(pszFirst, cchFirst); + if (cchSecond) + RTLogWriteStdErr(pszSecond, cchSecond); + } + +# if defined(IN_RING0) && !defined(LOG_NO_COM) + if (pLoggerInt->fDestFlags & RTLOGDEST_COM) + { + if (cchPreamble) + RTLogWriteCom(pszPreamble, cchPreamble); + if (cchFirst) + RTLogWriteCom(pszFirst, cchFirst); + if (cchSecond) + RTLogWriteCom(pszSecond, cchSecond); + } +# endif +} + + +/********************************************************************************************************************************* +* Create, Destroy, Setup * +*********************************************************************************************************************************/ + +RTDECL(int) RTLogCreateExV(PRTLOGGER *ppLogger, const char *pszEnvVarBase, uint64_t fFlags, const char *pszGroupSettings, + uint32_t cGroups, const char * const *papszGroups, uint32_t cMaxEntriesPerGroup, + uint32_t cBufDescs, PRTLOGBUFFERDESC paBufDescs, uint32_t fDestFlags, + PFNRTLOGPHASE pfnPhase, uint32_t cHistory, uint64_t cbHistoryFileMax, uint32_t cSecsHistoryTimeSlot, + PCRTLOGOUTPUTIF pOutputIf, void *pvOutputIfUser, + PRTERRINFO pErrInfo, const char *pszFilenameFmt, va_list args) +{ + int rc; + size_t cbLogger; + size_t offBuffers; + PRTLOGGERINTERNAL pLoggerInt; + uint32_t i; + + /* + * Validate input. + */ + AssertPtrReturn(ppLogger, VERR_INVALID_POINTER); + *ppLogger = NULL; + if (cGroups) + { + AssertPtrReturn(papszGroups, VERR_INVALID_POINTER); + AssertReturn(cGroups < _8K, VERR_OUT_OF_RANGE); + } + AssertMsgReturn(cHistory < _1M, ("%#x", cHistory), VERR_OUT_OF_RANGE); + AssertReturn(cBufDescs <= 128, VERR_OUT_OF_RANGE); + + /* + * Calculate the logger size. + */ + AssertCompileSize(RTLOGGER, 32); + cbLogger = RT_UOFFSETOF_DYN(RTLOGGERINTERNAL, afGroups[cGroups]); + if (fFlags & RTLOGFLAGS_RESTRICT_GROUPS) + cbLogger += cGroups * sizeof(uint32_t); + if (cBufDescs == 0) + { + /* Allocate one buffer descriptor and a default sized buffer. */ + cbLogger = RT_ALIGN_Z(cbLogger, RTLOG_BUFFER_ALIGN); + offBuffers = cbLogger; + cbLogger += RT_ALIGN_Z(sizeof(paBufDescs[0]), RTLOG_BUFFER_ALIGN) + RTLOG_BUFFER_DEFAULT_SIZE; + } + else + { + /* Caller-supplied buffer descriptors. If pchBuf is NULL, we have to allocate the buffers. */ + AssertPtrReturn(paBufDescs, VERR_INVALID_POINTER); + if (paBufDescs[0].pchBuf != NULL) + offBuffers = 0; + else + { + cbLogger = RT_ALIGN_Z(cbLogger, RTLOG_BUFFER_ALIGN); + offBuffers = cbLogger; + } + + for (i = 0; i < cBufDescs; i++) + { + AssertReturn(paBufDescs[i].u32Magic == RTLOGBUFFERDESC_MAGIC, VERR_INVALID_MAGIC); + AssertReturn(paBufDescs[i].uReserved == 0, VERR_INVALID_PARAMETER); + AssertMsgReturn(paBufDescs[i].cbBuf >= _1K && paBufDescs[i].cbBuf <= _64M, + ("paBufDesc[%u].cbBuf=%#x\n", i, paBufDescs[i].cbBuf), VERR_OUT_OF_RANGE); + AssertReturn(paBufDescs[i].offBuf == 0, VERR_INVALID_PARAMETER); + if (offBuffers != 0) + { + cbLogger += RT_ALIGN_Z(paBufDescs[i].cbBuf, RTLOG_BUFFER_ALIGN); + AssertReturn(paBufDescs[i].pchBuf == NULL, VERR_INVALID_PARAMETER); + AssertReturn(paBufDescs[i].pAux == NULL, VERR_INVALID_PARAMETER); + } + else + { + AssertPtrReturn(paBufDescs[i].pchBuf, VERR_INVALID_POINTER); + AssertPtrNullReturn(paBufDescs[i].pAux, VERR_INVALID_POINTER); + } + } + } + + /* + * Allocate a logger instance. + */ + pLoggerInt = (PRTLOGGERINTERNAL)RTMemAllocZVarTag(cbLogger, "may-leak:log-instance"); + if (pLoggerInt) + { +# if defined(RT_ARCH_X86) && !defined(LOG_USE_C99) + uint8_t *pu8Code; +# endif + pLoggerInt->Core.u32Magic = RTLOGGER_MAGIC; + pLoggerInt->cGroups = cGroups; + pLoggerInt->fFlags = fFlags; + pLoggerInt->fDestFlags = fDestFlags; + pLoggerInt->uRevision = RTLOGGERINTERNAL_REV; + pLoggerInt->cbSelf = sizeof(RTLOGGERINTERNAL); + pLoggerInt->hSpinMtx = NIL_RTSEMSPINMUTEX; + pLoggerInt->pfnFlush = NULL; + pLoggerInt->pfnPrefix = NULL; + pLoggerInt->pvPrefixUserArg = NULL; + pLoggerInt->fPendingPrefix = true; + pLoggerInt->fCreated = false; + pLoggerInt->nsR0ProgramStart = 0; + RT_ZERO(pLoggerInt->szR0ThreadName); + pLoggerInt->cMaxGroups = cGroups; + pLoggerInt->papszGroups = papszGroups; + if (fFlags & RTLOGFLAGS_RESTRICT_GROUPS) + pLoggerInt->pacEntriesPerGroup = &pLoggerInt->afGroups[cGroups]; + else + pLoggerInt->pacEntriesPerGroup = NULL; + pLoggerInt->cMaxEntriesPerGroup = cMaxEntriesPerGroup ? cMaxEntriesPerGroup : UINT32_MAX; +# ifdef IN_RING3 + pLoggerInt->pfnPhase = pfnPhase; + pLoggerInt->hFile = NIL_RTFILE; + pLoggerInt->fLogOpened = false; + pLoggerInt->cHistory = cHistory; + if (cbHistoryFileMax == 0) + pLoggerInt->cbHistoryFileMax = UINT64_MAX; + else + pLoggerInt->cbHistoryFileMax = cbHistoryFileMax; + if (cSecsHistoryTimeSlot == 0) + pLoggerInt->cSecsHistoryTimeSlot = UINT32_MAX; + else + pLoggerInt->cSecsHistoryTimeSlot = cSecsHistoryTimeSlot; + + if (pOutputIf) + { + pLoggerInt->pOutputIf = pOutputIf; + pLoggerInt->pvOutputIfUser = pvOutputIfUser; + } + else + { + /* Use the default interface for output logging. */ + pLoggerInt->pOutputIf = &g_LogOutputIfDef; + pLoggerInt->pvOutputIfUser = pLoggerInt; + } + +# else /* !IN_RING3 */ + RT_NOREF_PV(pfnPhase); RT_NOREF_PV(cHistory); RT_NOREF_PV(cbHistoryFileMax); RT_NOREF_PV(cSecsHistoryTimeSlot); + RT_NOREF_PV(pOutputIf); RT_NOREF_PV(pvOutputIfUser); +# endif /* !IN_RING3 */ + if (pszGroupSettings) + RTLogGroupSettings(&pLoggerInt->Core, pszGroupSettings); + + /* + * Buffer descriptors. + */ + if (!offBuffers) + { + /* Caller-supplied descriptors: */ + pLoggerInt->cBufDescs = cBufDescs; + pLoggerInt->paBufDescs = paBufDescs; + } + else if (cBufDescs) + { + /* Caller-supplied descriptors, but we allocate the actual buffers: */ + pLoggerInt->cBufDescs = cBufDescs; + pLoggerInt->paBufDescs = paBufDescs; + for (i = 0; i < cBufDescs; i++) + { + paBufDescs[i].pchBuf = (char *)pLoggerInt + offBuffers; + offBuffers = RT_ALIGN_Z(offBuffers + paBufDescs[i].cbBuf, RTLOG_BUFFER_ALIGN); + } + Assert(offBuffers == cbLogger); + } + else + { + /* One descriptor with a default sized buffer. */ + pLoggerInt->cBufDescs = cBufDescs = 1; + pLoggerInt->paBufDescs = paBufDescs = (PRTLOGBUFFERDESC)((char *)(char *)pLoggerInt + offBuffers); + offBuffers = RT_ALIGN_Z(offBuffers + sizeof(paBufDescs[0]) * cBufDescs, RTLOG_BUFFER_ALIGN); + for (i = 0; i < cBufDescs; i++) + { + paBufDescs[i].u32Magic = RTLOGBUFFERDESC_MAGIC; + paBufDescs[i].uReserved = 0; + paBufDescs[i].cbBuf = RTLOG_BUFFER_DEFAULT_SIZE; + paBufDescs[i].offBuf = 0; + paBufDescs[i].pAux = NULL; + paBufDescs[i].pchBuf = (char *)pLoggerInt + offBuffers; + offBuffers = RT_ALIGN_Z(offBuffers + RTLOG_BUFFER_DEFAULT_SIZE, RTLOG_BUFFER_ALIGN); + } + Assert(offBuffers == cbLogger); + } + pLoggerInt->pBufDesc = paBufDescs; + pLoggerInt->idxBufDesc = 0; + +# if defined(RT_ARCH_X86) && !defined(LOG_USE_C99) && 0 /* retired */ + /* + * Emit wrapper code. + */ + pu8Code = (uint8_t *)RTMemExecAlloc(64); + if (pu8Code) + { + pLoggerInt->Core.pfnLogger = *(PFNRTLOGGER *)&pu8Code; + *pu8Code++ = 0x68; /* push imm32 */ + *(void **)pu8Code = &pLoggerInt->Core; + pu8Code += sizeof(void *); + *pu8Code++ = 0xe8; /* call rel32 */ + *(uint32_t *)pu8Code = (uintptr_t)RTLogLogger - ((uintptr_t)pu8Code + sizeof(uint32_t)); + pu8Code += sizeof(uint32_t); + *pu8Code++ = 0x8d; /* lea esp, [esp + 4] */ + *pu8Code++ = 0x64; + *pu8Code++ = 0x24; + *pu8Code++ = 0x04; + *pu8Code++ = 0xc3; /* ret near */ + AssertMsg((uintptr_t)pu8Code - (uintptr_t)pLoggerInt->Core.pfnLogger <= 64, + ("Wrapper assembly is too big! %d bytes\n", (uintptr_t)pu8Code - (uintptr_t)pLoggerInt->Core.pfnLogger)); + rc = VINF_SUCCESS; + } + else + { + rc = VERR_NO_MEMORY; +# ifdef RT_OS_LINUX + /* Most probably SELinux causing trouble since the larger RTMemAlloc succeeded. */ + RTErrInfoSet(pErrInfo, rc, N_("mmap(PROT_WRITE | PROT_EXEC) failed -- SELinux?")); +# endif + } + if (RT_SUCCESS(rc)) +# endif /* X86 wrapper code */ + { +# ifdef IN_RING3 /* files and env.vars. are only accessible when in R3 at the present time. */ + /* + * Format the filename. + */ + if (pszFilenameFmt) + { + /** @todo validate the length, fail on overflow. */ + RTStrPrintfV(pLoggerInt->szFilename, sizeof(pLoggerInt->szFilename), pszFilenameFmt, args); + if (pLoggerInt->szFilename[0]) + pLoggerInt->fDestFlags |= RTLOGDEST_FILE; + } + + /* + * Parse the environment variables. + */ + if (pszEnvVarBase) + { + /* make temp copy of environment variable base. */ + size_t cchEnvVarBase = strlen(pszEnvVarBase); + char *pszEnvVar = (char *)alloca(cchEnvVarBase + 16); + memcpy(pszEnvVar, pszEnvVarBase, cchEnvVarBase); + + /* + * Destination. + */ + strcpy(pszEnvVar + cchEnvVarBase, "_DEST"); + const char *pszValue = RTEnvGet(pszEnvVar); + if (pszValue) + RTLogDestinations(&pLoggerInt->Core, pszValue); + + /* + * The flags. + */ + strcpy(pszEnvVar + cchEnvVarBase, "_FLAGS"); + pszValue = RTEnvGet(pszEnvVar); + if (pszValue) + RTLogFlags(&pLoggerInt->Core, pszValue); + + /* + * The group settings. + */ + pszEnvVar[cchEnvVarBase] = '\0'; + pszValue = RTEnvGet(pszEnvVar); + if (pszValue) + RTLogGroupSettings(&pLoggerInt->Core, pszValue); + + /* + * Group limit. + */ + strcpy(pszEnvVar + cchEnvVarBase, "_MAX_PER_GROUP"); + pszValue = RTEnvGet(pszEnvVar); + if (pszValue) + { + uint32_t cMax; + rc = RTStrToUInt32Full(pszValue, 0, &cMax); + if (RT_SUCCESS(rc)) + pLoggerInt->cMaxEntriesPerGroup = cMax ? cMax : UINT32_MAX; + else + AssertMsgFailed(("Invalid group limit! %s=%s\n", pszEnvVar, pszValue)); + } + + } +# else /* !IN_RING3 */ + RT_NOREF_PV(pszEnvVarBase); RT_NOREF_PV(pszFilenameFmt); RT_NOREF_PV(args); +# endif /* !IN_RING3 */ + + /* + * Open the destination(s). + */ + rc = VINF_SUCCESS; + if ((pLoggerInt->fDestFlags & (RTLOGDEST_F_DELAY_FILE | RTLOGDEST_FILE)) == RTLOGDEST_F_DELAY_FILE) + pLoggerInt->fDestFlags &= ~RTLOGDEST_F_DELAY_FILE; +# ifdef IN_RING3 + if ((pLoggerInt->fDestFlags & (RTLOGDEST_FILE | RTLOGDEST_F_DELAY_FILE)) == RTLOGDEST_FILE) + rc = rtR3LogOpenFileDestination(pLoggerInt, pErrInfo); +# endif + + if ((pLoggerInt->fDestFlags & RTLOGDEST_RINGBUF) && RT_SUCCESS(rc)) + rc = rtLogRingBufAdjust(pLoggerInt, pLoggerInt->cbRingBuf, true /*fForce*/); + + /* + * Create mutex and check how much it counts when entering the lock + * so that we can report the values for RTLOGFLAGS_PREFIX_LOCK_COUNTS. + */ + if (RT_SUCCESS(rc)) + { + if (!(fFlags & RTLOG_F_NO_LOCKING)) + rc = RTSemSpinMutexCreate(&pLoggerInt->hSpinMtx, RTSEMSPINMUTEX_FLAGS_IRQ_SAFE); + if (RT_SUCCESS(rc)) + { +# ifdef IN_RING3 /** @todo do counters in ring-0 too? */ + RTTHREAD Thread = RTThreadSelf(); + if (Thread != NIL_RTTHREAD) + { + int32_t c = RTLockValidatorWriteLockGetCount(Thread); + RTSemSpinMutexRequest(pLoggerInt->hSpinMtx); + c = RTLockValidatorWriteLockGetCount(Thread) - c; + RTSemSpinMutexRelease(pLoggerInt->hSpinMtx); + ASMAtomicWriteU32(&g_cLoggerLockCount, c); + } + + /* Use the callback to generate some initial log contents. */ + AssertPtrNull(pLoggerInt->pfnPhase); + if (pLoggerInt->pfnPhase) + pLoggerInt->pfnPhase(&pLoggerInt->Core, RTLOGPHASE_BEGIN, rtlogPhaseMsgNormal); +# endif + pLoggerInt->fCreated = true; + *ppLogger = &pLoggerInt->Core; + +# if defined(IN_RING3) && (defined(IN_RT_STATIC) || defined(IPRT_NO_CRT)) + /* Make sure the weak symbol emulation bits are ready before returning. */ + if (!g_pfnRTLogLoggerExV) + g_pfnRTLogLoggerExV = RTLogLoggerExV; +# endif + return VINF_SUCCESS; + } + + RTErrInfoSet(pErrInfo, rc, N_("failed to create semaphore")); + } +# ifdef IN_RING3 + pLoggerInt->pOutputIf->pfnClose(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser); +# endif +# if defined(RT_ARCH_X86) && !defined(LOG_USE_C99) && 0 /* retired */ + if (pLoggerInt->Core.pfnLogger) + { + RTMemExecFree(*(void **)&pLoggerInt->Core.pfnLogger, 64); + pLoggerInt->Core.pfnLogger = NULL; + } +# endif + } + RTMemFree(pLoggerInt); + } + else + rc = VERR_NO_MEMORY; + + return rc; +} +RT_EXPORT_SYMBOL(RTLogCreateExV); + + +RTDECL(int) RTLogCreate(PRTLOGGER *ppLogger, uint64_t fFlags, const char *pszGroupSettings, + const char *pszEnvVarBase, unsigned cGroups, const char * const * papszGroups, + uint32_t fDestFlags, const char *pszFilenameFmt, ...) +{ + va_list va; + int rc; + + va_start(va, pszFilenameFmt); + rc = RTLogCreateExV(ppLogger, pszEnvVarBase, fFlags, pszGroupSettings, cGroups, papszGroups, + UINT32_MAX /*cMaxEntriesPerGroup*/, + 0 /*cBufDescs*/, NULL /*paBufDescs*/, fDestFlags, + NULL /*pfnPhase*/, 0 /*cHistory*/, 0 /*cbHistoryFileMax*/, 0 /*cSecsHistoryTimeSlot*/, + NULL /*pOutputIf*/, NULL /*pvOutputIfUser*/, + NULL /*pErrInfo*/, pszFilenameFmt, va); + va_end(va); + return rc; +} +RT_EXPORT_SYMBOL(RTLogCreate); + + +RTDECL(int) RTLogDestroy(PRTLOGGER pLogger) +{ + int rc; + uint32_t iGroup; + RTSEMSPINMUTEX hSpinMtx; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + + /* + * Validate input. + */ + if (!pLoggerInt) + return VINF_SUCCESS; + AssertPtrReturn(pLoggerInt, VERR_INVALID_POINTER); + AssertReturn(pLoggerInt->Core.u32Magic == RTLOGGER_MAGIC, VERR_INVALID_MAGIC); + + /* + * Acquire logger instance sem and disable all logging. (paranoia) + */ + rc = rtlogLock(pLoggerInt); + AssertMsgRCReturn(rc, ("%Rrc\n", rc), rc); + + pLoggerInt->fFlags |= RTLOGFLAGS_DISABLED; + iGroup = pLoggerInt->cGroups; + while (iGroup-- > 0) + pLoggerInt->afGroups[iGroup] = 0; + + /* + * Flush it. + */ + rtlogFlush(pLoggerInt, false /*fNeedSpace*/); + +# ifdef IN_RING3 + /* + * Add end of logging message. + */ + if ( (pLoggerInt->fDestFlags & RTLOGDEST_FILE) + && pLoggerInt->fLogOpened) + pLoggerInt->pfnPhase(&pLoggerInt->Core, RTLOGPHASE_END, rtlogPhaseMsgLocked); + + /* + * Close output stuffs. + */ + if (pLoggerInt->fLogOpened) + { + int rc2 = pLoggerInt->pOutputIf->pfnClose(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser); + if (RT_FAILURE(rc2) && RT_SUCCESS(rc)) + rc = rc2; + pLoggerInt->fLogOpened = false; + } +# endif + + /* + * Free the mutex, the wrapper and the instance memory. + */ + hSpinMtx = pLoggerInt->hSpinMtx; + pLoggerInt->hSpinMtx = NIL_RTSEMSPINMUTEX; + if (hSpinMtx != NIL_RTSEMSPINMUTEX) + { + int rc2; + RTSemSpinMutexRelease(hSpinMtx); + rc2 = RTSemSpinMutexDestroy(hSpinMtx); + AssertRC(rc2); + if (RT_FAILURE(rc2) && RT_SUCCESS(rc)) + rc = rc2; + } + +# if defined(RT_ARCH_X86) && !defined(LOG_USE_C99) && 0 /* retired */ + if (pLoggerInt->Core.pfnLogger) + { + RTMemExecFree(*(void **)&pLoggerInt->Core.pfnLogger, 64); + pLoggerInt->Core.pfnLogger = NULL; + } +# endif + RTMemFree(pLoggerInt); + + return rc; +} +RT_EXPORT_SYMBOL(RTLogDestroy); + + +RTDECL(int) RTLogSetCustomPrefixCallback(PRTLOGGER pLogger, PFNRTLOGPREFIX pfnCallback, void *pvUser) +{ + int rc; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + + /* + * Do the work. + */ + rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + pLoggerInt->pvPrefixUserArg = pvUser; + pLoggerInt->pfnPrefix = pfnCallback; + rtlogUnlock(pLoggerInt); + } + + return rc; +} +RT_EXPORT_SYMBOL(RTLogSetCustomPrefixCallback); + + +RTDECL(int) RTLogSetFlushCallback(PRTLOGGER pLogger, PFNRTLOGFLUSH pfnFlush) +{ + int rc; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + + /* + * Do the work. + */ + rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + if (pLoggerInt->pfnFlush && pLoggerInt->pfnFlush != pfnFlush) + rc = VWRN_ALREADY_EXISTS; + pLoggerInt->pfnFlush = pfnFlush; + rtlogUnlock(pLoggerInt); + } + + return rc; +} +RT_EXPORT_SYMBOL(RTLogSetFlushCallback); + + +/** + * Matches a group name with a pattern mask in an case insensitive manner (ASCII). + * + * @returns true if matching and *ppachMask set to the end of the pattern. + * @returns false if no match. + * @param pszGrp The group name. + * @param ppachMask Pointer to the pointer to the mask. Only wildcard supported is '*'. + * @param cchMask The length of the mask, including modifiers. The modifiers is why + * we update *ppachMask on match. + */ +static bool rtlogIsGroupMatching(const char *pszGrp, const char **ppachMask, size_t cchMask) +{ + const char *pachMask; + + if (!pszGrp || !*pszGrp) + return false; + pachMask = *ppachMask; + for (;;) + { + if (RT_C_TO_LOWER(*pszGrp) != RT_C_TO_LOWER(*pachMask)) + { + const char *pszTmp; + + /* + * Check for wildcard and do a minimal match if found. + */ + if (*pachMask != '*') + return false; + + /* eat '*'s. */ + do pachMask++; + while (--cchMask && *pachMask == '*'); + + /* is there more to match? */ + if ( !cchMask + || *pachMask == '.' + || *pachMask == '=') + break; /* we're good */ + + /* do extremely minimal matching (fixme) */ + pszTmp = strchr(pszGrp, RT_C_TO_LOWER(*pachMask)); + if (!pszTmp) + pszTmp = strchr(pszGrp, RT_C_TO_UPPER(*pachMask)); + if (!pszTmp) + return false; + pszGrp = pszTmp; + continue; + } + + /* done? */ + if (!*++pszGrp) + { + /* trailing wildcard is ok. */ + do + { + pachMask++; + cchMask--; + } while (cchMask && *pachMask == '*'); + if ( !cchMask + || *pachMask == '.' + || *pachMask == '=') + break; /* we're good */ + return false; + } + + if (!--cchMask) + return false; + pachMask++; + } + + /* match */ + *ppachMask = pachMask; + return true; +} + + +RTDECL(int) RTLogGroupSettings(PRTLOGGER pLogger, const char *pszValue) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + Assert(pLoggerInt->Core.u32Magic == RTLOGGER_MAGIC); + + /* + * Iterate the string. + */ + while (*pszValue) + { + /* + * Skip prefixes (blanks, ;, + and -). + */ + bool fEnabled = true; + char ch; + const char *pszStart; + unsigned i; + size_t cch; + + while ((ch = *pszValue) == '+' || ch == '-' || ch == ' ' || ch == '\t' || ch == '\n' || ch == ';') + { + if (ch == '+' || ch == '-' || ch == ';') + fEnabled = ch != '-'; + pszValue++; + } + if (!*pszValue) + break; + + /* + * Find end. + */ + pszStart = pszValue; + while ((ch = *pszValue) != '\0' && ch != '+' && ch != '-' && ch != ' ' && ch != '\t') + pszValue++; + + /* + * Find the group (ascii case insensitive search). + * Special group 'all'. + */ + cch = pszValue - pszStart; + if ( cch >= 3 + && (pszStart[0] == 'a' || pszStart[0] == 'A') + && (pszStart[1] == 'l' || pszStart[1] == 'L') + && (pszStart[2] == 'l' || pszStart[2] == 'L') + && (cch == 3 || pszStart[3] == '.' || pszStart[3] == '=')) + { + /* + * All. + */ + unsigned fFlags = cch == 3 + ? RTLOGGRPFLAGS_ENABLED | RTLOGGRPFLAGS_LEVEL_1 + : rtlogGroupFlags(&pszStart[3]); + for (i = 0; i < pLoggerInt->cGroups; i++) + { + if (fEnabled) + pLoggerInt->afGroups[i] |= fFlags; + else + pLoggerInt->afGroups[i] &= ~fFlags; + } + } + else + { + /* + * Specific group(s). + */ + for (i = 0; i < pLoggerInt->cGroups; i++) + { + const char *psz2 = (const char*)pszStart; + if (rtlogIsGroupMatching(pLoggerInt->papszGroups[i], &psz2, cch)) + { + unsigned fFlags = RTLOGGRPFLAGS_ENABLED | RTLOGGRPFLAGS_LEVEL_1; + if (*psz2 == '.' || *psz2 == '=') + fFlags = rtlogGroupFlags(psz2); + if (fEnabled) + pLoggerInt->afGroups[i] |= fFlags; + else + pLoggerInt->afGroups[i] &= ~fFlags; + } + } /* for each group */ + } + + } /* parse specification */ + + return VINF_SUCCESS; +} +RT_EXPORT_SYMBOL(RTLogGroupSettings); + + +/** + * Interprets the group flags suffix. + * + * @returns Flags specified. (0 is possible!) + * @param psz Start of Suffix. (Either dot or equal sign.) + */ +static unsigned rtlogGroupFlags(const char *psz) +{ + unsigned fFlags = 0; + + /* + * Literal flags. + */ + while (*psz == '.') + { + static struct + { + const char *pszFlag; /* lowercase!! */ + unsigned fFlag; + } aFlags[] = + { + { "eo", RTLOGGRPFLAGS_ENABLED }, + { "enabledonly",RTLOGGRPFLAGS_ENABLED }, + { "e", RTLOGGRPFLAGS_ENABLED | RTLOGGRPFLAGS_LEVEL_1 | RTLOGGRPFLAGS_WARN }, + { "enabled", RTLOGGRPFLAGS_ENABLED | RTLOGGRPFLAGS_LEVEL_1 | RTLOGGRPFLAGS_WARN }, + { "l1", RTLOGGRPFLAGS_LEVEL_1 }, + { "level1", RTLOGGRPFLAGS_LEVEL_1 }, + { "l", RTLOGGRPFLAGS_LEVEL_2 }, + { "l2", RTLOGGRPFLAGS_LEVEL_2 }, + { "level2", RTLOGGRPFLAGS_LEVEL_2 }, + { "l3", RTLOGGRPFLAGS_LEVEL_3 }, + { "level3", RTLOGGRPFLAGS_LEVEL_3 }, + { "l4", RTLOGGRPFLAGS_LEVEL_4 }, + { "level4", RTLOGGRPFLAGS_LEVEL_4 }, + { "l5", RTLOGGRPFLAGS_LEVEL_5 }, + { "level5", RTLOGGRPFLAGS_LEVEL_5 }, + { "l6", RTLOGGRPFLAGS_LEVEL_6 }, + { "level6", RTLOGGRPFLAGS_LEVEL_6 }, + { "l7", RTLOGGRPFLAGS_LEVEL_7 }, + { "level7", RTLOGGRPFLAGS_LEVEL_7 }, + { "l8", RTLOGGRPFLAGS_LEVEL_8 }, + { "level8", RTLOGGRPFLAGS_LEVEL_8 }, + { "l9", RTLOGGRPFLAGS_LEVEL_9 }, + { "level9", RTLOGGRPFLAGS_LEVEL_9 }, + { "l10", RTLOGGRPFLAGS_LEVEL_10 }, + { "level10", RTLOGGRPFLAGS_LEVEL_10 }, + { "l11", RTLOGGRPFLAGS_LEVEL_11 }, + { "level11", RTLOGGRPFLAGS_LEVEL_11 }, + { "l12", RTLOGGRPFLAGS_LEVEL_12 }, + { "level12", RTLOGGRPFLAGS_LEVEL_12 }, + { "f", RTLOGGRPFLAGS_FLOW }, + { "flow", RTLOGGRPFLAGS_FLOW }, + { "w", RTLOGGRPFLAGS_WARN }, + { "warn", RTLOGGRPFLAGS_WARN }, + { "warning", RTLOGGRPFLAGS_WARN }, + { "restrict", RTLOGGRPFLAGS_RESTRICT }, + + }; + unsigned i; + bool fFound = false; + psz++; + for (i = 0; i < RT_ELEMENTS(aFlags) && !fFound; i++) + { + const char *psz1 = aFlags[i].pszFlag; + const char *psz2 = psz; + while (*psz1 == RT_C_TO_LOWER(*psz2)) + { + psz1++; + psz2++; + if (!*psz1) + { + if ( (*psz2 >= 'a' && *psz2 <= 'z') + || (*psz2 >= 'A' && *psz2 <= 'Z') + || (*psz2 >= '0' && *psz2 <= '9') ) + break; + fFlags |= aFlags[i].fFlag; + fFound = true; + psz = psz2; + break; + } + } /* strincmp */ + } /* for each flags */ + AssertMsg(fFound, ("%.15s...", psz)); + } + + /* + * Flag value. + */ + if (*psz == '=') + { + psz++; + if (*psz == '~') + fFlags = ~RTStrToInt32(psz + 1); + else + fFlags = RTStrToInt32(psz); + } + + return fFlags; +} + + +/** + * Helper for RTLogGetGroupSettings. + */ +static int rtLogGetGroupSettingsAddOne(const char *pszName, uint32_t fGroup, char **ppszBuf, size_t *pcchBuf, bool *pfNotFirst) +{ +#define APPEND_PSZ(psz,cch) do { memcpy(*ppszBuf, (psz), (cch)); *ppszBuf += (cch); *pcchBuf -= (cch); } while (0) +#define APPEND_SZ(sz) APPEND_PSZ(sz, sizeof(sz) - 1) +#define APPEND_CH(ch) do { **ppszBuf = (ch); *ppszBuf += 1; *pcchBuf -= 1; } while (0) + + /* + * Add the name. + */ + size_t cchName = strlen(pszName); + if (cchName + 1 + *pfNotFirst > *pcchBuf) + return VERR_BUFFER_OVERFLOW; + if (*pfNotFirst) + APPEND_CH(' '); + else + *pfNotFirst = true; + APPEND_PSZ(pszName, cchName); + + /* + * Only generate mnemonics for the simple+common bits. + */ + if (fGroup == (RTLOGGRPFLAGS_ENABLED | RTLOGGRPFLAGS_LEVEL_1)) + /* nothing */; + else if ( fGroup == (RTLOGGRPFLAGS_ENABLED | RTLOGGRPFLAGS_LEVEL_1 | RTLOGGRPFLAGS_LEVEL_2 | RTLOGGRPFLAGS_FLOW) + && *pcchBuf >= sizeof(".e.l.f")) + APPEND_SZ(".e.l.f"); + else if ( fGroup == (RTLOGGRPFLAGS_ENABLED | RTLOGGRPFLAGS_LEVEL_1 | RTLOGGRPFLAGS_FLOW) + && *pcchBuf >= sizeof(".e.f")) + APPEND_SZ(".e.f"); + else if (*pcchBuf >= 1 + 10 + 1) + { + size_t cch; + APPEND_CH('='); + cch = RTStrFormatNumber(*ppszBuf, fGroup, 16, 0, 0, RTSTR_F_SPECIAL | RTSTR_F_32BIT); + *ppszBuf += cch; + *pcchBuf -= cch; + } + else + return VERR_BUFFER_OVERFLOW; + +#undef APPEND_PSZ +#undef APPEND_SZ +#undef APPEND_CH + return VINF_SUCCESS; +} + + +RTDECL(int) RTLogQueryGroupSettings(PRTLOGGER pLogger, char *pszBuf, size_t cchBuf) +{ + bool fNotFirst = false; + int rc = VINF_SUCCESS; + uint32_t cGroups; + uint32_t fGroup; + uint32_t i; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + Assert(pLoggerInt->Core.u32Magic == RTLOGGER_MAGIC); + Assert(cchBuf); + + /* + * Check if all are the same. + */ + cGroups = pLoggerInt->cGroups; + fGroup = pLoggerInt->afGroups[0]; + for (i = 1; i < cGroups; i++) + if (pLoggerInt->afGroups[i] != fGroup) + break; + if (i >= cGroups) + rc = rtLogGetGroupSettingsAddOne("all", fGroup, &pszBuf, &cchBuf, &fNotFirst); + else + { + + /* + * Iterate all the groups and print all that are enabled. + */ + for (i = 0; i < cGroups; i++) + { + fGroup = pLoggerInt->afGroups[i]; + if (fGroup) + { + const char *pszName = pLoggerInt->papszGroups[i]; + if (pszName) + { + rc = rtLogGetGroupSettingsAddOne(pszName, fGroup, &pszBuf, &cchBuf, &fNotFirst); + if (rc) + break; + } + } + } + } + + *pszBuf = '\0'; + return rc; +} +RT_EXPORT_SYMBOL(RTLogQueryGroupSettings); + + +RTDECL(int) RTLogFlags(PRTLOGGER pLogger, const char *pszValue) +{ + int rc = VINF_SUCCESS; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + Assert(pLoggerInt->Core.u32Magic == RTLOGGER_MAGIC); + + /* + * Iterate the string. + */ + while (*pszValue) + { + /* check no prefix. */ + bool fNo = false; + char ch; + unsigned i; + + /* skip blanks. */ + while (RT_C_IS_SPACE(*pszValue)) + pszValue++; + if (!*pszValue) + return rc; + + while ((ch = *pszValue) != '\0') + { + if (ch == 'n' && pszValue[1] == 'o') + { + pszValue += 2; + fNo = !fNo; + } + else if (ch == '+') + { + pszValue++; + fNo = true; + } + else if (ch == '-' || ch == '!' || ch == '~') + { + pszValue++; + fNo = !fNo; + } + else + break; + } + + /* instruction. */ + for (i = 0; i < RT_ELEMENTS(g_aLogFlags); i++) + { + if (!strncmp(pszValue, g_aLogFlags[i].pszInstr, g_aLogFlags[i].cchInstr)) + { + if (!(g_aLogFlags[i].fFixedDest & pLoggerInt->fDestFlags)) + { + if (fNo == g_aLogFlags[i].fInverted) + pLoggerInt->fFlags |= g_aLogFlags[i].fFlag; + else + pLoggerInt->fFlags &= ~g_aLogFlags[i].fFlag; + } + pszValue += g_aLogFlags[i].cchInstr; + break; + } + } + + /* unknown instruction? */ + if (i >= RT_ELEMENTS(g_aLogFlags)) + { + AssertMsgFailed(("Invalid flags! unknown instruction %.20s\n", pszValue)); + pszValue++; + } + + /* skip blanks and delimiters. */ + while (RT_C_IS_SPACE(*pszValue) || *pszValue == ';') + pszValue++; + } /* while more environment variable value left */ + + return rc; +} +RT_EXPORT_SYMBOL(RTLogFlags); + + +RTDECL(bool) RTLogSetBuffering(PRTLOGGER pLogger, bool fBuffered) +{ + int rc; + bool fOld = false; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, false); + + rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + fOld = !!(pLoggerInt->fFlags & RTLOGFLAGS_BUFFERED); + if (fBuffered) + pLoggerInt->fFlags |= RTLOGFLAGS_BUFFERED; + else + pLoggerInt->fFlags &= ~RTLOGFLAGS_BUFFERED; + rtlogUnlock(pLoggerInt); + } + + return fOld; +} +RT_EXPORT_SYMBOL(RTLogSetBuffering); + + +RTDECL(uint32_t) RTLogSetGroupLimit(PRTLOGGER pLogger, uint32_t cMaxEntriesPerGroup) +{ + int rc; + uint32_t cOld = UINT32_MAX; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, UINT32_MAX); + + rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + cOld = pLoggerInt->cMaxEntriesPerGroup; + pLoggerInt->cMaxEntriesPerGroup = cMaxEntriesPerGroup; + rtlogUnlock(pLoggerInt); + } + + return cOld; +} +RT_EXPORT_SYMBOL(RTLogSetGroupLimit); + + +#ifdef IN_RING0 + +RTR0DECL(int) RTLogSetR0ThreadNameV(PRTLOGGER pLogger, const char *pszNameFmt, va_list va) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + int rc; + if (pLoggerInt) + { + rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + ssize_t cch = RTStrPrintf2V(pLoggerInt->szR0ThreadName, sizeof(pLoggerInt->szR0ThreadName), pszNameFmt, va); + rtlogUnlock(pLoggerInt); + rc = cch > 0 ? VINF_SUCCESS : VERR_BUFFER_OVERFLOW; + } + } + else + rc = VERR_INVALID_PARAMETER; + return rc; +} +RT_EXPORT_SYMBOL(RTLogSetR0ThreadNameV); + + +RTR0DECL(int) RTLogSetR0ProgramStart(PRTLOGGER pLogger, uint64_t nsStart) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + int rc; + if (pLoggerInt) + { + rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + pLoggerInt->nsR0ProgramStart = nsStart; + rtlogUnlock(pLoggerInt); + } + } + else + rc = VERR_INVALID_PARAMETER; + return rc; +} +RT_EXPORT_SYMBOL(RTLogSetR0ProgramStart); + +#endif /* IN_RING0 */ + +RTDECL(uint64_t) RTLogGetFlags(PRTLOGGER pLogger) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, UINT64_MAX); + Assert(pLoggerInt->Core.u32Magic == RTLOGGER_MAGIC); + return pLoggerInt->fFlags; +} +RT_EXPORT_SYMBOL(RTLogGetFlags); + + +RTDECL(int) RTLogChangeFlags(PRTLOGGER pLogger, uint64_t fSet, uint64_t fClear) +{ + int rc; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + AssertReturn(!(fSet & ~RTLOG_F_VALID_MASK), VERR_INVALID_FLAGS); + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + + /* + * Make the changes. + */ + rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + pLoggerInt->fFlags &= ~fClear; + pLoggerInt->fFlags |= fSet; + rtlogUnlock(pLoggerInt); + } + return rc; +} +RT_EXPORT_SYMBOL(RTLogChangeFlags); + + +RTDECL(int) RTLogQueryFlags(PRTLOGGER pLogger, char *pszBuf, size_t cchBuf) +{ + bool fNotFirst = false; + int rc = VINF_SUCCESS; + uint32_t fFlags; + unsigned i; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + + Assert(cchBuf); + *pszBuf = '\0'; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + Assert(pLoggerInt->Core.u32Magic == RTLOGGER_MAGIC); + + /* + * Add the flags in the list. + */ + fFlags = pLoggerInt->fFlags; + for (i = 0; i < RT_ELEMENTS(g_aLogFlags); i++) + if ( !g_aLogFlags[i].fInverted + ? (g_aLogFlags[i].fFlag & fFlags) + : !(g_aLogFlags[i].fFlag & fFlags)) + { + size_t cchInstr = g_aLogFlags[i].cchInstr; + if (cchInstr + fNotFirst + 1 > cchBuf) + { + rc = VERR_BUFFER_OVERFLOW; + break; + } + if (fNotFirst) + { + *pszBuf++ = ' '; + cchBuf--; + } + memcpy(pszBuf, g_aLogFlags[i].pszInstr, cchInstr); + pszBuf += cchInstr; + cchBuf -= cchInstr; + fNotFirst = true; + } + *pszBuf = '\0'; + return rc; +} +RT_EXPORT_SYMBOL(RTLogQueryFlags); + + +/** + * Finds the end of a destination value. + * + * The value ends when we counter a ';' or a free standing word (space on both + * from the g_aLogDst table. (If this is problematic for someone, we could + * always do quoting and escaping.) + * + * @returns Value length in chars. + * @param pszValue The first char after '=' or ':'. + */ +static size_t rtLogDestFindValueLength(const char *pszValue) +{ + size_t off = 0; + char ch; + while ((ch = pszValue[off]) != '\0' && ch != ';') + { + if (!RT_C_IS_SPACE(ch)) + off++; + else + { + unsigned i; + size_t cchThusFar = off; + do + off++; + while ((ch = pszValue[off]) != '\0' && RT_C_IS_SPACE(ch)); + if (ch == ';') + return cchThusFar; + + if (ch == 'n' && pszValue[off + 1] == 'o') + off += 2; + for (i = 0; i < RT_ELEMENTS(g_aLogDst); i++) + if (!strncmp(&pszValue[off], g_aLogDst[i].pszInstr, g_aLogDst[i].cchInstr)) + { + ch = pszValue[off + g_aLogDst[i].cchInstr]; + if (ch == '\0' || RT_C_IS_SPACE(ch) || ch == '=' || ch == ':' || ch == ';') + return cchThusFar; + } + } + } + return off; +} + + +RTDECL(int) RTLogDestinations(PRTLOGGER pLogger, char const *pszValue) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + Assert(pLoggerInt->Core.u32Magic == RTLOGGER_MAGIC); + /** @todo locking? */ + + /* + * Do the parsing. + */ + while (*pszValue) + { + bool fNo; + unsigned i; + + /* skip blanks. */ + while (RT_C_IS_SPACE(*pszValue)) + pszValue++; + if (!*pszValue) + break; + + /* check no prefix. */ + fNo = false; + if ( pszValue[0] == 'n' + && pszValue[1] == 'o' + && ( pszValue[2] != 'd' + || pszValue[3] != 'e' + || pszValue[4] != 'n' + || pszValue[5] != 'y')) + { + fNo = true; + pszValue += 2; + } + + /* instruction. */ + for (i = 0; i < RT_ELEMENTS(g_aLogDst); i++) + { + if (!strncmp(pszValue, g_aLogDst[i].pszInstr, g_aLogDst[i].cchInstr)) + { + if (!fNo) + pLoggerInt->fDestFlags |= g_aLogDst[i].fFlag; + else + pLoggerInt->fDestFlags &= ~g_aLogDst[i].fFlag; + pszValue += g_aLogDst[i].cchInstr; + + /* check for value. */ + while (RT_C_IS_SPACE(*pszValue)) + pszValue++; + if (*pszValue == '=' || *pszValue == ':') + { + pszValue++; + size_t cch = rtLogDestFindValueLength(pszValue); + const char *pszEnd = pszValue + cch; + +# ifdef IN_RING3 + char szTmp[sizeof(pLoggerInt->szFilename)]; +# else + char szTmp[32]; +# endif + if (0) + { /* nothing */ } +# ifdef IN_RING3 + + /* log file name */ + else if (i == 0 /* file */ && !fNo) + { + if (!(pLoggerInt->fDestFlags & RTLOGDEST_FIXED_FILE)) + { + AssertReturn(cch < sizeof(pLoggerInt->szFilename), VERR_OUT_OF_RANGE); + memcpy(pLoggerInt->szFilename, pszValue, cch); + pLoggerInt->szFilename[cch] = '\0'; + /** @todo reopen log file if pLoggerInt->fCreated is true ... */ + } + } + /* log directory */ + else if (i == 1 /* dir */ && !fNo) + { + if (!(pLoggerInt->fDestFlags & RTLOGDEST_FIXED_DIR)) + { + const char *pszFile = RTPathFilename(pLoggerInt->szFilename); + size_t cchFile = pszFile ? strlen(pszFile) : 0; + AssertReturn(cchFile + cch + 1 < sizeof(pLoggerInt->szFilename), VERR_OUT_OF_RANGE); + memcpy(szTmp, cchFile ? pszFile : "", cchFile + 1); + + memcpy(pLoggerInt->szFilename, pszValue, cch); + pLoggerInt->szFilename[cch] = '\0'; + RTPathStripTrailingSlash(pLoggerInt->szFilename); + + cch = strlen(pLoggerInt->szFilename); + pLoggerInt->szFilename[cch++] = '/'; + memcpy(&pLoggerInt->szFilename[cch], szTmp, cchFile); + pLoggerInt->szFilename[cch + cchFile] = '\0'; + /** @todo reopen log file if pLoggerInt->fCreated is true ... */ + } + } + else if (i == 2 /* history */) + { + if (!fNo) + { + uint32_t cHistory = 0; + int rc = RTStrCopyEx(szTmp, sizeof(szTmp), pszValue, cch); + if (RT_SUCCESS(rc)) + rc = RTStrToUInt32Full(szTmp, 0, &cHistory); + AssertMsgReturn(RT_SUCCESS(rc) && cHistory < _1M, ("Invalid history value %s (%Rrc)!\n", szTmp, rc), rc); + pLoggerInt->cHistory = cHistory; + } + else + pLoggerInt->cHistory = 0; + } + else if (i == 3 /* histsize */) + { + if (!fNo) + { + int rc = RTStrCopyEx(szTmp, sizeof(szTmp), pszValue, cch); + if (RT_SUCCESS(rc)) + rc = RTStrToUInt64Full(szTmp, 0, &pLoggerInt->cbHistoryFileMax); + AssertMsgRCReturn(rc, ("Invalid history file size value %s (%Rrc)!\n", szTmp, rc), rc); + if (pLoggerInt->cbHistoryFileMax == 0) + pLoggerInt->cbHistoryFileMax = UINT64_MAX; + } + else + pLoggerInt->cbHistoryFileMax = UINT64_MAX; + } + else if (i == 4 /* histtime */) + { + if (!fNo) + { + int rc = RTStrCopyEx(szTmp, sizeof(szTmp), pszValue, cch); + if (RT_SUCCESS(rc)) + rc = RTStrToUInt32Full(szTmp, 0, &pLoggerInt->cSecsHistoryTimeSlot); + AssertMsgRCReturn(rc, ("Invalid history time slot value %s (%Rrc)!\n", szTmp, rc), rc); + if (pLoggerInt->cSecsHistoryTimeSlot == 0) + pLoggerInt->cSecsHistoryTimeSlot = UINT32_MAX; + } + else + pLoggerInt->cSecsHistoryTimeSlot = UINT32_MAX; + } +# endif /* IN_RING3 */ + else if (i == 5 /* ringbuf */ && !fNo) + { + int rc = RTStrCopyEx(szTmp, sizeof(szTmp), pszValue, cch); + uint32_t cbRingBuf = 0; + if (RT_SUCCESS(rc)) + rc = RTStrToUInt32Full(szTmp, 0, &cbRingBuf); + AssertMsgRCReturn(rc, ("Invalid ring buffer size value '%s' (%Rrc)!\n", szTmp, rc), rc); + + if (cbRingBuf == 0) + cbRingBuf = RTLOG_RINGBUF_DEFAULT_SIZE; + else if (cbRingBuf < RTLOG_RINGBUF_MIN_SIZE) + cbRingBuf = RTLOG_RINGBUF_MIN_SIZE; + else if (cbRingBuf > RTLOG_RINGBUF_MAX_SIZE) + cbRingBuf = RTLOG_RINGBUF_MAX_SIZE; + else + cbRingBuf = RT_ALIGN_32(cbRingBuf, 64); + rc = rtLogRingBufAdjust(pLoggerInt, cbRingBuf, false /*fForce*/); + if (RT_FAILURE(rc)) + return rc; + } + else + AssertMsgFailedReturn(("Invalid destination value! %s%s doesn't take a value!\n", + fNo ? "no" : "", g_aLogDst[i].pszInstr), + VERR_INVALID_PARAMETER); + + pszValue = pszEnd + (*pszEnd != '\0'); + } + else if (i == 5 /* ringbuf */ && !fNo && !pLoggerInt->pszRingBuf) + { + int rc = rtLogRingBufAdjust(pLoggerInt, pLoggerInt->cbRingBuf, false /*fForce*/); + if (RT_FAILURE(rc)) + return rc; + } + break; + } + } + + /* assert known instruction */ + AssertMsgReturn(i < RT_ELEMENTS(g_aLogDst), + ("Invalid destination value! unknown instruction %.20s\n", pszValue), + VERR_INVALID_PARAMETER); + + /* skip blanks and delimiters. */ + while (RT_C_IS_SPACE(*pszValue) || *pszValue == ';') + pszValue++; + } /* while more environment variable value left */ + + return VINF_SUCCESS; +} +RT_EXPORT_SYMBOL(RTLogDestinations); + + +RTDECL(int) RTLogClearFileDelayFlag(PRTLOGGER pLogger, PRTERRINFO pErrInfo) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + + /* + * Do the work. + */ + int rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + if (pLoggerInt->fDestFlags & RTLOGDEST_F_DELAY_FILE) + { + pLoggerInt->fDestFlags &= ~RTLOGDEST_F_DELAY_FILE; +# ifdef IN_RING3 + if ( pLoggerInt->fDestFlags & RTLOGDEST_FILE + && !pLoggerInt->fLogOpened) + { + rc = rtR3LogOpenFileDestination(pLoggerInt, pErrInfo); + if (RT_SUCCESS(rc)) + rtlogFlush(pLoggerInt, false /*fNeedSpace*/); + } +# endif + RT_NOREF(pErrInfo); /** @todo fix create API to use RTErrInfo */ + } + rtlogUnlock(pLoggerInt); + } + return VINF_SUCCESS; +} +RT_EXPORT_SYMBOL(RTLogClearFileDelayFlag); + + +RTDECL(int) RTLogChangeDestinations(PRTLOGGER pLogger, uint32_t fSet, uint32_t fClear) +{ + int rc; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + AssertCompile((RTLOG_DST_VALID_MASK & RTLOG_DST_CHANGE_MASK) == RTLOG_DST_CHANGE_MASK); + AssertReturn(!(fSet & ~RTLOG_DST_CHANGE_MASK), VERR_INVALID_FLAGS); + AssertReturn(!(fClear & ~RTLOG_DST_CHANGE_MASK), VERR_INVALID_FLAGS); + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + + /* + * Make the changes. + */ + rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + pLoggerInt->fDestFlags &= ~fClear; + pLoggerInt->fDestFlags |= fSet; + rtlogUnlock(pLoggerInt); + } + + return VINF_SUCCESS; +} +RT_EXPORT_SYMBOL(RTLogChangeDestinations); + + +RTDECL(uint32_t) RTLogGetDestinations(PRTLOGGER pLogger) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + if (!pLoggerInt) + { + pLoggerInt = (PRTLOGGERINTERNAL)RTLogDefaultInstance(); + if (!pLoggerInt) + return UINT32_MAX; + } + return pLoggerInt->fDestFlags; +} +RT_EXPORT_SYMBOL(RTLogGetDestinations); + + +RTDECL(int) RTLogQueryDestinations(PRTLOGGER pLogger, char *pszBuf, size_t cchBuf) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + bool fNotFirst = false; + int rc = VINF_SUCCESS; + uint32_t fDestFlags; + unsigned i; + + AssertReturn(cchBuf, VERR_INVALID_PARAMETER); + *pszBuf = '\0'; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + Assert(pLoggerInt->Core.u32Magic == RTLOGGER_MAGIC); + + /* + * Add the flags in the list. + */ + fDestFlags = pLoggerInt->fDestFlags; + for (i = 6; i < RT_ELEMENTS(g_aLogDst); i++) + if (g_aLogDst[i].fFlag & fDestFlags) + { + if (fNotFirst) + { + rc = RTStrCopyP(&pszBuf, &cchBuf, " "); + if (RT_FAILURE(rc)) + return rc; + } + rc = RTStrCopyP(&pszBuf, &cchBuf, g_aLogDst[i].pszInstr); + if (RT_FAILURE(rc)) + return rc; + fNotFirst = true; + } + + char szNum[32]; + +# ifdef IN_RING3 + /* + * Add the filename. + */ + if (fDestFlags & RTLOGDEST_FILE) + { + rc = RTStrCopyP(&pszBuf, &cchBuf, fNotFirst ? " file=" : "file="); + if (RT_FAILURE(rc)) + return rc; + rc = RTStrCopyP(&pszBuf, &cchBuf, pLoggerInt->szFilename); + if (RT_FAILURE(rc)) + return rc; + fNotFirst = true; + + if (pLoggerInt->cHistory) + { + RTStrPrintf(szNum, sizeof(szNum), fNotFirst ? " history=%u" : "history=%u", pLoggerInt->cHistory); + rc = RTStrCopyP(&pszBuf, &cchBuf, szNum); + if (RT_FAILURE(rc)) + return rc; + fNotFirst = true; + } + if (pLoggerInt->cbHistoryFileMax != UINT64_MAX) + { + RTStrPrintf(szNum, sizeof(szNum), fNotFirst ? " histsize=%llu" : "histsize=%llu", pLoggerInt->cbHistoryFileMax); + rc = RTStrCopyP(&pszBuf, &cchBuf, szNum); + if (RT_FAILURE(rc)) + return rc; + fNotFirst = true; + } + if (pLoggerInt->cSecsHistoryTimeSlot != UINT32_MAX) + { + RTStrPrintf(szNum, sizeof(szNum), fNotFirst ? " histtime=%llu" : "histtime=%llu", pLoggerInt->cSecsHistoryTimeSlot); + rc = RTStrCopyP(&pszBuf, &cchBuf, szNum); + if (RT_FAILURE(rc)) + return rc; + fNotFirst = true; + } + } +# endif /* IN_RING3 */ + + /* + * Add the ring buffer. + */ + if (fDestFlags & RTLOGDEST_RINGBUF) + { + if (pLoggerInt->cbRingBuf == RTLOG_RINGBUF_DEFAULT_SIZE) + rc = RTStrCopyP(&pszBuf, &cchBuf, fNotFirst ? " ringbuf" : "ringbuf"); + else + { + RTStrPrintf(szNum, sizeof(szNum), fNotFirst ? " ringbuf=%#x" : "ringbuf=%#x", pLoggerInt->cbRingBuf); + rc = RTStrCopyP(&pszBuf, &cchBuf, szNum); + } + if (RT_FAILURE(rc)) + return rc; + fNotFirst = true; + } + + return VINF_SUCCESS; +} +RT_EXPORT_SYMBOL(RTLogQueryDestinations); + + +/** + * Helper for calculating the CRC32 of all the group names. + */ +static uint32_t rtLogCalcGroupNameCrc32(PRTLOGGERINTERNAL pLoggerInt) +{ + const char * const * const papszGroups = pLoggerInt->papszGroups; + uint32_t iGroup = pLoggerInt->cGroups; + uint32_t uCrc32 = RTCrc32Start(); + while (iGroup-- > 0) + { + const char *pszGroup = papszGroups[iGroup]; + uCrc32 = RTCrc32Process(uCrc32, pszGroup, strlen(pszGroup) + 1); + } + return RTCrc32Finish(uCrc32); +} + +#ifdef IN_RING3 + +/** + * Opens/creates the log file. + * + * @param pLoggerInt The logger instance to update. NULL is not allowed! + * @param pErrInfo Where to return extended error information. + * Optional. + */ +static int rtlogFileOpen(PRTLOGGERINTERNAL pLoggerInt, PRTERRINFO pErrInfo) +{ + uint32_t fOpen = RTFILE_O_WRITE | RTFILE_O_DENY_NONE; + if (pLoggerInt->fFlags & RTLOGFLAGS_APPEND) + fOpen |= RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND; + else + { + pLoggerInt->pOutputIf->pfnDelete(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, + pLoggerInt->szFilename); + fOpen |= RTFILE_O_CREATE; + } + if (pLoggerInt->fFlags & RTLOGFLAGS_WRITE_THROUGH) + fOpen |= RTFILE_O_WRITE_THROUGH; + if (pLoggerInt->fDestFlags & RTLOGDEST_F_NO_DENY) + fOpen = (fOpen & ~RTFILE_O_DENY_NONE) | RTFILE_O_DENY_NOT_DELETE; + + unsigned cBackoff = 0; + int rc = pLoggerInt->pOutputIf->pfnOpen(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, + pLoggerInt->szFilename, fOpen); + while ( ( rc == VERR_SHARING_VIOLATION + || (rc == VERR_ALREADY_EXISTS && !(pLoggerInt->fFlags & RTLOGFLAGS_APPEND))) + && cBackoff < RT_ELEMENTS(g_acMsLogBackoff)) + { + RTThreadSleep(g_acMsLogBackoff[cBackoff++]); + if (!(pLoggerInt->fFlags & RTLOGFLAGS_APPEND)) + pLoggerInt->pOutputIf->pfnDelete(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, + pLoggerInt->szFilename); + rc = pLoggerInt->pOutputIf->pfnOpen(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, + pLoggerInt->szFilename, fOpen); + } + if (RT_SUCCESS(rc)) + { + pLoggerInt->fLogOpened = true; + + rc = pLoggerInt->pOutputIf->pfnQuerySize(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, + &pLoggerInt->cbHistoryFileWritten); + if (RT_FAILURE(rc)) + { + /* Don't complain if this fails, assume the file is empty. */ + pLoggerInt->cbHistoryFileWritten = 0; + rc = VINF_SUCCESS; + } + } + else + { + pLoggerInt->fLogOpened = false; + RTErrInfoSetF(pErrInfo, rc, N_("could not open file '%s' (fOpen=%#x)"), pLoggerInt->szFilename, fOpen); + } + return rc; +} + + +/** + * Closes, rotates and opens the log files if necessary. + * + * Used by the rtlogFlush() function as well as RTLogCreateExV() by way of + * rtR3LogOpenFileDestination(). + * + * @param pLoggerInt The logger instance to update. NULL is not allowed! + * @param uTimeSlot Current time slot (for tikme based rotation). + * @param fFirst Flag whether this is the beginning of logging, i.e. + * called from RTLogCreateExV. Prevents pfnPhase from + * being called. + * @param pErrInfo Where to return extended error information. Optional. + */ +static void rtlogRotate(PRTLOGGERINTERNAL pLoggerInt, uint32_t uTimeSlot, bool fFirst, PRTERRINFO pErrInfo) +{ + /* Suppress rotating empty log files simply because the time elapsed. */ + if (RT_UNLIKELY(!pLoggerInt->cbHistoryFileWritten)) + pLoggerInt->uHistoryTimeSlotStart = uTimeSlot; + + /* Check rotation condition: file still small enough and not too old? */ + if (RT_LIKELY( pLoggerInt->cbHistoryFileWritten < pLoggerInt->cbHistoryFileMax + && uTimeSlot == pLoggerInt->uHistoryTimeSlotStart)) + return; + + /* + * Save "disabled" log flag and make sure logging is disabled. + * The logging in the functions called during log file history + * rotation would cause severe trouble otherwise. + */ + uint32_t const fSavedFlags = pLoggerInt->fFlags; + pLoggerInt->fFlags |= RTLOGFLAGS_DISABLED; + + /* + * Disable log rotation temporarily, otherwise with extreme settings and + * chatty phase logging we could run into endless rotation. + */ + uint32_t const cSavedHistory = pLoggerInt->cHistory; + pLoggerInt->cHistory = 0; + + /* + * Close the old log file. + */ + if (pLoggerInt->fLogOpened) + { + /* Use the callback to generate some final log contents, but only if + * this is a rotation with a fully set up logger. Leave the other case + * to the RTLogCreateExV function. */ + if (pLoggerInt->pfnPhase && !fFirst) + { + uint32_t fODestFlags = pLoggerInt->fDestFlags; + pLoggerInt->fDestFlags &= RTLOGDEST_FILE; + pLoggerInt->pfnPhase(&pLoggerInt->Core, RTLOGPHASE_PREROTATE, rtlogPhaseMsgLocked); + pLoggerInt->fDestFlags = fODestFlags; + } + + pLoggerInt->pOutputIf->pfnClose(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser); + } + + if (cSavedHistory) + { + /* + * Rotate the log files. + */ + for (uint32_t i = cSavedHistory - 1; i + 1 > 0; i--) + { + char szOldName[sizeof(pLoggerInt->szFilename) + 32]; + if (i > 0) + RTStrPrintf(szOldName, sizeof(szOldName), "%s.%u", pLoggerInt->szFilename, i); + else + RTStrCopy(szOldName, sizeof(szOldName), pLoggerInt->szFilename); + + char szNewName[sizeof(pLoggerInt->szFilename) + 32]; + RTStrPrintf(szNewName, sizeof(szNewName), "%s.%u", pLoggerInt->szFilename, i + 1); + + unsigned cBackoff = 0; + int rc = pLoggerInt->pOutputIf->pfnRename(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, + szOldName, szNewName, RTFILEMOVE_FLAGS_REPLACE); + while ( rc == VERR_SHARING_VIOLATION + && cBackoff < RT_ELEMENTS(g_acMsLogBackoff)) + { + RTThreadSleep(g_acMsLogBackoff[cBackoff++]); + rc = pLoggerInt->pOutputIf->pfnRename(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, + szOldName, szNewName, RTFILEMOVE_FLAGS_REPLACE); + } + + if (rc == VERR_FILE_NOT_FOUND) + pLoggerInt->pOutputIf->pfnDelete(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, szNewName); + } + + /* + * Delete excess log files. + */ + for (uint32_t i = cSavedHistory + 1; ; i++) + { + char szExcessName[sizeof(pLoggerInt->szFilename) + 32]; + RTStrPrintf(szExcessName, sizeof(szExcessName), "%s.%u", pLoggerInt->szFilename, i); + int rc = pLoggerInt->pOutputIf->pfnDelete(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, szExcessName); + if (RT_FAILURE(rc)) + break; + } + } + + /* + * Update logger state and create new log file. + */ + pLoggerInt->cbHistoryFileWritten = 0; + pLoggerInt->uHistoryTimeSlotStart = uTimeSlot; + rtlogFileOpen(pLoggerInt, pErrInfo); + + /* + * Use the callback to generate some initial log contents, but only if this + * is a rotation with a fully set up logger. Leave the other case to the + * RTLogCreateExV function. + */ + if (pLoggerInt->pfnPhase && !fFirst) + { + uint32_t const fSavedDestFlags = pLoggerInt->fDestFlags; + pLoggerInt->fDestFlags &= RTLOGDEST_FILE; + pLoggerInt->pfnPhase(&pLoggerInt->Core, RTLOGPHASE_POSTROTATE, rtlogPhaseMsgLocked); + pLoggerInt->fDestFlags = fSavedDestFlags; + } + + /* Restore saved values. */ + pLoggerInt->cHistory = cSavedHistory; + pLoggerInt->fFlags = fSavedFlags; +} + + +/** + * Worker for RTLogCreateExV and RTLogClearFileDelayFlag. + * + * This will later be used to reopen the file by RTLogDestinations. + * + * @returns IPRT status code. + * @param pLoggerInt The logger. + * @param pErrInfo Where to return extended error information. + * Optional. + */ +static int rtR3LogOpenFileDestination(PRTLOGGERINTERNAL pLoggerInt, PRTERRINFO pErrInfo) +{ + int rc; + if (pLoggerInt->fFlags & RTLOGFLAGS_APPEND) + { + rc = rtlogFileOpen(pLoggerInt, pErrInfo); + + /* Rotate in case of appending to a too big log file, + otherwise this simply doesn't do anything. */ + rtlogRotate(pLoggerInt, 0, true /* fFirst */, pErrInfo); + } + else + { + /* Force rotation if it is configured. */ + pLoggerInt->cbHistoryFileWritten = UINT64_MAX; + rtlogRotate(pLoggerInt, 0, true /* fFirst */, pErrInfo); + + /* If the file is not open then rotation is not set up. */ + if (!pLoggerInt->fLogOpened) + { + pLoggerInt->cbHistoryFileWritten = 0; + rc = rtlogFileOpen(pLoggerInt, pErrInfo); + } + else + rc = VINF_SUCCESS; + } + return rc; +} + +#endif /* IN_RING3 */ + + +/********************************************************************************************************************************* +* Bulk Reconfig & Logging for ring-0 EMT loggers. * +*********************************************************************************************************************************/ + +RTDECL(int) RTLogBulkUpdate(PRTLOGGER pLogger, uint64_t fFlags, uint32_t uGroupCrc32, uint32_t cGroups, uint32_t const *pafGroups) +{ + int rc; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + + /* + * Do the updating. + */ + rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + pLoggerInt->fFlags = fFlags; + if ( uGroupCrc32 == rtLogCalcGroupNameCrc32(pLoggerInt) + && pLoggerInt->cGroups == cGroups) + { + RT_BCOPY_UNFORTIFIED(pLoggerInt->afGroups, pafGroups, sizeof(pLoggerInt->afGroups[0]) * cGroups); + rc = VINF_SUCCESS; + } + else + rc = VERR_MISMATCH; + + rtlogUnlock(pLoggerInt); + } + return rc; +} +RT_EXPORT_SYMBOL(RTLogBulkUpdate); + + +RTDECL(int) RTLogQueryBulk(PRTLOGGER pLogger, uint64_t *pfFlags, uint32_t *puGroupCrc32, uint32_t *pcGroups, uint32_t *pafGroups) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + uint32_t const cGroupsAlloc = *pcGroups; + + *pfFlags = 0; + *puGroupCrc32 = 0; + *pcGroups = 0; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + AssertReturn(pLoggerInt->Core.u32Magic == RTLOGGER_MAGIC, VERR_INVALID_MAGIC); + + /* + * Get the data. + */ + *pfFlags = pLoggerInt->fFlags; + *pcGroups = pLoggerInt->cGroups; + if (cGroupsAlloc >= pLoggerInt->cGroups) + { + memcpy(pafGroups, pLoggerInt->afGroups, sizeof(pLoggerInt->afGroups[0]) * pLoggerInt->cGroups); + *puGroupCrc32 = rtLogCalcGroupNameCrc32(pLoggerInt); + return VINF_SUCCESS; + } + return VERR_BUFFER_OVERFLOW; +} +RT_EXPORT_SYMBOL(RTLogQueryBulk); + + +RTDECL(int) RTLogBulkWrite(PRTLOGGER pLogger, const char *pszBefore, const char *pch, size_t cch, const char *pszAfter) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + + /* + * Lock and validate it. + */ + int rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + if (cch > 0) + { + /* + * Heading/marker. + */ + if (pszBefore) + rtlogLoggerExFLocked(pLoggerInt, RTLOGGRPFLAGS_LEVEL_1, UINT32_MAX, "%s", pszBefore); + + /* + * Do the copying. + */ + do + { + PRTLOGBUFFERDESC const pBufDesc = pLoggerInt->pBufDesc; + char * const pchBuf = pBufDesc->pchBuf; + uint32_t const cbBuf = pBufDesc->cbBuf; + uint32_t offBuf = pBufDesc->offBuf; + if (cch + 1 < cbBuf - offBuf) + { + memcpy(&pchBuf[offBuf], pch, cch); + offBuf += (uint32_t)cch; + pchBuf[offBuf] = '\0'; + pBufDesc->offBuf = offBuf; + if (pBufDesc->pAux) + pBufDesc->pAux->offBuf = offBuf; + if (!(pLoggerInt->fDestFlags & RTLOGFLAGS_BUFFERED)) + rtlogFlush(pLoggerInt, false /*fNeedSpace*/); + break; + } + + /* Not enough space. */ + if (offBuf + 1 < cbBuf) + { + uint32_t cbToCopy = cbBuf - offBuf - 1; + memcpy(&pchBuf[offBuf], pch, cbToCopy); + offBuf += cbToCopy; + pchBuf[offBuf] = '\0'; + pBufDesc->offBuf = offBuf; + if (pBufDesc->pAux) + pBufDesc->pAux->offBuf = offBuf; + pch += cbToCopy; + cch -= cbToCopy; + } + + rtlogFlush(pLoggerInt, false /*fNeedSpace*/); + } while (cch > 0); + + /* + * Footer/marker. + */ + if (pszAfter) + rtlogLoggerExFLocked(pLoggerInt, RTLOGGRPFLAGS_LEVEL_1, UINT32_MAX, "%s", pszAfter); + } + + rtlogUnlock(pLoggerInt); + } + return rc; +} +RT_EXPORT_SYMBOL(RTLogBulkWrite); + + +RTDECL(int) RTLogBulkNestedWrite(PRTLOGGER pLogger, const char *pch, size_t cch, const char *pszInfix) +{ + if (cch > 0) + { + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + + /* + * Lock and validate it. + */ + int rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + /* + * If we've got an auxilary descriptor, check if the buffer was flushed. + */ + PRTLOGBUFFERDESC pBufDesc = pLoggerInt->pBufDesc; + PRTLOGBUFFERAUXDESC pAuxDesc = pBufDesc->pAux; + if (!pAuxDesc || !pAuxDesc->fFlushedIndicator) + { /* likely, except maybe for ring-0 */ } + else + { + pAuxDesc->fFlushedIndicator = false; + pBufDesc->offBuf = 0; + } + + /* + * Write the stuff. + */ + RTLOGOUTPUTPREFIXEDARGS Args; + Args.pLoggerInt = pLoggerInt; + Args.fFlags = 0; + Args.iGroup = ~0U; + Args.pszInfix = pszInfix; + rtLogOutputPrefixed(&Args, pch, cch); + rtLogOutputPrefixed(&Args, pch, 0); /* termination call */ + + /* + * Maybe flush the buffer and update the auxiliary descriptor if there is one. + */ + pBufDesc = pLoggerInt->pBufDesc; /* (the descriptor may have changed) */ + if ( !(pLoggerInt->fFlags & RTLOGFLAGS_BUFFERED) + && pBufDesc->offBuf) + rtlogFlush(pLoggerInt, false /*fNeedSpace*/); + else + { + pAuxDesc = pBufDesc->pAux; + if (pAuxDesc) + pAuxDesc->offBuf = pBufDesc->offBuf; + } + + rtlogUnlock(pLoggerInt); + } + return rc; + } + return VINF_SUCCESS; +} +RT_EXPORT_SYMBOL(RTLogBulkNestedWrite); + + +/********************************************************************************************************************************* +* Flushing * +*********************************************************************************************************************************/ + +RTDECL(int) RTLogFlush(PRTLOGGER pLogger) +{ + if (!pLogger) + { + pLogger = rtLogGetDefaultInstanceCommon(); /* Get it if it exists, do _not_ create one if it doesn't. */ + if (!pLogger) + return VINF_LOG_NO_LOGGER; + } + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + Assert(pLoggerInt->Core.u32Magic == RTLOGGER_MAGIC); + AssertPtr(pLoggerInt->pBufDesc); + Assert(pLoggerInt->pBufDesc->u32Magic == RTLOGBUFFERDESC_MAGIC); + + /* + * Acquire logger instance sem. + */ + int rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + /* + * Any thing to flush? + */ + if ( pLoggerInt->pBufDesc->offBuf > 0 + || (pLoggerInt->fDestFlags & RTLOGDEST_RINGBUF)) + { + /* + * Call worker. + */ + rtlogFlush(pLoggerInt, false /*fNeedSpace*/); + + /* + * Since this is an explicit flush call, the ring buffer content should + * be flushed to the other destinations if active. + */ + if ( (pLoggerInt->fDestFlags & RTLOGDEST_RINGBUF) + && pLoggerInt->pszRingBuf /* paranoia */) + rtLogRingBufFlush(pLoggerInt); + } + + rtlogUnlock(pLoggerInt); + } + return rc; +} +RT_EXPORT_SYMBOL(RTLogFlush); + + +/** + * Writes the buffer to the given log device without checking for buffered + * data or anything. + * + * Used by the RTLogFlush() function. + * + * @param pLoggerInt The logger instance to write to. NULL is not allowed! + * @param fNeedSpace Set if the caller assumes space will be made available. + */ +static void rtlogFlush(PRTLOGGERINTERNAL pLoggerInt, bool fNeedSpace) +{ + PRTLOGBUFFERDESC pBufDesc = pLoggerInt->pBufDesc; + uint32_t cchToFlush = pBufDesc->offBuf; + char * pchToFlush = pBufDesc->pchBuf; + uint32_t const cbBuf = pBufDesc->cbBuf; + Assert(pBufDesc->u32Magic == RTLOGBUFFERDESC_MAGIC); + + NOREF(fNeedSpace); + if (cchToFlush == 0) + return; /* nothing to flush. */ + + AssertPtrReturnVoid(pchToFlush); + AssertReturnVoid(cbBuf > 0); + AssertMsgStmt(cchToFlush < cbBuf, ("%#x vs %#x\n", cchToFlush, cbBuf), cchToFlush = cbBuf - 1); + + /* + * If the ring buffer is active, the other destinations are only written + * to when the ring buffer is flushed by RTLogFlush(). + */ + if ( (pLoggerInt->fDestFlags & RTLOGDEST_RINGBUF) + && pLoggerInt->pszRingBuf /* paranoia */) + { + rtLogRingBufWrite(pLoggerInt, pchToFlush, cchToFlush); + + /* empty the buffer. */ + pBufDesc->offBuf = 0; + *pchToFlush = '\0'; + } + /* + * In file delay mode, we ignore flush requests except when we're full + * and the caller really needs some scratch space to get work done. + */ + else +#ifdef IN_RING3 + if (!(pLoggerInt->fDestFlags & RTLOGDEST_F_DELAY_FILE)) +#endif + { + /* Make sure the string is terminated. On Windows, RTLogWriteDebugger + will get upset if it isn't. */ + pchToFlush[cchToFlush] = '\0'; + + if (pLoggerInt->fDestFlags & RTLOGDEST_USER) + RTLogWriteUser(pchToFlush, cchToFlush); + +#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64) + if (pLoggerInt->fDestFlags & RTLOGDEST_VMM) + RTLogWriteVmm(pchToFlush, cchToFlush, false /*fReleaseLog*/); + + if (pLoggerInt->fDestFlags & RTLOGDEST_VMM_REL) + RTLogWriteVmm(pchToFlush, cchToFlush, true /*fReleaseLog*/); +#endif + + if (pLoggerInt->fDestFlags & RTLOGDEST_DEBUGGER) + RTLogWriteDebugger(pchToFlush, cchToFlush); + +#ifdef IN_RING3 + if ((pLoggerInt->fDestFlags & (RTLOGDEST_FILE | RTLOGDEST_RINGBUF)) == RTLOGDEST_FILE) + { + if (pLoggerInt->fLogOpened) + { + pLoggerInt->pOutputIf->pfnWrite(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser, + pchToFlush, cchToFlush, NULL /*pcbWritten*/); + if (pLoggerInt->fFlags & RTLOGFLAGS_FLUSH) + pLoggerInt->pOutputIf->pfnFlush(pLoggerInt->pOutputIf, pLoggerInt->pvOutputIfUser); + } + if (pLoggerInt->cHistory) + pLoggerInt->cbHistoryFileWritten += cchToFlush; + } +#endif + + if (pLoggerInt->fDestFlags & RTLOGDEST_STDOUT) + RTLogWriteStdOut(pchToFlush, cchToFlush); + + if (pLoggerInt->fDestFlags & RTLOGDEST_STDERR) + RTLogWriteStdErr(pchToFlush, cchToFlush); + +#if (defined(IN_RING0) || defined(IN_RC)) && !defined(LOG_NO_COM) + if (pLoggerInt->fDestFlags & RTLOGDEST_COM) + RTLogWriteCom(pchToFlush, cchToFlush); +#endif + + if (pLoggerInt->pfnFlush) + { + /* + * We have a custom flush callback. Before calling it we must make + * sure the aux descriptor is up to date. When we get back, we may + * need to switch to the next buffer if the current is being flushed + * asynchronously. This of course requires there to be more than one + * buffer. (The custom flush callback is responsible for making sure + * the next buffer isn't being flushed before returning.) + */ + if (pBufDesc->pAux) + pBufDesc->pAux->offBuf = cchToFlush; + if (!pLoggerInt->pfnFlush(&pLoggerInt->Core, pBufDesc)) + { + /* advance to the next buffer */ + Assert(pLoggerInt->cBufDescs > 1); + size_t idxBufDesc = pBufDesc - pLoggerInt->paBufDescs; + Assert(idxBufDesc < pLoggerInt->cBufDescs); + idxBufDesc = (idxBufDesc + 1) % pLoggerInt->cBufDescs; + pLoggerInt->idxBufDesc = (uint8_t)idxBufDesc; + pLoggerInt->pBufDesc = pBufDesc = &pLoggerInt->paBufDescs[idxBufDesc]; + pchToFlush = pBufDesc->pchBuf; + } + } + + /* Empty the buffer. */ + pBufDesc->offBuf = 0; + if (pBufDesc->pAux) + pBufDesc->pAux->offBuf = 0; + *pchToFlush = '\0'; + +#ifdef IN_RING3 + /* + * Rotate the log file if configured. Must be done after everything is + * flushed, since this will also use logging/flushing to write the header + * and footer messages. + */ + if ( pLoggerInt->cHistory > 0 + && (pLoggerInt->fDestFlags & RTLOGDEST_FILE)) + rtlogRotate(pLoggerInt, RTTimeProgramSecTS() / pLoggerInt->cSecsHistoryTimeSlot, false /*fFirst*/, NULL /*pErrInfo*/); +#endif + } +#ifdef IN_RING3 + else + { + /* + * Delay file open but the caller really need some space. So, give him half a + * buffer and insert a message indicating that we've dropped output. + */ + uint32_t offHalf = cbBuf / 2; + if (cchToFlush > offHalf) + { + static const char s_szDropMsgLf[] = "\n[DROP DROP DROP]\n"; + static const char s_szDropMsgCrLf[] = "\r\n[DROP DROP DROP]\r\n"; + if (!(pLoggerInt->fFlags & RTLOGFLAGS_USECRLF)) + { + memcpy(&pchToFlush[offHalf], RT_STR_TUPLE(s_szDropMsgLf)); + offHalf += sizeof(s_szDropMsgLf) - 1; + } + else + { + memcpy(&pchToFlush[offHalf], RT_STR_TUPLE(s_szDropMsgCrLf)); + offHalf += sizeof(s_szDropMsgCrLf) - 1; + } + pBufDesc->offBuf = offHalf; + } + } +#endif +} + + +/********************************************************************************************************************************* +* Logger Core * +*********************************************************************************************************************************/ + +#ifdef IN_RING0 + +/** + * For rtR0LogLoggerExFallbackOutput and rtR0LogLoggerExFallbackFlush. + */ +typedef struct RTR0LOGLOGGERFALLBACK +{ + /** The current scratch buffer offset. */ + uint32_t offScratch; + /** The destination flags. */ + uint32_t fDestFlags; + /** For ring buffer output. */ + PRTLOGGERINTERNAL pInt; + /** The scratch buffer. */ + char achScratch[80]; +} RTR0LOGLOGGERFALLBACK; +/** Pointer to RTR0LOGLOGGERFALLBACK which is used by + * rtR0LogLoggerExFallbackOutput. */ +typedef RTR0LOGLOGGERFALLBACK *PRTR0LOGLOGGERFALLBACK; + + +/** + * Flushes the fallback buffer. + * + * @param pThis The scratch buffer. + */ +static void rtR0LogLoggerExFallbackFlush(PRTR0LOGLOGGERFALLBACK pThis) +{ + if (!pThis->offScratch) + return; + + if ( (pThis->fDestFlags & RTLOGDEST_RINGBUF) + && pThis->pInt + && pThis->pInt->pszRingBuf /* paranoia */) + rtLogRingBufWrite(pThis->pInt, pThis->achScratch, pThis->offScratch); + else + { + if (pThis->fDestFlags & RTLOGDEST_USER) + RTLogWriteUser(pThis->achScratch, pThis->offScratch); + +# if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64) + if (pThis->fDestFlags & RTLOGDEST_VMM) + RTLogWriteVmm(pThis->achScratch, pThis->offScratch, false /*fReleaseLog*/); + + if (pThis->fDestFlags & RTLOGDEST_VMM_REL) + RTLogWriteVmm(pThis->achScratch, pThis->offScratch, true /*fReleaseLog*/); +# endif + + if (pThis->fDestFlags & RTLOGDEST_DEBUGGER) + RTLogWriteDebugger(pThis->achScratch, pThis->offScratch); + + if (pThis->fDestFlags & RTLOGDEST_STDOUT) + RTLogWriteStdOut(pThis->achScratch, pThis->offScratch); + + if (pThis->fDestFlags & RTLOGDEST_STDERR) + RTLogWriteStdErr(pThis->achScratch, pThis->offScratch); + +# ifndef LOG_NO_COM + if (pThis->fDestFlags & RTLOGDEST_COM) + RTLogWriteCom(pThis->achScratch, pThis->offScratch); +# endif + } + + /* empty the buffer. */ + pThis->offScratch = 0; +} + + +/** + * Callback for RTLogFormatV used by rtR0LogLoggerExFallback. + * See PFNLOGOUTPUT() for details. + */ +static DECLCALLBACK(size_t) rtR0LogLoggerExFallbackOutput(void *pv, const char *pachChars, size_t cbChars) +{ + PRTR0LOGLOGGERFALLBACK pThis = (PRTR0LOGLOGGERFALLBACK)pv; + if (cbChars) + { + size_t cbRet = 0; + for (;;) + { + /* how much */ + uint32_t cb = sizeof(pThis->achScratch) - pThis->offScratch - 1; /* minus 1 - for the string terminator. */ + if (cb > cbChars) + cb = (uint32_t)cbChars; + + /* copy */ + memcpy(&pThis->achScratch[pThis->offScratch], pachChars, cb); + + /* advance */ + pThis->offScratch += cb; + cbRet += cb; + cbChars -= cb; + + /* done? */ + if (cbChars <= 0) + return cbRet; + + pachChars += cb; + + /* flush */ + pThis->achScratch[pThis->offScratch] = '\0'; + rtR0LogLoggerExFallbackFlush(pThis); + } + + /* won't ever get here! */ + } + else + { + /* + * Termination call, flush the log. + */ + pThis->achScratch[pThis->offScratch] = '\0'; + rtR0LogLoggerExFallbackFlush(pThis); + return 0; + } +} + + +/** + * Ring-0 fallback for cases where we're unable to grab the lock. + * + * This will happen when we're at a too high IRQL on Windows for instance and + * needs to be dealt with or we'll drop a lot of log output. This fallback will + * only output to some of the log destinations as a few of them may be doing + * dangerous things. We won't be doing any prefixing here either, at least not + * for the present, because it's too much hassle. + * + * @param fDestFlags The destination flags. + * @param fFlags The logger flags. + * @param pInt The internal logger data, for ring buffer output. + * @param pszFormat The format string. + * @param va The format arguments. + */ +static void rtR0LogLoggerExFallback(uint32_t fDestFlags, uint32_t fFlags, PRTLOGGERINTERNAL pInt, + const char *pszFormat, va_list va) +{ + RTR0LOGLOGGERFALLBACK This; + This.fDestFlags = fDestFlags; + This.pInt = pInt; + + /* fallback indicator. */ + This.offScratch = 2; + This.achScratch[0] = '['; + This.achScratch[1] = 'F'; + + /* selected prefixes */ + if (fFlags & RTLOGFLAGS_PREFIX_PID) + { + RTPROCESS Process = RTProcSelf(); + This.achScratch[This.offScratch++] = ' '; + This.offScratch += RTStrFormatNumber(&This.achScratch[This.offScratch], Process, 16, sizeof(RTPROCESS) * 2, 0, RTSTR_F_ZEROPAD); + } + if (fFlags & RTLOGFLAGS_PREFIX_TID) + { + RTNATIVETHREAD Thread = RTThreadNativeSelf(); + This.achScratch[This.offScratch++] = ' '; + This.offScratch += RTStrFormatNumber(&This.achScratch[This.offScratch], Thread, 16, sizeof(RTNATIVETHREAD) * 2, 0, RTSTR_F_ZEROPAD); + } + + This.achScratch[This.offScratch++] = ']'; + This.achScratch[This.offScratch++] = ' '; + + RTLogFormatV(rtR0LogLoggerExFallbackOutput, &This, pszFormat, va); +} + +#endif /* IN_RING0 */ + + +/** + * Callback for RTLogFormatV which writes to the com port. + * See PFNLOGOUTPUT() for details. + */ +static DECLCALLBACK(size_t) rtLogOutput(void *pv, const char *pachChars, size_t cbChars) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pv; + if (cbChars) + { + size_t cbRet = 0; + for (;;) + { + PRTLOGBUFFERDESC const pBufDesc = pLoggerInt->pBufDesc; + if (pBufDesc->offBuf < pBufDesc->cbBuf) + { + /* how much */ + char *pchBuf = pBufDesc->pchBuf; + uint32_t offBuf = pBufDesc->offBuf; + size_t cb = pBufDesc->cbBuf - offBuf - 1; + if (cb > cbChars) + cb = cbChars; + + switch (cb) + { + default: + memcpy(&pchBuf[offBuf], pachChars, cb); + pBufDesc->offBuf = offBuf + (uint32_t)cb; + cbRet += cb; + cbChars -= cb; + if (cbChars <= 0) + return cbRet; + pachChars += cb; + break; + + case 1: + pchBuf[offBuf] = pachChars[0]; + pBufDesc->offBuf = offBuf + 1; + if (cbChars == 1) + return cbRet + 1; + cbChars -= 1; + pachChars += 1; + break; + + case 2: + pchBuf[offBuf] = pachChars[0]; + pchBuf[offBuf + 1] = pachChars[1]; + pBufDesc->offBuf = offBuf + 2; + if (cbChars == 2) + return cbRet + 2; + cbChars -= 2; + pachChars += 2; + break; + + case 3: + pchBuf[offBuf] = pachChars[0]; + pchBuf[offBuf + 1] = pachChars[1]; + pchBuf[offBuf + 2] = pachChars[2]; + pBufDesc->offBuf = offBuf + 3; + if (cbChars == 3) + return cbRet + 3; + cbChars -= 3; + pachChars += 3; + break; + } + + } +#if defined(RT_STRICT) && defined(IN_RING3) + else + { +# ifndef IPRT_NO_CRT + fprintf(stderr, "pBufDesc->offBuf >= pBufDesc->cbBuf (%#x >= %#x)\n", pBufDesc->offBuf, pBufDesc->cbBuf); +# else + RTLogWriteStdErr(RT_STR_TUPLE("pBufDesc->offBuf >= pBufDesc->cbBuf\n")); +# endif + AssertBreakpoint(); AssertBreakpoint(); + } +#endif + + /* flush */ + rtlogFlush(pLoggerInt, true /*fNeedSpace*/); + } + + /* won't ever get here! */ + } + else + { + /* + * Termination call. + * There's always space for a terminator, and it's not counted. + */ + PRTLOGBUFFERDESC const pBufDesc = pLoggerInt->pBufDesc; + pBufDesc->pchBuf[RT_MIN(pBufDesc->offBuf, pBufDesc->cbBuf - 1)] = '\0'; + return 0; + } +} + + +/** + * stpncpy implementation for use in rtLogOutputPrefixed w/ padding. + * + * @returns Pointer to the destination buffer byte following the copied string. + * @param pszDst The destination buffer. + * @param pszSrc The source string. + * @param cchSrcMax The maximum number of characters to copy from + * the string. + * @param cchMinWidth The minimum field with, padd with spaces to + * reach this. + */ +DECLINLINE(char *) rtLogStPNCpyPad(char *pszDst, const char *pszSrc, size_t cchSrcMax, size_t cchMinWidth) +{ + size_t cchSrc = 0; + if (pszSrc) + { + cchSrc = strlen(pszSrc); + if (cchSrc > cchSrcMax) + cchSrc = cchSrcMax; + + memcpy(pszDst, pszSrc, cchSrc); + pszDst += cchSrc; + } + do + *pszDst++ = ' '; + while (cchSrc++ < cchMinWidth); + + return pszDst; +} + + +/** + * stpncpy implementation for use in rtLogOutputPrefixed w/ padding. + * + * @returns Pointer to the destination buffer byte following the copied string. + * @param pszDst The destination buffer. + * @param pszSrc The source string. + * @param cchSrc The number of characters to copy from the + * source. Equal or less than string length. + * @param cchMinWidth The minimum field with, padd with spaces to + * reach this. + */ +DECLINLINE(char *) rtLogStPNCpyPad2(char *pszDst, const char *pszSrc, size_t cchSrc, size_t cchMinWidth) +{ + Assert(pszSrc); + Assert(strlen(pszSrc) >= cchSrc); + + memcpy(pszDst, pszSrc, cchSrc); + pszDst += cchSrc; + do + *pszDst++ = ' '; + while (cchSrc++ < cchMinWidth); + + return pszDst; +} + + + +/** + * Callback for RTLogFormatV which writes to the logger instance. + * This version supports prefixes. + * + * See PFNLOGOUTPUT() for details. + */ +static DECLCALLBACK(size_t) rtLogOutputPrefixed(void *pv, const char *pachChars, size_t cbChars) +{ + PRTLOGOUTPUTPREFIXEDARGS pArgs = (PRTLOGOUTPUTPREFIXEDARGS)pv; + PRTLOGGERINTERNAL pLoggerInt = pArgs->pLoggerInt; + if (cbChars) + { + uint64_t const fFlags = pLoggerInt->fFlags; + size_t cbRet = 0; + for (;;) + { + PRTLOGBUFFERDESC const pBufDesc = pLoggerInt->pBufDesc; + char * const pchBuf = pBufDesc->pchBuf; + uint32_t const cbBuf = pBufDesc->cbBuf; + uint32_t offBuf = pBufDesc->offBuf; + size_t cb = cbBuf - offBuf - 1; + const char *pszNewLine; + char *psz; + +#if defined(RT_STRICT) && defined(IN_RING3) + /* sanity */ + if (offBuf < cbBuf) + { /* likely */ } + else + { +# ifndef IPRT_NO_CRT + fprintf(stderr, "offBuf >= cbBuf (%#x >= %#x)\n", offBuf, cbBuf); +# else + RTLogWriteStdErr(RT_STR_TUPLE("offBuf >= cbBuf\n")); +# endif + AssertBreakpoint(); AssertBreakpoint(); + } +#endif + + /* + * Pending prefix? + */ + if (pLoggerInt->fPendingPrefix) + { + /* + * Flush the buffer if there isn't enough room for the maximum prefix config. + * Max is 265, add a couple of extra bytes. See CCH_PREFIX check way below. + */ + if (cb >= 265 + 16) + pLoggerInt->fPendingPrefix = false; + else + { + rtlogFlush(pLoggerInt, true /*fNeedSpace*/); + continue; + } + + /* + * Write the prefixes. + * psz is pointing to the current position. + */ + psz = &pchBuf[offBuf]; + if (fFlags & RTLOGFLAGS_PREFIX_TS) + { + uint64_t u64 = RTTimeNanoTS(); + int iBase = 16; + unsigned int fStrFlags = RTSTR_F_ZEROPAD; + if (fFlags & RTLOGFLAGS_DECIMAL_TS) + { + iBase = 10; + fStrFlags = 0; + } + if (fFlags & RTLOGFLAGS_REL_TS) + { + static volatile uint64_t s_u64LastTs; + uint64_t u64DiffTs = u64 - s_u64LastTs; + s_u64LastTs = u64; + /* We could have been preempted just before reading of s_u64LastTs by + * another thread which wrote s_u64LastTs. In that case the difference + * is negative which we simply ignore. */ + u64 = (int64_t)u64DiffTs < 0 ? 0 : u64DiffTs; + } + /* 1E15 nanoseconds = 11 days */ + psz += RTStrFormatNumber(psz, u64, iBase, 16, 0, fStrFlags); + *psz++ = ' '; + } +#define CCH_PREFIX_01 0 + 17 + + if (fFlags & RTLOGFLAGS_PREFIX_TSC) + { +#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86) + uint64_t u64 = ASMReadTSC(); +#else + uint64_t u64 = RTTimeNanoTS(); +#endif + int iBase = 16; + unsigned int fStrFlags = RTSTR_F_ZEROPAD; + if (fFlags & RTLOGFLAGS_DECIMAL_TS) + { + iBase = 10; + fStrFlags = 0; + } + if (fFlags & RTLOGFLAGS_REL_TS) + { + static volatile uint64_t s_u64LastTsc; + int64_t i64DiffTsc = u64 - s_u64LastTsc; + s_u64LastTsc = u64; + /* We could have been preempted just before reading of s_u64LastTsc by + * another thread which wrote s_u64LastTsc. In that case the difference + * is negative which we simply ignore. */ + u64 = i64DiffTsc < 0 ? 0 : i64DiffTsc; + } + /* 1E15 ticks at 4GHz = 69 hours */ + psz += RTStrFormatNumber(psz, u64, iBase, 16, 0, fStrFlags); + *psz++ = ' '; + } +#define CCH_PREFIX_02 CCH_PREFIX_01 + 17 + + if (fFlags & RTLOGFLAGS_PREFIX_MS_PROG) + { +#ifndef IN_RING0 + uint64_t u64 = RTTimeProgramMilliTS(); +#else + uint64_t u64 = (RTTimeNanoTS() - pLoggerInt->nsR0ProgramStart) / RT_NS_1MS; +#endif + /* 1E8 milliseconds = 27 hours */ + psz += RTStrFormatNumber(psz, u64, 10, 9, 0, RTSTR_F_ZEROPAD); + *psz++ = ' '; + } +#define CCH_PREFIX_03 CCH_PREFIX_02 + 21 + + if (fFlags & RTLOGFLAGS_PREFIX_TIME) + { +#if defined(IN_RING3) || defined(IN_RING0) + RTTIMESPEC TimeSpec; + RTTIME Time; + RTTimeExplode(&Time, RTTimeNow(&TimeSpec)); + psz += RTStrFormatNumber(psz, Time.u8Hour, 10, 2, 0, RTSTR_F_ZEROPAD); + *psz++ = ':'; + psz += RTStrFormatNumber(psz, Time.u8Minute, 10, 2, 0, RTSTR_F_ZEROPAD); + *psz++ = ':'; + psz += RTStrFormatNumber(psz, Time.u8Second, 10, 2, 0, RTSTR_F_ZEROPAD); + *psz++ = '.'; + psz += RTStrFormatNumber(psz, Time.u32Nanosecond / 1000, 10, 6, 0, RTSTR_F_ZEROPAD); + *psz++ = ' '; +#else + memset(psz, ' ', 16); + psz += 16; +#endif + } +#define CCH_PREFIX_04 CCH_PREFIX_03 + (3+1+3+1+3+1+7+1) + + if (fFlags & RTLOGFLAGS_PREFIX_TIME_PROG) + { + +#ifndef IN_RING0 + uint64_t u64 = RTTimeProgramMicroTS(); +#else + uint64_t u64 = (RTTimeNanoTS() - pLoggerInt->nsR0ProgramStart) / RT_NS_1US; + +#endif + psz += RTStrFormatNumber(psz, (uint32_t)(u64 / RT_US_1HOUR), 10, 2, 0, RTSTR_F_ZEROPAD); + *psz++ = ':'; + uint32_t u32 = (uint32_t)(u64 % RT_US_1HOUR); + psz += RTStrFormatNumber(psz, u32 / RT_US_1MIN, 10, 2, 0, RTSTR_F_ZEROPAD); + *psz++ = ':'; + u32 %= RT_US_1MIN; + + psz += RTStrFormatNumber(psz, u32 / RT_US_1SEC, 10, 2, 0, RTSTR_F_ZEROPAD); + *psz++ = '.'; + psz += RTStrFormatNumber(psz, u32 % RT_US_1SEC, 10, 6, 0, RTSTR_F_ZEROPAD); + *psz++ = ' '; + } +#define CCH_PREFIX_05 CCH_PREFIX_04 + (9+1+2+1+2+1+6+1) + +# if 0 + if (fFlags & RTLOGFLAGS_PREFIX_DATETIME) + { + char szDate[32]; + RTTIMESPEC Time; + RTTimeSpecToString(RTTimeNow(&Time), szDate, sizeof(szDate)); + size_t cch = strlen(szDate); + memcpy(psz, szDate, cch); + psz += cch; + *psz++ = ' '; + } +# define CCH_PREFIX_06 CCH_PREFIX_05 + 32 +# else +# define CCH_PREFIX_06 CCH_PREFIX_05 + 0 +# endif + + if (fFlags & RTLOGFLAGS_PREFIX_PID) + { + RTPROCESS Process = RTProcSelf(); + psz += RTStrFormatNumber(psz, Process, 16, sizeof(RTPROCESS) * 2, 0, RTSTR_F_ZEROPAD); + *psz++ = ' '; + } +#define CCH_PREFIX_07 CCH_PREFIX_06 + 9 + + if (fFlags & RTLOGFLAGS_PREFIX_TID) + { + RTNATIVETHREAD Thread = RTThreadNativeSelf(); + psz += RTStrFormatNumber(psz, Thread, 16, sizeof(RTNATIVETHREAD) * 2, 0, RTSTR_F_ZEROPAD); + *psz++ = ' '; + } +#define CCH_PREFIX_08 CCH_PREFIX_07 + 17 + + if (fFlags & RTLOGFLAGS_PREFIX_THREAD) + { +#ifdef IN_RING3 + const char *pszName = RTThreadSelfName(); +#elif defined IN_RC + const char *pszName = "EMT-RC"; +#else + const char *pszName = pLoggerInt->szR0ThreadName[0] ? pLoggerInt->szR0ThreadName : "R0"; +#endif + psz = rtLogStPNCpyPad(psz, pszName, 16, 8); + } +#define CCH_PREFIX_09 CCH_PREFIX_08 + 17 + + if (fFlags & RTLOGFLAGS_PREFIX_CPUID) + { +#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86) + const uint8_t idCpu = ASMGetApicId(); +#else + const RTCPUID idCpu = RTMpCpuId(); +#endif + psz += RTStrFormatNumber(psz, idCpu, 16, sizeof(idCpu) * 2, 0, RTSTR_F_ZEROPAD); + *psz++ = ' '; + } +#define CCH_PREFIX_10 CCH_PREFIX_09 + 17 + + if ( (fFlags & RTLOGFLAGS_PREFIX_CUSTOM) + && pLoggerInt->pfnPrefix) + { + psz += pLoggerInt->pfnPrefix(&pLoggerInt->Core, psz, 31, pLoggerInt->pvPrefixUserArg); + *psz++ = ' '; /* +32 */ + } +#define CCH_PREFIX_11 CCH_PREFIX_10 + 32 + + if (fFlags & RTLOGFLAGS_PREFIX_LOCK_COUNTS) + { +#ifdef IN_RING3 /** @todo implement these counters in ring-0 too? */ + RTTHREAD Thread = RTThreadSelf(); + if (Thread != NIL_RTTHREAD) + { + uint32_t cReadLocks = RTLockValidatorReadLockGetCount(Thread); + uint32_t cWriteLocks = RTLockValidatorWriteLockGetCount(Thread) - g_cLoggerLockCount; + cReadLocks = RT_MIN(0xfff, cReadLocks); + cWriteLocks = RT_MIN(0xfff, cWriteLocks); + psz += RTStrFormatNumber(psz, cReadLocks, 16, 1, 0, RTSTR_F_ZEROPAD); + *psz++ = '/'; + psz += RTStrFormatNumber(psz, cWriteLocks, 16, 1, 0, RTSTR_F_ZEROPAD); + } + else +#endif + { + *psz++ = '?'; + *psz++ = '/'; + *psz++ = '?'; + } + *psz++ = ' '; + } +#define CCH_PREFIX_12 CCH_PREFIX_11 + 8 + + if (fFlags & RTLOGFLAGS_PREFIX_FLAG_NO) + { + psz += RTStrFormatNumber(psz, pArgs->fFlags, 16, 8, 0, RTSTR_F_ZEROPAD); + *psz++ = ' '; + } +#define CCH_PREFIX_13 CCH_PREFIX_12 + 9 + + if (fFlags & RTLOGFLAGS_PREFIX_FLAG) + { +#ifdef IN_RING3 + const char *pszGroup = pArgs->iGroup != ~0U ? pLoggerInt->papszGroups[pArgs->iGroup] : NULL; +#else + const char *pszGroup = NULL; +#endif + psz = rtLogStPNCpyPad(psz, pszGroup, 16, 8); + } +#define CCH_PREFIX_14 CCH_PREFIX_13 + 17 + + if (fFlags & RTLOGFLAGS_PREFIX_GROUP_NO) + { + if (pArgs->iGroup != ~0U) + { + psz += RTStrFormatNumber(psz, pArgs->iGroup, 16, 3, 0, RTSTR_F_ZEROPAD); + *psz++ = ' '; + } + else + { + memcpy(psz, "-1 ", sizeof("-1 ") - 1); + psz += sizeof("-1 ") - 1; + } /* +9 */ + } +#define CCH_PREFIX_15 CCH_PREFIX_14 + 9 + + if (fFlags & RTLOGFLAGS_PREFIX_GROUP) + { + const unsigned fGrp = pLoggerInt->afGroups[pArgs->iGroup != ~0U ? pArgs->iGroup : 0]; + const char *pszGroup; + size_t cchGroup; + switch (pArgs->fFlags & fGrp) + { + case 0: pszGroup = "--------"; cchGroup = sizeof("--------") - 1; break; + case RTLOGGRPFLAGS_ENABLED: pszGroup = "enabled" ; cchGroup = sizeof("enabled" ) - 1; break; + case RTLOGGRPFLAGS_LEVEL_1: pszGroup = "level 1" ; cchGroup = sizeof("level 1" ) - 1; break; + case RTLOGGRPFLAGS_LEVEL_2: pszGroup = "level 2" ; cchGroup = sizeof("level 2" ) - 1; break; + case RTLOGGRPFLAGS_LEVEL_3: pszGroup = "level 3" ; cchGroup = sizeof("level 3" ) - 1; break; + case RTLOGGRPFLAGS_LEVEL_4: pszGroup = "level 4" ; cchGroup = sizeof("level 4" ) - 1; break; + case RTLOGGRPFLAGS_LEVEL_5: pszGroup = "level 5" ; cchGroup = sizeof("level 5" ) - 1; break; + case RTLOGGRPFLAGS_LEVEL_6: pszGroup = "level 6" ; cchGroup = sizeof("level 6" ) - 1; break; + case RTLOGGRPFLAGS_LEVEL_7: pszGroup = "level 7" ; cchGroup = sizeof("level 7" ) - 1; break; + case RTLOGGRPFLAGS_LEVEL_8: pszGroup = "level 8" ; cchGroup = sizeof("level 8" ) - 1; break; + case RTLOGGRPFLAGS_LEVEL_9: pszGroup = "level 9" ; cchGroup = sizeof("level 9" ) - 1; break; + case RTLOGGRPFLAGS_LEVEL_10: pszGroup = "level 10"; cchGroup = sizeof("level 10") - 1; break; + case RTLOGGRPFLAGS_LEVEL_11: pszGroup = "level 11"; cchGroup = sizeof("level 11") - 1; break; + case RTLOGGRPFLAGS_LEVEL_12: pszGroup = "level 12"; cchGroup = sizeof("level 12") - 1; break; + case RTLOGGRPFLAGS_FLOW: pszGroup = "flow" ; cchGroup = sizeof("flow" ) - 1; break; + case RTLOGGRPFLAGS_WARN: pszGroup = "warn" ; cchGroup = sizeof("warn" ) - 1; break; + default: pszGroup = "????????"; cchGroup = sizeof("????????") - 1; break; + } + psz = rtLogStPNCpyPad2(psz, pszGroup, RT_MIN(cchGroup, 16), 8); + } +#define CCH_PREFIX_16 CCH_PREFIX_15 + 17 + + if (pArgs->pszInfix) + { + size_t cchInfix = strlen(pArgs->pszInfix); + psz = rtLogStPNCpyPad2(psz, pArgs->pszInfix, RT_MIN(cchInfix, 8), 1); + } +#define CCH_PREFIX_17 CCH_PREFIX_16 + 9 + + +#define CCH_PREFIX ( CCH_PREFIX_17 ) + { AssertCompile(CCH_PREFIX < 265); } + + /* + * Done, figure what we've used and advance the buffer and free size. + */ + AssertMsg(psz - &pchBuf[offBuf] <= 223, + ("%#zx (%zd) - fFlags=%#x\n", psz - &pchBuf[offBuf], psz - &pchBuf[offBuf], fFlags)); + pBufDesc->offBuf = offBuf = (uint32_t)(psz - pchBuf); + cb = cbBuf - offBuf - 1; + } + else if (cb <= 2) /* 2 - Make sure we can write a \r\n and not loop forever. */ + { + rtlogFlush(pLoggerInt, true /*fNeedSpace*/); + continue; + } + + /* + * Done with the prefixing. Copy message text past the next newline. + */ + + /* how much */ + if (cb > cbChars) + cb = cbChars; + + /* have newline? */ + pszNewLine = (const char *)memchr(pachChars, '\n', cb); + if (pszNewLine) + { + cb = pszNewLine - pachChars; + if (!(fFlags & RTLOGFLAGS_USECRLF)) + { + cb += 1; + memcpy(&pchBuf[offBuf], pachChars, cb); + pLoggerInt->fPendingPrefix = true; + } + else if (cb + 2U < cbBuf - offBuf) + { + memcpy(&pchBuf[offBuf], pachChars, cb); + pchBuf[offBuf + cb++] = '\r'; + pchBuf[offBuf + cb++] = '\n'; + cbChars++; /* Discount the extra '\r'. */ + pachChars--; /* Ditto. */ + cbRet--; /* Ditto. */ + pLoggerInt->fPendingPrefix = true; + } + else + { + /* Insufficient buffer space, leave the '\n' for the next iteration. */ + memcpy(&pchBuf[offBuf], pachChars, cb); + } + } + else + memcpy(&pchBuf[offBuf], pachChars, cb); + + /* advance */ + pBufDesc->offBuf = offBuf += (uint32_t)cb; + cbRet += cb; + cbChars -= cb; + + /* done? */ + if (cbChars <= 0) + return cbRet; + pachChars += cb; + } + + /* won't ever get here! */ + } + else + { + /* + * Termination call. + * There's always space for a terminator, and it's not counted. + */ + PRTLOGBUFFERDESC const pBufDesc = pLoggerInt->pBufDesc; + pBufDesc->pchBuf[RT_MIN(pBufDesc->offBuf, pBufDesc->cbBuf - 1)] = '\0'; + return 0; + } +} + + +/** + * Write to a logger instance (worker function). + * + * 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 pLoggerInt Pointer to logger instance. Must be non-NULL. + * @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. + */ +static void rtlogLoggerExVLocked(PRTLOGGERINTERNAL pLoggerInt, unsigned fFlags, unsigned iGroup, + const char *pszFormat, va_list args) +{ + /* + * If we've got an auxilary descriptor, check if the buffer was flushed. + */ + PRTLOGBUFFERDESC pBufDesc = pLoggerInt->pBufDesc; + PRTLOGBUFFERAUXDESC pAuxDesc = pBufDesc->pAux; + if (!pAuxDesc || !pAuxDesc->fFlushedIndicator) + { /* likely, except maybe for ring-0 */ } + else + { + pAuxDesc->fFlushedIndicator = false; + pBufDesc->offBuf = 0; + } + + /* + * Format the message. + */ + if (pLoggerInt->fFlags & (RTLOGFLAGS_PREFIX_MASK | RTLOGFLAGS_USECRLF)) + { + RTLOGOUTPUTPREFIXEDARGS OutputArgs; + OutputArgs.pLoggerInt = pLoggerInt; + OutputArgs.iGroup = iGroup; + OutputArgs.fFlags = fFlags; + OutputArgs.pszInfix = NULL; + RTLogFormatV(rtLogOutputPrefixed, &OutputArgs, pszFormat, args); + } + else + RTLogFormatV(rtLogOutput, pLoggerInt, pszFormat, args); + + /* + * Maybe flush the buffer and update the auxiliary descriptor if there is one. + */ + pBufDesc = pLoggerInt->pBufDesc; /* (the descriptor may have changed) */ + if ( !(pLoggerInt->fFlags & RTLOGFLAGS_BUFFERED) + && pBufDesc->offBuf) + rtlogFlush(pLoggerInt, false /*fNeedSpace*/); + else + { + pAuxDesc = pBufDesc->pAux; + if (pAuxDesc) + pAuxDesc->offBuf = pBufDesc->offBuf; + } +} + + +/** + * For calling rtlogLoggerExVLocked. + * + * @param pLoggerInt The logger. + * @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 ... Format arguments. + */ +static void rtlogLoggerExFLocked(PRTLOGGERINTERNAL pLoggerInt, unsigned fFlags, unsigned iGroup, const char *pszFormat, ...) +{ + va_list va; + va_start(va, pszFormat); + rtlogLoggerExVLocked(pLoggerInt, fFlags, iGroup, pszFormat, va); + va_end(va); +} + + +RTDECL(int) RTLogLoggerExV(PRTLOGGER pLogger, unsigned fFlags, unsigned iGroup, const char *pszFormat, va_list args) +{ + int rc; + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER); + + /* + * Validate and correct iGroup. + */ + if (iGroup != ~0U && iGroup >= pLoggerInt->cGroups) + iGroup = 0; + + /* + * If no output, then just skip it. + */ + if ( (pLoggerInt->fFlags & RTLOGFLAGS_DISABLED) + || !pLoggerInt->fDestFlags + || !pszFormat || !*pszFormat) + return VINF_LOG_DISABLED; + if ( iGroup != ~0U + && (pLoggerInt->afGroups[iGroup] & (fFlags | RTLOGGRPFLAGS_ENABLED)) != (fFlags | RTLOGGRPFLAGS_ENABLED)) + return VINF_LOG_DISABLED; + + /* + * Acquire logger instance sem. + */ + rc = rtlogLock(pLoggerInt); + if (RT_SUCCESS(rc)) + { + /* + * Check group restrictions and call worker. + */ + if (RT_LIKELY( !(pLoggerInt->fFlags & RTLOGFLAGS_RESTRICT_GROUPS) + || iGroup >= pLoggerInt->cGroups + || !(pLoggerInt->afGroups[iGroup] & RTLOGGRPFLAGS_RESTRICT) + || ++pLoggerInt->pacEntriesPerGroup[iGroup] < pLoggerInt->cMaxEntriesPerGroup )) + rtlogLoggerExVLocked(pLoggerInt, fFlags, iGroup, pszFormat, args); + else + { + uint32_t cEntries = pLoggerInt->pacEntriesPerGroup[iGroup]; + if (cEntries > pLoggerInt->cMaxEntriesPerGroup) + pLoggerInt->pacEntriesPerGroup[iGroup] = cEntries - 1; + else + { + rtlogLoggerExVLocked(pLoggerInt, fFlags, iGroup, pszFormat, args); + if ( pLoggerInt->papszGroups + && pLoggerInt->papszGroups[iGroup]) + rtlogLoggerExFLocked(pLoggerInt, fFlags, iGroup, "%u messages from group %s (#%u), muting it.\n", + cEntries, pLoggerInt->papszGroups[iGroup], iGroup); + else + rtlogLoggerExFLocked(pLoggerInt, fFlags, iGroup, "%u messages from group #%u, muting it.\n", cEntries, iGroup); + } + } + + /* + * Release the semaphore. + */ + rtlogUnlock(pLoggerInt); + return VINF_SUCCESS; + } + +#ifdef IN_RING0 + if (pLoggerInt->fDestFlags & ~RTLOGDEST_FILE) + { + rtR0LogLoggerExFallback(pLoggerInt->fDestFlags, pLoggerInt->fFlags, pLoggerInt, pszFormat, args); + return VINF_SUCCESS; + } +#endif + return rc; +} +RT_EXPORT_SYMBOL(RTLogLoggerExV); + + +RTDECL(void) RTLogLoggerV(PRTLOGGER pLogger, const char *pszFormat, va_list args) +{ + RTLogLoggerExV(pLogger, 0, ~0U, pszFormat, args); +} +RT_EXPORT_SYMBOL(RTLogLoggerV); + + +RTDECL(void) RTLogPrintfV(const char *pszFormat, va_list va) +{ + RTLogLoggerV(NULL, pszFormat, va); +} +RT_EXPORT_SYMBOL(RTLogPrintfV); + + +RTDECL(void) RTLogDumpPrintfV(void *pvUser, const char *pszFormat, va_list va) +{ + RTLogLoggerV((PRTLOGGER)pvUser, pszFormat, va); +} +RT_EXPORT_SYMBOL(RTLogDumpPrintfV); + + +RTDECL(void) RTLogAssert(const char *pszFormat, ...) +{ + va_list va; + va_start(va, pszFormat); + RTLogAssertV(pszFormat,va); + va_end(va); +} + + +RTDECL(void) RTLogAssertV(const char *pszFormat, va_list va) +{ + /* + * To the release log if we got one. + */ + PRTLOGGER pLogger = RTLogRelGetDefaultInstance(); + if (pLogger) + { + va_list vaCopy; + va_copy(vaCopy, va); + RTLogLoggerExV(pLogger, 0 /*fFlags*/, ~0U /*uGroup*/, pszFormat, vaCopy); + va_end(vaCopy); +#ifndef IN_RC + RTLogFlush(pLogger); +#endif + } + + /* + * To the debug log if we got one, however when LOG_ENABLE (debug builds and + * such) we'll allow it to be created here. + */ +#ifdef LOG_ENABLED + pLogger = RTLogDefaultInstance(); +#else + pLogger = RTLogGetDefaultInstance(); +#endif + if (pLogger) + { + RTLogLoggerExV(pLogger, 0 /*fFlags*/, ~0U /*uGroup*/, pszFormat, va); +# ifndef IN_RC /* flushing is done automatically in RC */ + RTLogFlush(pLogger); +#endif + } +} + + +#if defined(IN_RING3) && (defined(IN_RT_STATIC) || defined(IPRT_NO_CRT)) +/** + * "Weak symbol" emulation to prevent dragging in log.cpp and all its friends + * just because some code is using Assert() in a statically linked binary. + * + * The pointers are in log-assert-pfn.cpp, so users only drag in that file and + * they remain NULL unless this file is also linked into the binary. + */ +class RTLogAssertWeakSymbolEmulator +{ +public: + RTLogAssertWeakSymbolEmulator(void) + { + g_pfnRTLogAssert = RTLogAssert; + g_pfnRTLogAssertV = RTLogAssertV; + } +}; +static RTLogAssertWeakSymbolEmulator rtLogInitWeakSymbolPointers; +#endif + + +#ifdef IN_RING3 + +/** + * @callback_method_impl{FNRTLOGPHASEMSG, + * Log phase callback function - assumes the lock is already held.} + */ +static DECLCALLBACK(void) rtlogPhaseMsgLocked(PRTLOGGER pLogger, const char *pszFormat, ...) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + AssertPtrReturnVoid(pLoggerInt); + Assert(pLoggerInt->hSpinMtx != NIL_RTSEMSPINMUTEX); + + va_list args; + va_start(args, pszFormat); + rtlogLoggerExVLocked(pLoggerInt, 0, ~0U, pszFormat, args); + va_end(args); +} + + +/** + * @callback_method_impl{FNRTLOGPHASEMSG, + * Log phase callback function - assumes the lock is not held.} + */ +static DECLCALLBACK(void) rtlogPhaseMsgNormal(PRTLOGGER pLogger, const char *pszFormat, ...) +{ + PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger; + AssertPtrReturnVoid(pLoggerInt); + Assert(pLoggerInt->hSpinMtx != NIL_RTSEMSPINMUTEX); + + va_list args; + va_start(args, pszFormat); + RTLogLoggerExV(&pLoggerInt->Core, 0, ~0U, pszFormat, args); + va_end(args); +} + +#endif /* IN_RING3 */ + |