VirtualBox

Changeset 55980 in vbox


Ignore:
Timestamp:
May 20, 2015 5:35:22 PM (9 years ago)
Author:
vboxsync
Message:

iprt/log.h,++: Added extended logger instance getters that also checks whether the given logger and group-flags are enabled, making the LogRel* checks more efficient in avoid uncessary RTLogLoggerEx parameter building and calls. Ditto for debug logging. The LOG_INSTANCE and LOG_REL_INSTANCE tricks are gone for now.

Location:
trunk
Files:
51 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/log.h

    r55286 r55980  
    124124#endif
    125125
    126 /** @def LOG_INSTANCE
    127  * Active logging instance.
    128  */
    129 #ifndef LOG_INSTANCE
    130 # define LOG_INSTANCE       NULL
    131 #endif
    132 
    133 /** @def LOG_REL_INSTANCE
    134  * Active release logging instance.
    135  */
    136 #ifndef LOG_REL_INSTANCE
    137 # define LOG_REL_INSTANCE   NULL
    138 #endif
    139 
    140126/** @def LOG_FN_FMT
    141127 * You can use this to specify you desired way of printing __PRETTY_FUNCTION__
    … …  
    144130#ifndef LOG_FN_FMT
    145131# define LOG_FN_FMT "%Rfn"
     132#endif
     133
     134#ifdef LOG_INSTANCE
     135# error "LOG_INSTANCE is no longer supported."
     136#endif
     137#ifdef LOG_REL_INSTANCE
     138# error "LOG_REL_INSTANCE is no longer supported."
    146139#endif
    147140
    … …  
    523516#ifdef LOG_ENABLED
    524517# if defined(LOG_USE_C99)
    525 #  define _LogRemoveParentheseis(...)                           __VA_ARGS__
    526 #  define _LogIt(a_pvInst, a_fFlags, a_iGroup, ...)             RTLogLoggerEx((PRTLOGGER)a_pvInst, a_fFlags, a_iGroup, __VA_ARGS__)
    527 #  define LogIt(a_pvInst, a_fFlags, a_iGroup, fmtargs)          _LogIt(a_pvInst, a_fFlags, a_iGroup, _LogRemoveParentheseis fmtargs)
    528 #  define _LogItAlways(a_pvInst, a_fFlags, a_iGroup, ...)       RTLogLoggerEx((PRTLOGGER)a_pvInst, a_fFlags, ~0U, __VA_ARGS__)
    529 #  define LogItAlways(a_pvInst, a_fFlags, a_iGroup, fmtargs)    _LogItAlways(a_pvInst, a_fFlags, a_iGroup, _LogRemoveParentheseis fmtargs)
     518#  define _LogRemoveParentheseis(...)                   __VA_ARGS__
     519#  define _LogIt(a_fFlags, a_iGroup, ...) \
     520   do \
     521   { \
     522        register PRTLOGGER LogIt_pLogger = RTLogDefaultInstanceEx(a_fFlags, a_iGroup); \
     523        if (RT_LIKELY(!LogIt_pLogger)) \
     524        {   /* likely */ } \
     525        else \
     526            RTLogLoggerEx(LogIt_pLogger, a_fFlags, a_iGroup, __VA_ARGS__); \
     527   } while (0)
     528#  define LogIt(a_fFlags, a_iGroup, fmtargs)            _LogIt(a_fFlags, a_iGroup, _LogRemoveParentheseis fmtargs)
     529#  define _LogItAlways(a_fFlags, a_iGroup, ...)          RTLogLoggerEx(NULL, a_fFlags, UINT32_MAX, __VA_ARGS__)
     530#  define LogItAlways(a_fFlags, a_iGroup, fmtargs)      _LogItAlways(a_fFlags, a_iGroup, _LogRemoveParentheseis fmtargs)
    530531        /** @todo invent a flag or something for skipping the group check so we can pass iGroup. LogItAlways. */
    531532# else
    532 #  define LogIt(a_pvInst, a_fFlags, a_iGroup, fmtargs) \
     533#  define LogIt(a_fFlags, a_iGroup, fmtargs) \
    533534    do \
    534535    { \
    535         register PRTLOGGER LogIt_pLogger = (PRTLOGGER)(a_pvInst) ? (PRTLOGGER)(a_pvInst) : RTLogDefaultInstance(); \
    536         if (    LogIt_pLogger \
    537             && !(LogIt_pLogger->fFlags & RTLOGFLAGS_DISABLED)) \
     536        register PRTLOGGER LogIt_pLogger = RTLogDefaultInstanceEx(a_fFlags, a_iGroup); \
     537        if (RT_LIKELY(!LogIt_pLogger)) \
     538        {   /* likely */ } \
     539        else \
    538540        { \
    539             register unsigned LogIt_fFlags = LogIt_pLogger->afGroups[(unsigned)(a_iGroup) < LogIt_pLogger->cGroups ? (unsigned)(a_iGroup) : 0]; \
    540             if ((LogIt_fFlags & ((a_fFlags) | RTLOGGRPFLAGS_ENABLED)) == ((a_fFlags) | RTLOGGRPFLAGS_ENABLED)) \
    541                 LogIt_pLogger->pfnLogger fmtargs; \
     541            LogIt_pLogger->pfnLogger fmtargs; \
    542542        } \
    543543    } while (0)
    544 #  define LogItAlways(a_pvInst, a_fFlags, a_iGroup, fmtargs) \
     544#  define LogItAlways(a_fFlags, a_iGroup, fmtargs) \
    545545    do \
    546546    { \
    547         register PRTLOGGER LogIt_pLogger = (PRTLOGGER)(a_pvInst) ? (PRTLOGGER)(a_pvInst) : RTLogDefaultInstance(); \
    548         if (   LogIt_pLogger \
    549             && !(LogIt_pLogger->fFlags & RTLOGFLAGS_DISABLED)) \
     547        register PRTLOGGER LogIt_pLogger = RTLogDefaultInstanceEx(0, UINT32_MAX); \
     548        if (LogIt_pLogger) \
    550549            LogIt_pLogger->pfnLogger fmtargs; \
    551550    } while (0)
    552551# endif
    553552#else
    554 # define LogIt(a_pvInst, a_fFlags, a_iGroup, fmtargs)       do { } while (0)
    555 # define LogItAlways(a_pvInst, a_fFlags, a_iGroup, fmtargs) do { } while (0)
     553# define LogIt(a_fFlags, a_iGroup, fmtargs)             do { } while (0)
     554# define LogItAlways(a_fFlags, a_iGroup, fmtargs)      do { } while (0)
    556555# if defined(LOG_USE_C99)
    557 #  define _LogRemoveParentheseis(...)                       __VA_ARGS__
    558 #  define _LogIt(a_pvInst, a_fFlags, a_iGroup, ...)         do { } while (0)
    559 #  define _LogItAlways(a_pvInst, a_fFlags, a_iGroup, ...)   do { } while (0)
     556#  define _LogRemoveParentheseis(...)                   __VA_ARGS__
     557#  define _LogIt(a_fFlags, a_iGroup, ...)               do { } while (0)
     558#  define _LogItAlways(a_fFlags, a_iGroup, ...)         do { } while (0)
    560559# endif
    561560#endif
    … …  
    565564 * Level 1 logging that works regardless of the group settings.
    566565 */
    567 #define LogAlways(a)    LogItAlways(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, a)
     566#define LogAlways(a)    LogItAlways(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, a)
    568567
    569568/** @def Log
    570569 * Level 1 logging.
    571570 */
    572 #define Log(a)          LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, a)
     571#define Log(a)          LogIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, a)
    573572
    574573/** @def Log2
    575574 * Level 2 logging.
    576575 */
    577 #define Log2(a)         LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2,  LOG_GROUP, a)
     576#define Log2(a)         LogIt(RTLOGGRPFLAGS_LEVEL_2,  LOG_GROUP, a)
    578577
    579578/** @def Log3
    580579 * Level 3 logging.
    581580 */
    582 #define Log3(a)         LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_3,  LOG_GROUP, a)
     581#define Log3(a)         LogIt(RTLOGGRPFLAGS_LEVEL_3,  LOG_GROUP, a)
    583582
    584583/** @def Log4
    585584 * Level 4 logging.
    586585 */
    587 #define Log4(a)         LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_4,  LOG_GROUP, a)
     586#define Log4(a)         LogIt(RTLOGGRPFLAGS_LEVEL_4,  LOG_GROUP, a)
    588587
    589588/** @def Log5
    590589 * Level 5 logging.
    591590 */
    592 #define Log5(a)         LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_5,  LOG_GROUP, a)
     591#define Log5(a)         LogIt(RTLOGGRPFLAGS_LEVEL_5,  LOG_GROUP, a)
    593592
    594593/** @def Log6
    595594 * Level 6 logging.
    596595 */
    597 #define Log6(a)         LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_6,  LOG_GROUP, a)
     596#define Log6(a)         LogIt(RTLOGGRPFLAGS_LEVEL_6,  LOG_GROUP, a)
    598597
    599598/** @def LogFlow
    600599 * Logging of execution flow.
    601600 */
    602 #define LogFlow(a)      LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_FLOW,     LOG_GROUP, a)
     601#define LogFlow(a)      LogIt(RTLOGGRPFLAGS_FLOW,     LOG_GROUP, a)
    603602
    604603/** @def LogLelik
    605604 *  lelik logging.
    606605 */
    607 #define LogLelik(a)     LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LELIK,    LOG_GROUP, a)
     606#define LogLelik(a)     LogIt(RTLOGGRPFLAGS_LELIK,    LOG_GROUP, a)
    608607
    609608
    … …  
    611610 * michael logging.
    612611 */
    613 #define LogMichael(a)   LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_MICHAEL,  LOG_GROUP, a)
     612#define LogMichael(a)   LogIt(RTLOGGRPFLAGS_MICHAEL,  LOG_GROUP, a)
    614613
    615614/** @def LogSunlover
    616615 * sunlover logging.
    617616 */
    618 #define LogSunlover(a)  LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_SUNLOVER, LOG_GROUP, a)
     617#define LogSunlover(a)  LogIt(RTLOGGRPFLAGS_SUNLOVER, LOG_GROUP, a)
    619618
    620619/** @def LogAchim
    621620 * Achim logging.
    622621 */
    623 #define LogAchim(a)     LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_ACHIM,    LOG_GROUP, a)
     622#define LogAchim(a)     LogIt(RTLOGGRPFLAGS_ACHIM,    LOG_GROUP, a)
    624623
    625624/** @def LogSander
    626625 * Sander logging.
    627626 */
    628 #define LogSander(a)    LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_SANDER,   LOG_GROUP, a)
     627#define LogSander(a)    LogIt(RTLOGGRPFLAGS_SANDER,   LOG_GROUP, a)
    629628
    630629/** @def LogKlaus
    631630 *  klaus logging.
    632631 */
    633 #define LogKlaus(a)     LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_KLAUS,    LOG_GROUP, a)
     632#define LogKlaus(a)     LogIt(RTLOGGRPFLAGS_KLAUS,    LOG_GROUP, a)
    634633
    635634/** @def LogFrank
    636635 *  frank logging.
    637636 */
    638 #define LogFrank(a)     LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_FRANK,    LOG_GROUP, a)
     637#define LogFrank(a)     LogIt(RTLOGGRPFLAGS_FRANK,    LOG_GROUP, a)
    639638
    640639/** @def LogBird
    641640 * bird logging.
    642641 */
    643 #define LogBird(a)      LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_BIRD,     LOG_GROUP, a)
     642#define LogBird(a)      LogIt(RTLOGGRPFLAGS_BIRD,     LOG_GROUP, a)
    644643
    645644/** @def LogAleksey
    646645 * aleksey logging.
    647646 */
    648 #define LogAleksey(a)   LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_ALEKSEY,  LOG_GROUP, a)
     647#define LogAleksey(a)   LogIt(RTLOGGRPFLAGS_ALEKSEY,  LOG_GROUP, a)
    649648
    650649/** @def LogDJ
    651650 * dj logging.
    652651 */
    653 #define LogDJ(a)        LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_DJ,  LOG_GROUP, a)
     652#define LogDJ(a)        LogIt(RTLOGGRPFLAGS_DJ,  LOG_GROUP, a)
    654653
    655654/** @def LogNoName
    656655 * NoName logging.
    657656 */
    658 #define LogNoName(a)    LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_NONAME,   LOG_GROUP, a)
     657#define LogNoName(a)    LogIt(RTLOGGRPFLAGS_NONAME,   LOG_GROUP, a)
    659658
    660659/** @def LogWarning
    … …  
    665664#if defined(LOG_USE_C99)
    666665# define LogWarning(a) \
    667     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, "WARNING! %M", _LogRemoveParentheseis a )
     666    _LogIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, "WARNING! %M", _LogRemoveParentheseis a )
    668667#else
    669668# define LogWarning(a) \
    … …  
    686685#ifdef LOG_USE_C99
    687686# define LogTraceMsg(a) \
    688     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_FLOW, LOG_GROUP, ">>>>> %s (%d): " LOG_FN_FMT ": %M", __FILE__, __LINE__, __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     687    _LogIt(RTLOGGRPFLAGS_FLOW, LOG_GROUP, ">>>>> %s (%d): " LOG_FN_FMT ": %M", __FILE__, __LINE__, __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    689688#else
    690689# define LogTraceMsg(a) \
    … …  
    702701#ifdef LOG_USE_C99
    703702# define LogFunc(a) \
    704     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     703    _LogIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    705704#else
    706705# define LogFunc(a) \
    … …  
    718717#ifdef LOG_USE_C99
    719718# define Log2Func(a) \
    720     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     719    _LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    721720#else
    722721# define Log2Func(a) \
    … …  
    734733#ifdef LOG_USE_C99
    735734# define Log3Func(a) \
    736     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_3, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     735    _LogIt(RTLOGGRPFLAGS_LEVEL_3, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    737736#else
    738737# define Log3Func(a) \
    … …  
    750749#ifdef LOG_USE_C99
    751750# define Log4Func(a) \
    752     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_4, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     751    _LogIt(RTLOGGRPFLAGS_LEVEL_4, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    753752#else
    754753# define Log4Func(a) \
    … …  
    766765#ifdef LOG_USE_C99
    767766# define Log5Func(a) \
    768     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     767    _LogIt(RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    769768#else
    770769# define Log5Func(a) \
    … …  
    782781#ifdef LOG_USE_C99
    783782# define Log6Func(a) \
    784     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_6, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     783    _LogIt(RTLOGGRPFLAGS_LEVEL_6, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    785784#else
    786785# define Log6Func(a) \
    … …  
    796795#ifdef LOG_USE_C99
    797796# define LogThisFunc(a) \
    798     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, "{%p} " LOG_FN_FMT ": %M", this, __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     797    _LogIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, "{%p} " LOG_FN_FMT ": %M", this, __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    799798#else
    800799# define LogThisFunc(a) \
    … …  
    812811#ifdef LOG_USE_C99
    813812# define LogFlowFunc(a) \
    814     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_FLOW, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     813    _LogIt(RTLOGGRPFLAGS_FLOW, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    815814#else
    816815# define LogFlowFunc(a) \
    … …  
    825824#ifdef LOG_USE_C99
    826825# define LogWarningFunc(a) \
    827     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, LOG_FN_FMT ": WARNING! %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     826    _LogIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, LOG_FN_FMT ": WARNING! %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    828827#else
    829828# define LogWarningFunc(a) \
    … …  
    839838#ifdef LOG_USE_C99
    840839# define LogFlowThisFunc(a) \
    841     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_FLOW, LOG_GROUP, "{%p} " LOG_FN_FMT ": %M", this, __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     840    _LogIt(RTLOGGRPFLAGS_FLOW, LOG_GROUP, "{%p} " LOG_FN_FMT ": %M", this, __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    842841#else
    843842# define LogFlowThisFunc(a) \
    … …  
    853852#ifdef LOG_USE_C99
    854853# define LogWarningThisFunc(a) \
    855     _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, "{%p} " LOG_FN_FMT ": WARNING! %M", this, __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     854    _LogIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, "{%p} " LOG_FN_FMT ": WARNING! %M", this, __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    856855#else
    857856# define LogWarningThisFunc(a) \
    … …  
    897896 */
    898897#ifdef LOG_ENABLED
    899 # define LogIsItEnabled(a_pvInst, a_fFlags, a_iGroup) \
    900     LogIsItEnabledInternal((a_pvInst), (unsigned)(a_iGroup), (unsigned)(a_fFlags))
    901 #else
    902 # define LogIsItEnabled(a_pvInst, a_fFlags, a_iGroup) (false)
     898# define LogIsItEnabled(a_fFlags, a_iGroup) \
     899    LogIsItEnabledInternal((unsigned)(a_iGroup), (unsigned)(a_fFlags))
     900#else
     901# define LogIsItEnabled(a_fFlags, a_iGroup) (false)
    903902#endif
    904903
    … …  
    906905 * Checks whether level 1 logging is enabled.
    907906 */
    908 #define LogIsEnabled()      LogIsItEnabled(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP)
     907#define LogIsEnabled()      LogIsItEnabled(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP)
    909908
    910909/** @def LogIs2Enabled
    911910 * Checks whether level 2 logging is enabled.
    912911 */
    913 #define LogIs2Enabled()     LogIsItEnabled(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP)
     912#define LogIs2Enabled()     LogIsItEnabled(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP)
    914913
    915914/** @def LogIs3Enabled
    916915 * Checks whether level 3 logging is enabled.
    917916 */
    918 #define LogIs3Enabled()     LogIsItEnabled(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_3, LOG_GROUP)
     917#define LogIs3Enabled()     LogIsItEnabled(RTLOGGRPFLAGS_LEVEL_3, LOG_GROUP)
    919918
    920919/** @def LogIs4Enabled
    921920 * Checks whether level 4 logging is enabled.
    922921 */
    923 #define LogIs4Enabled()     LogIsItEnabled(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_4, LOG_GROUP)
     922#define LogIs4Enabled()     LogIsItEnabled(RTLOGGRPFLAGS_LEVEL_4, LOG_GROUP)
    924923
    925924/** @def LogIs5Enabled
    926925 * Checks whether level 5 logging is enabled.
    927926 */
    928 #define LogIs5Enabled()     LogIsItEnabled(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP)
     927#define LogIs5Enabled()     LogIsItEnabled(RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP)
    929928
    930929/** @def LogIs6Enabled
    931930 * Checks whether level 6 logging is enabled.
    932931 */
    933 #define LogIs6Enabled()     LogIsItEnabled(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_6, LOG_GROUP)
     932#define LogIs6Enabled()     LogIsItEnabled(RTLOGGRPFLAGS_LEVEL_6, LOG_GROUP)
    934933
    935934/** @def LogIsFlowEnabled
    936935 * Checks whether execution flow logging is enabled.
    937936 */
    938 #define LogIsFlowEnabled()  LogIsItEnabled(LOG_INSTANCE, RTLOGGRPFLAGS_FLOW, LOG_GROUP)
     937#define LogIsFlowEnabled()  LogIsItEnabled(RTLOGGRPFLAGS_FLOW, LOG_GROUP)
    939938
    940939
    … …  
    10091008 * Write to specific logger if group enabled.
    10101009 */
     1010/** @def LogRelItLikely
     1011 * Write to specific logger if group enabled, assuming it likely it is enabled.
     1012 */
    10111013/** @def LogRelMaxIt
    10121014 * Write to specific logger if group enabled and at less than a_cMax messages
    … …  
    10161018# if defined(LOG_USE_C99)
    10171019#  define _LogRelRemoveParentheseis(...)                    __VA_ARGS__
    1018 #  define _LogRelIt(a_pvInst, a_fFlags, a_iGroup, ...) \
     1020#  define _LogRelIt(a_fFlags, a_iGroup, ...) \
    10191021    do \
    10201022    { \
    1021         PRTLOGGER LogRelIt_pLogger = (PRTLOGGER)(a_pvInst) ? (PRTLOGGER)(a_pvInst) : RTLogRelDefaultInstance(); \
    1022         if (   LogRelIt_pLogger \
    1023             && !(LogRelIt_pLogger->fFlags & RTLOGFLAGS_DISABLED)) \
     1023        PRTLOGGER LogRelIt_pLogger = RTLogRelGetDefaultInstanceEx(a_fFlags, a_iGroup); \
     1024        if (RT_LIKELY(!LogRelIt_pLogger)) \
     1025        { /* likely */ } \
     1026        else \
    10241027            RTLogLoggerEx(LogRelIt_pLogger, a_fFlags, a_iGroup, __VA_ARGS__); \
    1025         _LogIt(LOG_INSTANCE, a_fFlags, a_iGroup, __VA_ARGS__); \
     1028        _LogIt(a_fFlags, a_iGroup, __VA_ARGS__); \
    10261029    } while (0)
    1027 #  define LogRelIt(a_pvInst, a_fFlags, a_iGroup, fmtargs)   _LogRelIt(a_pvInst, a_fFlags, a_iGroup, _LogRelRemoveParentheseis fmtargs)
    1028 #  define _LogRelMaxIt(a_cMax, a_pvInst, a_fFlags, a_iGroup, ...) \
     1030#  define LogRelIt(a_fFlags, a_iGroup, fmtargs) \
     1031    _LogRelIt(a_fFlags, a_iGroup, _LogRelRemoveParentheseis fmtargs)
     1032#  define _LogRelItLikely(a_fFlags, a_iGroup, ...) \
    10291033    do \
    10301034    { \
    1031         PRTLOGGER LogRelIt_pLogger = (PRTLOGGER)(a_pvInst) ? (PRTLOGGER)(a_pvInst) : RTLogRelDefaultInstance(); \
    1032         if (   LogRelIt_pLogger \
    1033             && !(LogRelIt_pLogger->fFlags & RTLOGFLAGS_DISABLED)) \
     1035        PRTLOGGER LogRelIt_pLogger = RTLogRelGetDefaultInstanceEx(a_fFlags, a_iGroup); \
     1036        if (LogRelIt_pLogger) \
     1037            RTLogLoggerEx(LogRelIt_pLogger, a_fFlags, a_iGroup, __VA_ARGS__); \
     1038        _LogIt(a_fFlags, a_iGroup, __VA_ARGS__); \
     1039    } while (0)
     1040#  define LogRelItLikely(a_fFlags, a_iGroup, fmtargs) \
     1041    _LogRelItLikely(a_fFlags, a_iGroup, _LogRelRemoveParentheseis fmtargs)
     1042#  define _LogRelMaxIt(a_cMax, a_fFlags, a_iGroup, ...) \
     1043    do \
     1044    { \
     1045        PRTLOGGER LogRelIt_pLogger = RTLogRelGetDefaultInstanceEx(a_fFlags, a_iGroup); \
     1046        if (LogRelIt_pLogger) \
    10341047        { \
    10351048            static uint32_t s_LogRelMaxIt_cLogged = 0; \
    … …  
    10401053            } \
    10411054        } \
    1042         _LogIt(LOG_INSTANCE, a_fFlags, a_iGroup, __VA_ARGS__); \
     1055        _LogIt(a_fFlags, a_iGroup, __VA_ARGS__); \
    10431056    } while (0)
    1044 #  define LogRelMaxIt(a_cMax, a_pvInst, a_fFlags, a_iGroup, fmtargs) \
    1045     _LogRelMaxIt(a_cMax, a_pvInst, a_fFlags, a_iGroup, _LogRelRemoveParentheseis fmtargs)
     1057#  define LogRelMaxIt(a_cMax, a_fFlags, a_iGroup, fmtargs) \
     1058    _LogRelMaxIt(a_cMax, a_fFlags, a_iGroup, _LogRelRemoveParentheseis fmtargs)
    10461059# else
    1047 #  define LogRelIt(a_pvInst, a_fFlags, a_iGroup, fmtargs) \
     1060#  define LogRelItLikely(a_fFlags, a_iGroup, fmtargs) \
    10481061   do \
    10491062   { \
    1050        PRTLOGGER LogRelIt_pLogger = (PRTLOGGER)(a_pvInst) ? (PRTLOGGER)(a_pvInst) : RTLogRelDefaultInstance(); \
    1051        if (   LogRelIt_pLogger \
    1052            && !(LogRelIt_pLogger->fFlags & RTLOGFLAGS_DISABLED)) \
     1063       PRTLOGGER LogRelIt_pLogger = RTLogRelGetDefaultInstanceEx(a_fFlags, a_iGroup); \
     1064       if (LogRelIt_pLogger) \
    10531065       { \
    1054            unsigned LogIt_fFlags = LogRelIt_pLogger->afGroups[(unsigned)(a_iGroup) < LogRelIt_pLogger->cGroups ? (unsigned)(a_iGroup) : 0]; \
    1055            if ((LogIt_fFlags & ((a_fFlags) | RTLOGGRPFLAGS_ENABLED)) == ((a_fFlags) | RTLOGGRPFLAGS_ENABLED)) \
    1056                LogRelIt_pLogger->pfnLogger fmtargs; \
     1066           LogRelIt_pLogger->pfnLogger fmtargs; \
    10571067       } \
    1058        LogIt(LOG_INSTANCE, a_fFlags, a_iGroup, fmtargs); \
     1068       LogIt(a_fFlags, a_iGroup, fmtargs); \
    10591069  } while (0)
    1060 #  define LogRelMaxIt(a_cMax, a_pvInst, a_fFlags, a_iGroup, fmtargs) \
     1070#  define LogRelIt(a_fFlags, a_iGroup, fmtargs) \
    10611071   do \
    10621072   { \
    1063        PRTLOGGER LogRelIt_pLogger = (PRTLOGGER)(a_pvInst) ? (PRTLOGGER)(a_pvInst) : RTLogRelDefaultInstance(); \
    1064        if (   LogRelIt_pLogger \
    1065            && !(LogRelIt_pLogger->fFlags & RTLOGFLAGS_DISABLED)) \
     1073       PRTLOGGER LogRelIt_pLogger = RTLogRelGetDefaultInstanceEx(a_fFlags, a_iGroup); \
     1074       if (RT_LIKELY(!LogRelIt_pLogger)) \
     1075       { /* likely */ } \
     1076       else \
    10661077       { \
    1067            unsigned LogIt_fFlags = LogRelIt_pLogger->afGroups[(unsigned)(a_iGroup) < LogRelIt_pLogger->cGroups ? (unsigned)(a_iGroup) : 0]; \
    1068            if ((LogIt_fFlags & ((a_fFlags) | RTLOGGRPFLAGS_ENABLED)) == ((a_fFlags) | RTLOGGRPFLAGS_ENABLED)) \
     1078           LogRelIt_pLogger->pfnLogger fmtargs; \
     1079       } \
     1080       LogIt(a_fFlags, a_iGroup, fmtargs); \
     1081  } while (0)
     1082#  define LogRelMaxIt(a_cMax, a_fFlags, a_iGroup, fmtargs) \
     1083   do \
     1084   { \
     1085       PRTLOGGER LogRelIt_pLogger = RTLogRelGetDefaultInstanceEx(a_fFlags, a_iGroup); \
     1086       if (LogRelIt_pLogger) \
     1087       { \
     1088           static uint32_t s_LogRelMaxIt_cLogged = 0; \
     1089           if (s_LogRelMaxIt_cLogged < (a_cMax)) \
    10691090           { \
    1070                static uint32_t s_LogRelMaxIt_cLogged = 0; \
    1071                if (s_LogRelMaxIt_cLogged < (a_cMax)) \
    1072                { \
    1073                    s_LogRelMaxIt_cLogged++; \
    1074                    LogRelIt_pLogger->pfnLogger fmtargs; \
    1075                } \
     1091               s_LogRelMaxIt_cLogged++; \
     1092               LogRelIt_pLogger->pfnLogger fmtargs; \
    10761093           } \
    10771094       } \
    1078        LogIt(LOG_INSTANCE, a_fFlags, a_iGroup, fmtargs); \
     1095       LogIt(a_fFlags, a_iGroup, fmtargs); \
    10791096  } while (0)
    10801097# endif
    10811098#else   /* !RTLOG_REL_ENABLED */
    1082 # define LogRelIt(a_pvInst, a_fFlags, a_iGroup, fmtargs)    do { } while (0)
    1083 # define LogRelMaxIt(a_pvInst, a_fFlags, a_iGroup, fmtargs) do { } while (0)
     1099# define LogRelIt(a_fFlags, a_iGroup, fmtargs)              do { } while (0)
     1100# define LogRelItLikely(a_fFlags, a_iGroup, fmtargs)        do { } while (0)
     1101# define LogRelMaxIt(a_cMax, a_fFlags, a_iGroup, fmtargs)   do { } while (0)
    10841102# if defined(LOG_USE_C99)
    10851103#  define _LogRelRemoveParentheseis(...)                    __VA_ARGS__
    1086 #  define _LogRelIt(a_pvInst, a_fFlags, a_iGroup, ...)      do { } while (0)
    1087 #  define _LogRelMaxIt(a_cMax, a_pvInst, a_fFlags, a_iGroup, ...) do { } while (0)
     1104#  define _LogRelIt(a_fFlags, a_iGroup, ...)                do { } while (0)
     1105#  define _LogRelItLikely(a_fFlags, a_iGroup, ...)          do { } while (0)
     1106#  define _LogRelMaxIt(a_cMax, a_fFlags, a_iGroup, ...)     do { } while (0)
    10881107# endif
    10891108#endif  /* !RTLOG_REL_ENABLED */
    … …  
    10931112 * Level 1 logging.
    10941113 */
    1095 #define LogRel(a)          LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, a)
     1114#define LogRel(a)          LogRelItLikely(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, a)
    10961115
    10971116/** @def LogRel2
    10981117 * Level 2 logging.
    10991118 */
    1100 #define LogRel2(a)         LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_2,  LOG_GROUP, a)
     1119#define LogRel2(a)         LogRelIt(RTLOGGRPFLAGS_LEVEL_2,  LOG_GROUP, a)
    11011120
    11021121/** @def LogRel3
    11031122 * Level 3 logging.
    11041123 */
    1105 #define LogRel3(a)         LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_3,  LOG_GROUP, a)
     1124#define LogRel3(a)         LogRelIt(RTLOGGRPFLAGS_LEVEL_3,  LOG_GROUP, a)
    11061125
    11071126/** @def LogRel4
    11081127 * Level 4 logging.
    11091128 */
    1110 #define LogRel4(a)         LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_4,  LOG_GROUP, a)
     1129#define LogRel4(a)         LogRelIt(RTLOGGRPFLAGS_LEVEL_4,  LOG_GROUP, a)
    11111130
    11121131/** @def LogRel5
    11131132 * Level 5 logging.
    11141133 */
    1115 #define LogRel5(a)         LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_5,  LOG_GROUP, a)
     1134#define LogRel5(a)         LogRelIt(RTLOGGRPFLAGS_LEVEL_5,  LOG_GROUP, a)
    11161135
    11171136/** @def LogRel6
    11181137 * Level 6 logging.
    11191138 */
    1120 #define LogRel6(a)         LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_6,  LOG_GROUP, a)
     1139#define LogRel6(a)         LogRelIt(RTLOGGRPFLAGS_LEVEL_6,  LOG_GROUP, a)
    11211140
    11221141/** @def LogRelFlow
    11231142 * Logging of execution flow.
    11241143 */
    1125 #define LogRelFlow(a)      LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_FLOW,     LOG_GROUP, a)
     1144#define LogRelFlow(a)      LogRelIt(RTLOGGRPFLAGS_FLOW,     LOG_GROUP, a)
    11261145
    11271146/** @def LogRelFunc
    … …  
    11311150#ifdef LOG_USE_C99
    11321151# define LogRelFunc(a) \
    1133     _LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, LOG_FN_FMT ": %M", RT_GCC_EXTENSION __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    1134 # define LogFunc(a) \
    1135            _LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     1152    _LogRelItLikely(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, LOG_FN_FMT ": %M", RT_GCC_EXTENSION __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    11361153#else
    11371154# define LogRelFunc(a) \
    … …  
    11451162#ifdef LOG_USE_C99
    11461163# define LogRelThisFunc(a) \
    1147     _LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, "{%p} " LOG_FN_FMT ": %M", this, __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     1164    _LogRelItLikely(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, "{%p} " LOG_FN_FMT ": %M", this, __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    11481165#else
    11491166# define LogRelThisFunc(a) \
    … …  
    11611178#ifdef LOG_USE_C99
    11621179# define LogRelFlowFunc(a) \
    1163     _LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_FLOW, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
     1180    _LogRelIt(RTLOGGRPFLAGS_FLOW, LOG_GROUP, LOG_FN_FMT ": %M", __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    11641181#else
    11651182# define LogRelFlowFunc(a) \
    … …  
    11701187 *  lelik logging.
    11711188 */
    1172 #define LogRelLelik(a)     LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LELIK,    LOG_GROUP, a)
     1189#define LogRelLelik(a)              LogRelIt(RTLOGGRPFLAGS_LELIK,    LOG_GROUP, a)
    11731190
    11741191/** @def LogRelMichael
    11751192 * michael logging.
    11761193 */
    1177 #define LogRelMichael(a)   LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_MICHAEL,  LOG_GROUP, a)
     1194#define LogRelMichael(a)            LogRelIt(RTLOGGRPFLAGS_MICHAEL,  LOG_GROUP, a)
    11781195
    11791196/** @def LogRelSunlover
    11801197 * sunlover logging.
    11811198 */
    1182 #define LogRelSunlover(a)  LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_SUNLOVER, LOG_GROUP, a)
     1199#define LogRelSunlover(a)           LogRelIt(RTLOGGRPFLAGS_SUNLOVER, LOG_GROUP, a)
    11831200
    11841201/** @def LogRelAchim
    11851202 * Achim logging.
    11861203 */
    1187 #define LogRelAchim(a)     LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_ACHIM,    LOG_GROUP, a)
     1204#define LogRelAchim(a)              LogRelIt(RTLOGGRPFLAGS_ACHIM,    LOG_GROUP, a)
    11881205
    11891206/** @def LogRelSander
    11901207 * Sander logging.
    11911208 */
    1192 #define LogRelSander(a)    LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_SANDER,   LOG_GROUP, a)
     1209#define LogRelSander(a)             LogRelIt(RTLOGGRPFLAGS_SANDER,   LOG_GROUP, a)
    11931210
    11941211/** @def LogRelKlaus
    11951212 *  klaus logging.
    11961213 */
    1197 #define LogRelKlaus(a)     LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_KLAUS,    LOG_GROUP, a)
     1214#define LogRelKlaus(a)              LogRelIt(RTLOGGRPFLAGS_KLAUS,    LOG_GROUP, a)
    11981215
    11991216/** @def LogRelFrank
    12001217 *  frank logging.
    12011218 */
    1202 #define LogRelFrank(a)     LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_FRANK,    LOG_GROUP, a)
     1219#define LogRelFrank(a)              LogRelIt(RTLOGGRPFLAGS_FRANK,    LOG_GROUP, a)
    12031220
    12041221/** @def LogRelBird
    12051222 * bird logging.
    12061223 */
    1207 #define LogRelBird(a)      LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_BIRD,     LOG_GROUP, a)
     1224#define LogRelBird(a)               LogRelIt(RTLOGGRPFLAGS_BIRD,     LOG_GROUP, a)
    12081225
    12091226/** @def LogRelNoName
    12101227 * NoName logging.
    12111228 */
    1212 #define LogRelNoName(a)    LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_NONAME,   LOG_GROUP, a)
     1229#define LogRelNoName(a)             LogRelIt(RTLOGGRPFLAGS_NONAME,   LOG_GROUP, a)
    12131230
    12141231
    … …  
    12161233 * Level 1 logging.
    12171234 */
    1218 #define LogRelMax(a_cMax, a)        LogRelMaxIt(a_cMax, LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, a)
     1235#define LogRelMax(a_cMax, a)        LogRelMaxIt(a_cMax, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, a)
    12191236
    12201237/** @def LogRelMax2
    12211238 * Level 2 logging.
    12221239 */
    1223 #define LogRelMax2(a_cMax, a)       LogRelMaxIt(a_cMax, LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_2,  LOG_GROUP, a)
     1240#define LogRelMax2(a_cMax, a)       LogRelMaxIt(a_cMax, RTLOGGRPFLAGS_LEVEL_2,  LOG_GROUP, a)
    12241241
    12251242/** @def LogRelMax3
    12261243 * Level 3 logging.
    12271244 */
    1228 #define LogRelMax3(a_cMax, a)       LogRelMaxIt(a_cMax, LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_3,  LOG_GROUP, a)
     1245#define LogRelMax3(a_cMax, a)       LogRelMaxIt(a_cMax, RTLOGGRPFLAGS_LEVEL_3,  LOG_GROUP, a)
    12291246
    12301247/** @def LogRelMax4
    12311248 * Level 4 logging.
    12321249 */
    1233 #define LogRelMax4(a_cMax, a)       LogRelMaxIt(a_cMax, LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_4,  LOG_GROUP, a)
     1250#define LogRelMax4(a_cMax, a)       LogRelMaxIt(a_cMax, RTLOGGRPFLAGS_LEVEL_4,  LOG_GROUP, a)
    12341251
    12351252/** @def LogRelMax5
    12361253 * Level 5 logging.
    12371254 */
    1238 #define LogRelMax5(a_cMax, a)       LogRelMaxIt(a_cMax, LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_5,  LOG_GROUP, a)
     1255#define LogRelMax5(a_cMax, a)       LogRelMaxIt(a_cMax, RTLOGGRPFLAGS_LEVEL_5,  LOG_GROUP, a)
    12391256
    12401257/** @def LogRelMax6
    12411258 * Level 6 logging.
    12421259 */
    1243 #define LogRelMax6(a_cMax, a)       LogRelMaxIt(a_cMax, LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_6,  LOG_GROUP, a)
     1260#define LogRelMax6(a_cMax, a)       LogRelMaxIt(a_cMax, RTLOGGRPFLAGS_LEVEL_6,  LOG_GROUP, a)
    12441261
    12451262/** @def LogRelFlow
    12461263 * Logging of execution flow.
    12471264 */
    1248 #define LogRelMaxFlow(a_cMax, a)    LogRelMaxIt(a_cMax, LOG_REL_INSTANCE, RTLOGGRPFLAGS_FLOW,     LOG_GROUP, a)
     1265#define LogRelMaxFlow(a_cMax, a)    LogRelMaxIt(a_cMax, RTLOGGRPFLAGS_FLOW,     LOG_GROUP, a)
    12491266
    12501267/** @def LogRelMaxFunc
    … …  
    12541271#ifdef LOG_USE_C99
    12551272# define LogRelMaxFunc(a_cMax, a) \
    1256     _LogRelMaxIt(a_cMax, LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, LOG_FN_FMT ": %M", \
     1273    _LogRelMaxIt(a_cMax, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, LOG_FN_FMT ": %M", \
    12571274                 __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    12581275# define LogFuncMax(a_cMax, a) \
    1259     _LogItMax(a_cMax, LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, LOG_FN_FMT ": %M", \
     1276    _LogItMax(a_cMax, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, LOG_FN_FMT ": %M", \
    12601277              __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    12611278#else
    … …  
    12721289#ifdef LOG_USE_C99
    12731290# define LogRelMaxThisFunc(a_cMax, a) \
    1274     _LogRelMaxIt(a_cMax, LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, "{%p} " LOG_FN_FMT ": %M", \
     1291    _LogRelMaxIt(a_cMax, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, "{%p} " LOG_FN_FMT ": %M", \
    12751292                 this, __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    12761293#else
    … …  
    12901307#ifdef LOG_USE_C99
    12911308# define LogRelMaxFlowFunc(a_cMax, a) \
    1292     _LogRelMaxIt(a_cMax, LOG_REL_INSTANCE, RTLOGGRPFLAGS_FLOW, LOG_GROUP, LOG_FN_FMT ": %M", \
     1309    _LogRelMaxIt(a_cMax, RTLOGGRPFLAGS_FLOW, LOG_GROUP, LOG_FN_FMT ": %M", \
    12931310                 __PRETTY_FUNCTION__, _LogRemoveParentheseis a )
    12941311#else
    … …  
    13011318 * Checks whether the specified logging group is enabled or not.
    13021319 */
    1303 #define LogRelIsItEnabled(a_pvInst, a_fFlags, a_iGroup) \
    1304     LogRelIsItEnabledInternal((a_pvInst), (unsigned)(a_iGroup), (unsigned)(a_fFlags))
     1320#define LogRelIsItEnabled(a_fFlags, a_iGroup) \
     1321    ( RTLogRelGetDefaultInstanceEx((uint32_t)(a_fFlags), (uint32_t)(a_iGroup)) != NULL )
    13051322
    13061323/** @def LogRelIsEnabled
    13071324 * Checks whether level 1 logging is enabled.
    13081325 */
    1309 #define LogRelIsEnabled()      LogRelIsItEnabled(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP)
     1326#define LogRelIsEnabled()      LogRelIsItEnabled(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP)
    13101327
    13111328/** @def LogRelIs2Enabled
    13121329 * Checks whether level 2 logging is enabled.
    13131330 */
    1314 #define LogRelIs2Enabled()     LogRelIsItEnabled(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP)
     1331#define LogRelIs2Enabled()     LogRelIsItEnabled(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP)
    13151332
    13161333/** @def LogRelIs3Enabled
    13171334 * Checks whether level 3 logging is enabled.
    13181335 */
    1319 #define LogRelIs3Enabled()     LogRelIsItEnabled(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_3, LOG_GROUP)
     1336#define LogRelIs3Enabled()     LogRelIsItEnabled(RTLOGGRPFLAGS_LEVEL_3, LOG_GROUP)
    13201337
    13211338/** @def LogRelIs4Enabled
    13221339 * Checks whether level 4 logging is enabled.
    13231340 */
    1324 #define LogRelIs4Enabled()     LogRelIsItEnabled(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_4, LOG_GROUP)
     1341#define LogRelIs4Enabled()     LogRelIsItEnabled(RTLOGGRPFLAGS_LEVEL_4, LOG_GROUP)
    13251342
    13261343/** @def LogRelIs5Enabled
    13271344 * Checks whether level 5 logging is enabled.
    13281345 */
    1329 #define LogRelIs5Enabled()     LogRelIsItEnabled(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP)
     1346#define LogRelIs5Enabled()     LogRelIsItEnabled(RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP)
    13301347
    13311348/** @def LogRelIs6Enabled
    13321349 * Checks whether level 6 logging is enabled.
    13331350 */
    1334 #define LogRelIs6Enabled()     LogRelIsItEnabled(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_6, LOG_GROUP)
     1351#define LogRelIs6Enabled()     LogRelIsItEnabled(RTLOGGRPFLAGS_LEVEL_6, LOG_GROUP)
    13351352
    13361353/** @def LogRelIsFlowEnabled
    13371354 * Checks whether execution flow logging is enabled.
    13381355 */
    1339 #define LogRelIsFlowEnabled()  LogRelIsItEnabled(LOG_REL_INSTANCE, RTLOGGRPFLAGS_FLOW, LOG_GROUP)
     1356#define LogRelIsFlowEnabled()  LogRelIsItEnabled(RTLOGGRPFLAGS_FLOW, LOG_GROUP)
    13401357
    13411358
    … …  
    13531370 * Gets the default release logger instance.
    13541371 *
    1355  * @returns Pointer to default release logger instance.
    1356  * @returns NULL if no default release logger instance available.
    1357  */
    1358 RTDECL(PRTLOGGER) RTLogRelDefaultInstance(void);
    1359 
    1360 /** Internal worker function.
    1361  * Don't call directly, use the LogRelIsItEnabled macro!
    1362  */
    1363 DECLINLINE(bool) LogRelIsItEnabledInternal(void *pvInst, unsigned iGroup, unsigned fFlags)
    1364 {
    1365     register PRTLOGGER pLogger = (PRTLOGGER)pvInst ? (PRTLOGGER)pvInst : RTLogRelDefaultInstance();
    1366     if (   pLogger
    1367         && !(pLogger->fFlags & RTLOGFLAGS_DISABLED))
    1368     {
    1369         register unsigned fGrpFlags = pLogger->afGroups[(unsigned)iGroup < pLogger->cGroups ? (unsigned)iGroup : 0];
    1370         if ((fGrpFlags & (fFlags | RTLOGGRPFLAGS_ENABLED)) == (fFlags | RTLOGGRPFLAGS_ENABLED))
    1371             return true;
    1372     }
    1373     return false;
    1374 }
     1372 * @returns Pointer to default release logger instance if availble, otherwise NULL.
     1373 */
     1374RTDECL(PRTLOGGER) RTLogRelGetDefaultInstance(void);
     1375
     1376/**
     1377 * Gets the default release logger instance.
     1378 *
     1379 * @returns Pointer to default release logger instance if availble, otherwise NULL.
     1380 * @param   fFlags      The logging group flags required.
     1381 * @param   iGroup      The group.
     1382 */
     1383RTDECL(PRTLOGGER) RTLogRelGetDefaultInstanceEx(uint32_t fFlags, uint32_t iGroup);
    13751384
    13761385/**
    … …  
    15391548# if defined(LOG_USE_C99)
    15401549#  undef _LogIt
    1541 #  define _LogIt(a_pvInst, a_fFlags, a_iGroup, ...)  LogBackdoor((__VA_ARGS__))
     1550#  define _LogIt(a_fFlags, a_iGroup, ...)  LogBackdoor((__VA_ARGS__))
    15421551# endif
    15431552#endif
    … …  
    15501559 * Gets the default logger instance, creating it if necessary.
    15511560 *
    1552  * @returns Pointer to default logger instance.
    1553  * @returns NULL if no default logger instance available.
     1561 * @returns Pointer to default logger instance if availble, otherwise NULL.
    15541562 */
    15551563RTDECL(PRTLOGGER)   RTLogDefaultInstance(void);
    15561564
    15571565/**
     1566 * Gets the logger instance if enabled, creating it if necessary.
     1567 *
     1568 * @returns Pointer to default logger instance, if group has the specified
     1569 *          flags enabled.  Otherwise NULL is returned.
     1570 * @param   fFlags      The logging group flags required.
     1571 * @param   iGroup      The group.
     1572 */
     1573RTDECL(PRTLOGGER)   RTLogDefaultInstanceEx(uint32_t fFlags, uint32_t iGroup);
     1574
     1575/**
    15581576 * Gets the default logger instance.
    15591577 *
    1560  * @returns Pointer to default logger instance.
    1561  * @returns NULL if no default logger instance available.
     1578 * @returns Pointer to default logger instance if availble, otherwise NULL.
    15621579 */
    15631580RTDECL(PRTLOGGER)   RTLogGetDefaultInstance(void);
     1581
     1582/**
     1583 * Gets the default logger instance if enabled.
     1584 *
     1585 * @returns Pointer to default logger instance, if group has the specified
     1586 *          flags enabled.  Otherwise NULL is returned.
     1587 * @param   fFlags      The logging group flags required.
     1588 * @param   iGroup      The group.
     1589 */
     1590RTDECL(PRTLOGGER)   RTLogGetDefaultInstanceEx(uint32_t fFlags, uint32_t iGroup);
    15641591
    15651592#ifndef IN_RC
    … …  
    15701597 * @param   pLogger     The new default logger instance.
    15711598 */
    1572 RTDECL(PRTLOGGER) RTLogSetDefaultInstance(PRTLOGGER pLogger);
     1599RTDECL(PRTLOGGER)   RTLogSetDefaultInstance(PRTLOGGER pLogger);
    15731600#endif /* !IN_RC */
    15741601
    … …  
    15841611 *                      current thread use 0.
    15851612 */
    1586 RTDECL(int) RTLogSetDefaultInstanceThread(PRTLOGGER pLogger, uintptr_t uKey);
     1613RTDECL(int)         RTLogSetDefaultInstanceThread(PRTLOGGER pLogger, uintptr_t uKey);
    15871614#endif /* IN_RING0 */
    15881615
    … …  
    15921619 * Don't call directly, use the LogIsItEnabled macro!
    15931620 */
    1594 DECLINLINE(bool) LogIsItEnabledInternal(void *pvInst, unsigned iGroup, unsigned fFlags)
     1621DECLINLINE(bool)    LogIsItEnabledInternal(unsigned iGroup, unsigned fFlags)
    15951622{
    1596     register PRTLOGGER pLogger = (PRTLOGGER)pvInst ? (PRTLOGGER)pvInst : RTLogDefaultInstance();
     1623    register PRTLOGGER pLogger = RTLogDefaultInstance();
    15971624    if (   pLogger
    15981625        && !(pLogger->fFlags & RTLOGFLAGS_DISABLED))

  • trunk/include/iprt/mangling.h

    r55863 r55980  
    804804# define RTLogDefaultInit                               RT_MANGLER(RTLogDefaultInit)
    805805# define RTLogDefaultInstance                           RT_MANGLER(RTLogDefaultInstance)
     806# define RTLogDefaultInstanceEx                         RT_MANGLER(RTLogDefaultInstanceEx)
    806807# define RTLogDestinations                              RT_MANGLER(RTLogDestinations)
    807808# define RTLogDestroy                                   RT_MANGLER(RTLogDestroy)
    … …  
    813814# define RTLogFormatV                                   RT_MANGLER(RTLogFormatV)
    814815# define RTLogGetDefaultInstance                        RT_MANGLER(RTLogGetDefaultInstance)
     816# define RTLogGetDefaultInstanceEx                      RT_MANGLER(RTLogGetDefaultInstanceEx)
    815817# define RTLogGetDestinations                           RT_MANGLER(RTLogGetDestinations)
    816818# define RTLogGetFlags                                  RT_MANGLER(RTLogGetFlags)
    … …  
    824826# define RTLogPrintfV                                   RT_MANGLER(RTLogPrintfV)
    825827# define RTLogDumpPrintfV                               RT_MANGLER(RTLogDumpPrintfV)
    826 # define RTLogRelDefaultInstance                        RT_MANGLER(RTLogRelDefaultInstance)
     828# define RTLogRelGetDefaultInstance                     RT_MANGLER(RTLogRelGetDefaultInstance)
     829# define RTLogRelGetDefaultInstanceEx                   RT_MANGLER(RTLogRelGetDefaultInstanceEx)
    827830# define RTLogRelLogger                                 RT_MANGLER(RTLogRelLogger)
    828831# define RTLogRelLoggerV                                RT_MANGLER(RTLogRelLoggerV)

  • trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku-stubs.c

    r54608 r55980  
    331331    return g_VBoxGuest->_RTLogDefaultInstance();
    332332}
    333 RTDECL(PRTLOGGER) RTLogRelDefaultInstance(void)
    334 {
    335     return g_VBoxGuest->_RTLogRelDefaultInstance();
     333RTDECL(PRTLOGGER) RTLogDefaultInstanceEx(uint32_t fFlags, uint32_t iGroup)
     334{
     335    return g_VBoxGuest->_RTLogDefaultInstanceEx(fFlags, iGroup);
     336}
     337RTDECL(PRTLOGGER) RTLogRelGetDefaultInstance(void)
     338{
     339    return g_VBoxGuest->_RTLogRelGetDefaultInstance();
     340}
     341RTDECL(PRTLOGGER) RTLogRelGetDefaultInstance(uint32_t fFlags, uint32_t iGroup)
     342{
     343    return g_VBoxGuest->_RTLogRelGetDefaultInstanceEx(fFlags, iGroup);
    336344}
    337345RTDECL(int) RTErrConvertToErrno(int iErr)

  • trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku.c

    r54608 r55980  
    177177    RTMemTmpFree,
    178178    RTLogDefaultInstance,
    179     RTLogRelDefaultInstance,
     179    RTLogDefaultInstanceEx,
     180    RTLogRelGetDefaultInstance,
     181    RTLogRelGetDefaultInstanceEx,
    180182    RTErrConvertToErrno,
    181183    VbgdCommonIoCtl,

  • trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku.h

    r54608 r55980  
    180180    void (*_RTMemTmpFree)(void *pv);
    181181    PRTLOGGER(*_RTLogDefaultInstance)(void);
    182     PRTLOGGER(*_RTLogRelDefaultInstance)(void);
     182    PRTLOGGER(*_RTLogDefaultInstanceEx)(uint32_t fFlags, uint32_t iGroup);
     183    PRTLOGGER(*_RTLogRelGetDefaultInstance)(void);
     184    PRTLOGGER(*_RTLogRelGetDefaultInstanceEx)(uint32_t fFlags, uint32_t iGroup);
    183185    int (*_RTErrConvertToErrno)(int iErr);
    184186    int (*_VbgdCommonIoCtl)(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,

  • trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-linux.c

    r54610 r55980  
    957957    if (g_fLoggerCreated)
    958958    {
    959         PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelDefaultInstance();
     959        PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
    960960        if (pLogger)
    961961            RTLogGroupSettings(pLogger, pszValue);
    … …  
    970970static int vboxguestLinuxParamLogGrpGet(char *pszBuf, struct kernel_param *pParam)
    971971{
    972     PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelDefaultInstance();
     972    PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
    973973    *pszBuf = '\0';
    974974    if (pLogger)
    … …  
    983983    if (g_fLoggerCreated)
    984984    {
    985         PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelDefaultInstance();
     985        PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
    986986        if (pLogger)
    987987            RTLogFlags(pLogger, pszValue);
    … …  
    995995static int vboxguestLinuxParamLogFlagsGet(char *pszBuf, struct kernel_param *pParam)
    996996{
    997     PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelDefaultInstance();
     997    PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
    998998    *pszBuf = '\0';
    999999    if (pLogger)
    … …  
    10081008    if (g_fLoggerCreated)
    10091009    {
    1010         PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelDefaultInstance();
     1010        PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
    10111011        if (pLogger)
    10121012            RTLogDestinations(pLogger, pszValue);
    … …  
    10201020static int vboxguestLinuxParamLogDstGet(char *pszBuf, struct kernel_param *pParam)
    10211021{
    1022     PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelDefaultInstance();
     1022    PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
    10231023    *pszBuf = '\0';
    10241024    if (pLogger)

  • trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibRuntimeXF86.cpp

    r53972 r55980  
    6565}
    6666
    67 RTDECL(PRTLOGGER) RTLogRelDefaultInstance(void)
     67RTDECL(PRTLOGGER) RTLogRelGetDefaultInstance(void)
    6868{
     69    return NULL;
     70}
     71
     72RTDECL(PRTLOGGER) RTLogRelGetDefaultInstanceEx(uint32_t fFlags, uint32_t iGroup)
     73{
     74    NOREF(fFlags); NOREF(iGroup);
    6975    return NULL;
    7076}

  • trunk/src/VBox/Additions/solaris/DRM/vboxvideo_drm.c

    r52441 r55980  
    2929*   Header Files                                                               *
    3030*******************************************************************************/
    31 #ifdef DEBUG_ramshankar
    32 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    33 #endif
    3431#undef offsetof     /* This gets redefined in drmP.h */
    3532#include "include/drmP.h"

  • trunk/src/VBox/Additions/solaris/Virtio/Virtio-solaris.c

    r44529 r55980  
    2828*   Header Files                                                               *
    2929*******************************************************************************/
    30 #ifdef DEBUG_ramshankar
    31 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    32 #endif
    3330#include "Virtio-solaris.h"
    3431

  • trunk/src/VBox/Additions/solaris/Virtio/VirtioNet-solaris.c

    r44529 r55980  
    2828*   Header Files                                                               *
    2929*******************************************************************************/
    30 #ifdef DEBUG_ramshankar
    31 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    32 #endif
    3330#include "Virtio-solaris.h"
    3431#include "VirtioPci-solaris.h"

  • trunk/src/VBox/Additions/solaris/Virtio/VirtioPci-solaris.c

    r44529 r55980  
    2828*   Header Files                                                               *
    2929*******************************************************************************/
    30 #ifdef DEBUG_ramshankar
    31 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    32 #endif
    3330#include "VirtioPci-solaris.h"
    3431

  • trunk/src/VBox/Additions/solaris/Virtio/VirtioRing-solaris.c

    r44529 r55980  
    2828*   Header Files                                                               *
    2929*******************************************************************************/
    30 #ifdef DEBUG_ramshankar
    31 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    32 #endif
    3330#include "Virtio-solaris.h"
    3431

  • trunk/src/VBox/Additions/x11/VBoxClient/main.cpp

    r55440 r55980  
    301301            /* If the user is running in "no daemon" mode anyway, send critical
    302302             * logging to stdout as well. */
    303             PRTLOGGER pReleaseLog = RTLogRelDefaultInstance();
    304 
     303            PRTLOGGER pReleaseLog = RTLogRelGetDefaultInstance();
    305304            if (pReleaseLog)
    306305                rc = RTLogDestinations(pReleaseLog, "stdout");

  • trunk/src/VBox/Debugger/DBGCCommands.cpp

    r55881 r55980  
    12181218{
    12191219    RTLogFlush(NULL);
    1220     PRTLOGGER pLogRel = RTLogRelDefaultInstance();
     1220    PRTLOGGER pLogRel = RTLogRelGetDefaultInstance();
    12211221    if (pLogRel)
    12221222        RTLogFlush(pLogRel);

  • trunk/src/VBox/Devices/Network/DevE1000.cpp

    r55534 r55980  
    173173#  define E1kLog2(a)              Log2(a)
    174174#  define E1kLog3(a)              Log3(a)
    175 #  define E1kLogX(x, a)           LogIt(LOG_INSTANCE, x, LOG_GROUP, a)
     175#  define E1kLogX(x, a)           LogIt(x, LOG_GROUP, a)
    176176//#  define E1kLog(a)               do {} while (0)
    177177//#  define E1kLog2(a)              do {} while (0)

  • trunk/src/VBox/Devices/Network/lwip-new/vbox/include/lwip-log.h

    r50273 r55980  
    7373#ifdef LOG_ENABLED
    7474
    75 #define LWIP_DEBUGF(_when, _args)                                      \
    76     do {                                                                \
     75# define LWIP_DEBUGF(_when, _args) \
     76    do { \
    7777        const VBOX_LOGGROUP _group = (_when) >> LWIP_DEBUGF_LOG_GROUP_SHIFT; \
    78         if (_group >= LOG_GROUP_DEFAULT) {                              \
     78        if (_group >= LOG_GROUP_DEFAULT) { \
    7979            /* severe => l1; serious => l2; warning => l3; default => l4 */ \
    80             const unsigned int _level =                                 \
    81                 1 << (LWIP_DBG_MASK_LEVEL+1 - ((_when) & LWIP_DBG_MASK_LEVEL)); \
    82             LogIt(LOG_INSTANCE, _level, _group, _args);                 \
    83         }                                                               \
     80            const unsigned int _level = 1U << (LWIP_DBG_MASK_LEVEL + 1 - ((_when) & LWIP_DBG_MASK_LEVEL)); \
     81            LogIt(_level, _group, _args);  \
     82        } \
    8483    } while (0)
    8584
    8685#else  /* !LOG_ENABLED */
    8786
    88 #define LWIP_DEBUGF(_when, _args) do { } while (0)
     87# define LWIP_DEBUGF(_when, _args) do { } while (0)
    8988
    9089#endif /* !LOG_ENABLED */

  • trunk/src/VBox/Devices/USB/solaris/USBProxyDevice-solaris.cpp

    r50237 r55980  
    2121*******************************************************************************/
    2222#define LOG_GROUP LOG_GROUP_DRV_USBPROXY
    23 #ifdef DEBUG_ramshankar
    24 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    25 #endif
    2623#include <sys/poll.h>
    2724#include <errno.h>

  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r55275 r55980  
    21772177                    ("not null terminated\n"), VERR_INVALID_PARAMETER);
    21782178
    2179     LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("DEBUG LOG: %s", pReq->szString));
     2179    LogIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("DEBUG LOG: %s", pReq->szString));
    21802180    return VINF_SUCCESS;
    21812181}
    … …  
    28662866        switch (u32)
    28672867        {
    2868             case '\r': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <return>\n")); break;
    2869             case '\n': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <newline>\n")); break;
    2870             case '\t': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <tab>\n")); break;
    2871             default:   LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: %c (%02x)\n", u32, u32)); break;
     2868            case '\r': LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <return>\n")); break;
     2869            case '\n': LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <newline>\n")); break;
     2870            case '\t': LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <tab>\n")); break;
     2871            default:   LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: %c (%02x)\n", u32, u32)); break;
    28722872        }
    28732873
    … …  
    28772877            pThis->szMsg[pThis->iMsg] = '\0';
    28782878            if (pThis->iMsg)
    2879                 LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("VMMDev: Guest Log: %s\n", pThis->szMsg));
     2879                LogRelIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("VMMDev: Guest Log: %s\n", pThis->szMsg));
    28802880            pThis->iMsg = 0;
    28812881        }
    … …  
    28852885            {
    28862886                pThis->szMsg[pThis->iMsg] = '\0';
    2887                 LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("VMMDev: Guest Log: %s\n", pThis->szMsg));
     2887                LogRelIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("VMMDev: Guest Log: %s\n", pThis->szMsg));
    28882888                pThis->iMsg = 0;
    28892889            }

  • trunk/src/VBox/HostDrivers/Support/SUPDrv.cpp

    r55863 r55980  
    228228    { "RTHandleTableLookupWithCtx",             (void *)RTHandleTableLookupWithCtx },
    229229    { "RTLogDefaultInstance",                   (void *)RTLogDefaultInstance },
     230    { "RTLogDefaultInstanceEx",                 (void *)RTLogDefaultInstanceEx },
    230231    { "RTLogGetDefaultInstance",                (void *)RTLogGetDefaultInstance },
     232    { "RTLogGetDefaultInstanceEx",              (void *)RTLogGetDefaultInstanceEx },
    231233    { "RTLogLoggerExV",                         (void *)RTLogLoggerExV },
    232234    { "RTLogPrintfV",                           (void *)RTLogPrintfV },
    233     { "RTLogRelDefaultInstance",                (void *)RTLogRelDefaultInstance },
     235    { "RTLogRelDefaultInstance",                (void *)RTLogRelGetDefaultInstance },
     236    { "RTLogRelGetDefaultInstance",             (void *)RTLogRelGetDefaultInstance },
     237    { "RTLogRelGetDefaultInstanceEx",           (void *)RTLogRelGetDefaultInstanceEx },
    234238    { "RTLogSetDefaultInstanceThread",          (void *)RTLogSetDefaultInstanceThread },
    235239    { "RTMemAllocExTag",                        (void *)RTMemAllocExTag },
    … …  
    53285332
    53295333        case SUPLOGGERSETTINGS_WHICH_RELEASE:
    5330             pLogger = RTLogRelDefaultInstance();
     5334            pLogger = RTLogRelGetDefaultInstance();
    53315335            break;
    53325336

  • trunk/src/VBox/HostDrivers/Support/SUPDrvIOC.h

    r55863 r55980  
    213213 *
    214214 * @todo Pending work on next major version change:
    215  *          - (nothing)
    216  */
    217 #define SUPDRV_IOC_VERSION                              0x00220000
     215 *          - Remove RTLogRelDefaultInstance export from SUPDrv.cpp.
     216 */
     217#define SUPDRV_IOC_VERSION                              0x00220001
    218218
    219219/** SUP_IOCTL_COOKIE. */

  • trunk/src/VBox/HostDrivers/Support/SUPLib.cpp

    r55436 r55980  
    280280        CookieReq.u.In.u32ReqVersion = SUPDRV_IOC_VERSION;
    281281        const uint32_t uMinVersion = (SUPDRV_IOC_VERSION & 0xffff0000) == 0x00200000
    282                                    ? 0x00200000
     282                                   ? 0x00200001
    283283                                   : SUPDRV_IOC_VERSION & 0xffff0000;
    284284        CookieReq.u.In.u32MinVersion = uMinVersion;
    … …  
    493493        { "RTTimerCanDoHighResolution",             0xefef003a },
    494494        { "RTLogDefaultInstance",                   0xefef003b },
    495         { "RTLogRelDefaultInstance",                0xefef003c },
     495        { "RTLogRelGetDefaultInstance",             0xefef003c },
    496496        { "RTLogSetDefaultInstanceThread",          0xefef003d },
    497497        { "RTLogLogger",                            0xefef003e },

  • trunk/src/VBox/HostDrivers/Support/solaris/SUPDrv-solaris.c

    r54581 r55980  
    2929*******************************************************************************/
    3030#define LOG_GROUP LOG_GROUP_SUP_DRV
    31 #ifdef DEBUG_ramshankar
    32 # define LOG_ENABLED
    33 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    34 #endif
    3531#include <sys/types.h>
    3632#include <sys/param.h>

  • trunk/src/VBox/HostDrivers/VBoxNetAdp/solaris/VBoxNetAdp-solaris.c

    r50664 r55980  
    2929*******************************************************************************/
    3030#define LOG_GROUP LOG_GROUP_NET_ADP_DRV
    31 #ifdef DEBUG_ramshankar
    32 # define LOG_ENABLED
    33 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    34 #endif
    3531#include <VBox/log.h>
    3632#include <VBox/err.h>

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/solaris/VBoxNetFlt-solaris.c

    r52618 r55980  
    2929*******************************************************************************/
    3030#define LOG_GROUP LOG_GROUP_NET_FLT_DRV
    31 #ifdef DEBUG_ramshankar
    32 # define LOG_ENABLED
    33 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    34 #endif
    3531#include <VBox/log.h>
    3632#include <VBox/err.h>

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/solaris/VBoxNetFltBow-solaris.c

    r54909 r55980  
    2929*******************************************************************************/
    3030#define LOG_GROUP LOG_GROUP_NET_FLT_DRV
    31 #ifdef DEBUG_ramshankar
    32 # define LOG_ENABLED
    33 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    34 #endif
    3531#include <VBox/log.h>
    3632#include <VBox/err.h>

  • trunk/src/VBox/HostDrivers/VBoxUSB/solaris/USBLib-solaris.cpp

    r47496 r55980  
    2020*   Header Files                                                               *
    2121*******************************************************************************/
    22 #ifdef DEBUG_ramshankar
    23 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    24 #endif
    2522#include <VBox/usblib.h>
    2623#include <VBox/err.h>

  • trunk/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSB-solaris.c

    r52750 r55980  
    2929*******************************************************************************/
    3030#define LOG_GROUP LOG_GROUP_USB_DRV
    31 #ifdef DEBUG_ramshankar
    32 # define LOG_ENABLED
    33 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    34 #endif
    3531#include <VBox/version.h>
    3632#include <VBox/log.h>

  • trunk/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSBMon-solaris.c

    r50630 r55980  
    2929*******************************************************************************/
    3030#define LOG_GROUP  LOG_GROUP_USB_DRV
    31 #ifdef DEBUG_ramshankar
    32 # define LOG_ENABLED
    33 # define LOG_INSTANCE       RTLogRelDefaultInstance()
    34 #endif
    3531#include "VBoxUSBFilterMgr.h"
    3632#include <VBox/usblib-solaris.h>

  • trunk/src/VBox/Main/src-all/Logging.cpp

    r55401 r55980  
    11/* $Id$ */
    22/** @file
    3  *
    43 * VirtualBox Main Logging
    54 */
    … …  
    1918
    2019/*
    21  *  Main now always uses the default LOG_INSTANCE for logging,
    22  *  so nothing to do here for now.
     20 *  Main now always uses the defaults for logging, so nothing to do
     21 *  here for now.
    2322 */
    2423/* vi: set tabstop=4 shiftwidth=4 expandtab: */

  • trunk/src/VBox/Main/src-client/MachineDebuggerImpl.cpp

    r55885 r55980  
    529529HRESULT MachineDebugger::getLogRelFlags(com::Utf8Str &aLogRelFlags)
    530530{
    531     HRESULT hrc = i_logStringProps(RTLogRelDefaultInstance(), RTLogGetFlags, "RTGetFlags", aLogRelFlags);
    532 
     531    HRESULT hrc = i_logStringProps(RTLogRelGetDefaultInstance(), RTLogGetFlags, "RTGetFlags", aLogRelFlags);
    533532    return hrc;
    534533}
    … …  
    536535HRESULT MachineDebugger::getLogRelGroups(com::Utf8Str &aLogRelGroups)
    537536{
    538     HRESULT hrc = i_logStringProps(RTLogRelDefaultInstance(), RTLogGetGroupSettings, "RTLogGetGroupSettings", aLogRelGroups);
    539 
     537    HRESULT hrc = i_logStringProps(RTLogRelGetDefaultInstance(), RTLogGetGroupSettings, "RTLogGetGroupSettings", aLogRelGroups);
    540538    return hrc;
    541539}
    … …  
    543541HRESULT MachineDebugger::getLogRelDestinations(com::Utf8Str &aLogRelDestinations)
    544542{
    545     HRESULT hrc = i_logStringProps(RTLogRelDefaultInstance(), RTLogGetDestinations, "RTLogGetDestinations", aLogRelDestinations);
    546 
     543    HRESULT hrc = i_logStringProps(RTLogRelGetDefaultInstance(), RTLogGetDestinations, "RTLogGetDestinations", aLogRelDestinations);
    547544    return hrc;
    548545}

  • trunk/src/VBox/Main/src-server/SystemPropertiesImpl.cpp

    r55843 r55980  
    11831183    if (useLoggingLevel.isEmpty())
    11841184        useLoggingLevel = VBOXSVC_LOG_DEFAULT;
    1185     int rc = RTLogGroupSettings(RTLogRelDefaultInstance(), useLoggingLevel.c_str());
     1185    int rc = RTLogGroupSettings(RTLogRelGetDefaultInstance(), useLoggingLevel.c_str());
    11861186    //  If failed and not the default logging level - try to use the default logging level.
    11871187    if (RT_FAILURE(rc))
    … …  
    11921192        if (!useLoggingLevel.equals(VBOXSVC_LOG_DEFAULT))
    11931193        {
    1194             rc = RTLogGroupSettings(RTLogRelDefaultInstance(), VBOXSVC_LOG_DEFAULT);
     1194            rc = RTLogGroupSettings(RTLogRelGetDefaultInstance(), VBOXSVC_LOG_DEFAULT);
    11951195            // If failed report this to the release log.
    11961196            if (RT_FAILURE(rc))

  • trunk/src/VBox/Main/src-server/win/svcmain.cpp

    r55401 r55980  
    9999             * running at this point which would rotate the logs concurrently,
    100100             * creating a mess. */
    101             PRTLOGGER pReleaseLogger = RTLogRelDefaultInstance();
     101            PRTLOGGER pReleaseLogger = RTLogRelGetDefaultInstance();
    102102            if (pReleaseLogger)
    103103            {

  • trunk/src/VBox/Runtime/VBox/VBoxRTImp.def

    r54270 r55980  
    610610    RTLogDefaultInit
    611611    RTLogDefaultInstance
     612    RTLogDefaultInstanceEx
    612613    RTLogDestinations
    613614    RTLogDestroy
    … …  
    618619    RTLogFormatV
    619620    RTLogGetDefaultInstance
     621    RTLogGetDefaultInstanceEx
    620622    RTLogGetDestinations
    621623    RTLogGetFlags
    … …  
    628630    RTLogPrintf
    629631    RTLogPrintfV
    630     RTLogRelDefaultInstance
     632    RTLogRelGetDefaultInstance
     633    RTLogRelGetDefaultInstanceEx
    631634    RTLogRelLogger
    632635    RTLogRelLoggerV

  • trunk/src/VBox/Runtime/VBox/logbackdoor-redirect.cpp

    r48935 r55980  
    77
    88/*
    9  * Copyright (C) 2007-2011 Oracle Corporation
     9 * Copyright (C) 2007-2015 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2727 */
    2828
     29
    2930/*******************************************************************************
    3031*   Header Files                                                               *
    … …  
    3637
    3738/* All release logging goes to the backdoor logger anyway. */
    38 RTDECL(PRTLOGGER) RTLogRelDefaultInstance(void)
     39RTDECL(PRTLOGGER) RTLogRelGetDefaultInstance(void)
     40{
     41    return NULL;
     42}
     43
     44
     45/* All release logging goes to the backdoor logger anyway. */
     46RTDECL(PRTLOGGER) RTLogRelGetDefaultInstanceEx(uint32_t fFlags, uint32_t iGroup)
    3947{
    4048    return NULL;
    … …  
    4856}
    4957
     58
     59/* All logging goes to the backdoor logger anyway. */
     60RTDECL(PRTLOGGER) RTLogDefaultInstanceEx(uint32_t fFlags, uint32_t iGroup)
     61{
     62    return NULL;
     63}
     64
     65
    5066/* All logging goes to the backdoor logger anyway. */
    5167RTDECL(PRTLOGGER) RTLogRelSetDefaultInstance(PRTLOGGER pLogger)
    … …  
    5369    return NULL;
    5470}
     71
    5572
    5673RTDECL(void) RTLogRelPrintf(const char *pszFormat, ...)
    … …  
    108125    return VERR_NOT_IMPLEMENTED;
    109126}
     127

  • trunk/src/VBox/Runtime/common/log/log.cpp

    r55436 r55980  
    25762576
    25772577/**
    2578  * Gets the default logger instance, creating it if necessary.
    2579  *
    2580  * @returns Pointer to default logger instance.
    2581  * @returns NULL if no default logger instance available.
    2582  */
    2583 RTDECL(PRTLOGGER)   RTLogDefaultInstance(void)
     2578 * Common worker for RTLogDefaultInstance and RTLogDefaultInstanceEx.
     2579 */
     2580DECL_FORCE_INLINE(PRTLOGGER) rtLogDefaultInstanceCommon(void)
    25842581{
    25852582#ifdef IN_RC
    … …  
    26092606#endif /* !IN_RC */
    26102607}
     2608
     2609
     2610RTDECL(PRTLOGGER)   RTLogDefaultInstance(void)
     2611{
     2612    return rtLogDefaultInstanceCommon();
     2613}
    26112614RT_EXPORT_SYMBOL(RTLogDefaultInstance);
    26122615
    26132616
    2614 /**
    2615  * Gets the default logger instance.
    2616  *
    2617  * @returns Pointer to default logger instance.
    2618  * @returns NULL if no default logger instance available.
    2619  */
    2620 RTDECL(PRTLOGGER)   RTLogGetDefaultInstance(void)
     2617RTDECL(PRTLOGGER)   RTLogDefaultInstanceEx(uint32_t fFlags, uint32_t iGroup)
     2618{
     2619    PRTLOGGER pLogger = rtLogDefaultInstanceCommon();
     2620    if (pLogger)
     2621    {
     2622        if (pLogger->fFlags & RTLOGFLAGS_DISABLED)
     2623            pLogger = NULL;
     2624        else if (   iGroup != UINT32_MAX
     2625                 && (   (pLogger->afGroups[iGroup < pLogger->cGroups ? iGroup : 0] & (fFlags | RTLOGGRPFLAGS_ENABLED))
     2626                     != (fFlags | RTLOGGRPFLAGS_ENABLED)))
     2627            pLogger = NULL;
     2628    }
     2629    return pLogger;
     2630}
     2631RT_EXPORT_SYMBOL(RTLogDefaultInstanceEx);
     2632
     2633
     2634/**
     2635 * Common worker for RTLogGetDefaultInstance and RTLogGetDefaultInstanceEx.
     2636 */
     2637DECL_FORCE_INLINE(PRTLOGGER) rtLogGetDefaultInstanceCommon(void)
    26212638{
    26222639#ifdef IN_RC
    … …  
    26402657#endif
    26412658}
     2659
     2660
     2661RTDECL(PRTLOGGER) RTLogGetDefaultInstance(void)
     2662{
     2663    return rtLogGetDefaultInstanceCommon();
     2664}
    26422665RT_EXPORT_SYMBOL(RTLogGetDefaultInstance);
     2666
     2667
     2668RTDECL(PRTLOGGER) RTLogGetDefaultInstanceEx(uint32_t fFlags, uint32_t iGroup)
     2669{
     2670    PRTLOGGER pLogger = rtLogGetDefaultInstanceCommon();
     2671    if (pLogger)
     2672    {
     2673        if (pLogger->fFlags & RTLOGFLAGS_DISABLED)
     2674            pLogger = NULL;
     2675        else if (   iGroup != UINT32_MAX
     2676                 && (   (pLogger->afGroups[iGroup < pLogger->cGroups ? iGroup : 0] & (fFlags | RTLOGGRPFLAGS_ENABLED))
     2677                     != (fFlags | RTLOGGRPFLAGS_ENABLED)))
     2678            pLogger = NULL;
     2679    }
     2680    return pLogger;
     2681}
     2682RT_EXPORT_SYMBOL(RTLogGetDefaultInstanceEx);
    26432683
    26442684

  • trunk/src/VBox/Runtime/common/log/logrel.cpp

    r48935 r55980  
    7070
    7171
    72 /**
    73  * Gets the default release logger instance.
    74  *
    75  * @returns Pointer to default release logger instance.
    76  * @returns NULL if no default release logger instance available.
    77  */
    78 RTDECL(PRTLOGGER)   RTLogRelDefaultInstance(void)
     72RTDECL(PRTLOGGER)   RTLogRelGetDefaultInstance(void)
    7973{
    8074#ifdef IN_RC
    … …  
    8478#endif /* !IN_RC */
    8579}
    86 RT_EXPORT_SYMBOL(RTLogRelDefaultInstance);
     80RT_EXPORT_SYMBOL(RTLogRelGetDefaultInstance);
     81
     82
     83RTDECL(PRTLOGGER)   RTLogRelGetDefaultInstanceEx(uint32_t fFlags, uint32_t iGroup)
     84{
     85#ifdef IN_RC
     86    PRTLOGGER pLogger = &g_RelLogger;
     87#else /* !IN_RC */
     88    PRTLOGGER pLogger = g_pRelLogger;
     89#endif /* !IN_RC */
     90    if (pLogger)
     91    {
     92        if (pLogger->fFlags & RTLOGFLAGS_DISABLED)
     93            pLogger = NULL;
     94        else if (   iGroup != UINT32_MAX
     95                 && (   (pLogger->afGroups[iGroup < pLogger->cGroups ? iGroup : 0] & (fFlags | RTLOGGRPFLAGS_ENABLED))
     96                     != (fFlags | RTLOGGRPFLAGS_ENABLED)))
     97            pLogger = NULL;
     98    }
     99    return pLogger;
     100}
     101RT_EXPORT_SYMBOL(RTLogRelGetDefaultInstanceEx);
    87102
    88103
    … …  
    123138    if (!pLogger)
    124139    {
    125         pLogger = RTLogRelDefaultInstance();
     140        pLogger = RTLogRelGetDefaultInstance();
    126141        if (!pLogger)
    127142            return;
    … …  
    157172RTDECL(bool) RTLogRelSetBuffering(bool fBuffered)
    158173{
    159     PRTLOGGER pLogger = RTLogRelDefaultInstance();
     174    PRTLOGGER pLogger = RTLogRelGetDefaultInstance();
    160175    if (pLogger)
    161176        return RTLogSetBuffering(pLogger, fBuffered);

  • trunk/src/VBox/Runtime/common/misc/assert.cpp

    r48935 r55980  
    146146# endif
    147147
    148         PRTLOGGER pLog = RTLogRelDefaultInstance();
     148        PRTLOGGER pLog = RTLogRelGetDefaultInstance();
    149149        if (pLog)
    150150        {
    … …  
    255255# endif
    256256
    257         PRTLOGGER pLog = RTLogRelDefaultInstance();
     257        PRTLOGGER pLog = RTLogRelGetDefaultInstance();
    258258        if (pLog)
    259259        {

  • trunk/src/VBox/Runtime/r3/init.cpp

    r53525 r55980  
    168168            RTLogFlush(pLogger);
    169169
    170         pLogger = RTLogRelDefaultInstance();
     170        pLogger = RTLogRelGetDefaultInstance();
    171171        if (pLogger)
    172172            RTLogFlush(pLogger);

  • trunk/src/VBox/VMM/VMMR0/VMMR0.cpp

    r55864 r55980  
    20762076        va_end(vaCopy);
    20772077    }
    2078     pLog = RTLogRelDefaultInstance();
     2078    pLog = RTLogRelGetDefaultInstance();
    20792079    if (pLog)
    20802080    {

  • trunk/src/VBox/VMM/VMMR0/VMMR0.def

    r54270 r55980  
    3939    IOMMMIOMapMMIO2Page
    4040    RTLogDefaultInstance
    41     RTLogRelDefaultInstance
     41    RTLogDefaultInstanceEx
     42    RTLogRelGetDefaultInstance
     43    RTLogRelGetDefaultInstanceEx
    4244    RTLogLogger
    4345    RTLogLoggerEx

  • trunk/src/VBox/VMM/VMMR3/DBGFLog.cpp

    r46326 r55980  
    4545    {
    4646        *ppsz += sizeof("release:") - 1;
    47         pLogger = RTLogRelDefaultInstance();
     47        pLogger = RTLogRelGetDefaultInstance();
    4848    }
    4949    else

  • trunk/src/VBox/VMM/VMMR3/EMRaw.cpp

    r55001 r55980  
    15411541            default:
    15421542                if (PATMIsPatchGCAddr(pVM, pCtx->eip) && !(pCtx->eflags.u32 & X86_EFL_TF))
    1543                     LogIt(NULL, 0, LOG_GROUP_PATM, ("Patch code interrupted at %RRv for reason %Rrc\n", (RTRCPTR)CPUMGetGuestEIP(pVCpu), rc));
     1543                    LogIt(0, LOG_GROUP_PATM, ("Patch code interrupted at %RRv for reason %Rrc\n", (RTRCPTR)CPUMGetGuestEIP(pVCpu), rc));
    15441544                break;
    15451545        }

  • trunk/src/VBox/VMM/VMMR3/VMM.cpp

    r55863 r55980  
    382382    if (!HMIsEnabled(pVM))
    383383    {
    384         PRTLOGGER pRelLogger = RTLogRelDefaultInstance();
     384        PRTLOGGER pRelLogger = RTLogRelGetDefaultInstance();
    385385        if (pRelLogger)
    386386        {
    … …  
    608608            PRTLOGGERRC pRelLogger = pVM->vmm.s.pRCRelLoggerR3;
    609609            if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
    610                 RTLogFlushRC(RTLogRelDefaultInstance(), pRelLogger);
     610                RTLogFlushRC(RTLogRelGetDefaultInstance(), pRelLogger);
    611611#endif
    612612            if (rc != VINF_VMM_CALL_HOST)
    … …  
    917917
    918918        pVM->vmm.s.pRCRelLoggerRC = MMHyperR3ToRC(pVM, pVM->vmm.s.pRCRelLoggerR3);
    919         rc = RTLogCloneRC(RTLogRelDefaultInstance(), pVM->vmm.s.pRCRelLoggerR3, pVM->vmm.s.cbRCRelLogger,
     919        rc = RTLogCloneRC(RTLogRelGetDefaultInstance(), pVM->vmm.s.pRCRelLoggerR3, pVM->vmm.s.cbRCRelLogger,
    920920                          RCPtrLoggerWrapper, RCPtrLoggerFlush, RTLOGFLAGS_BUFFERED);
    921921        AssertReleaseMsgRC(rc, ("RTLogCloneRC failed! rc=%Rra\n", rc));
    … …  
    13191319        PRTLOGGERRC pRelLogger = pVM->vmm.s.pRCRelLoggerR3;
    13201320        if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
    1321             RTLogFlushRC(RTLogRelDefaultInstance(), pRelLogger);
     1321            RTLogFlushRC(RTLogRelGetDefaultInstance(), pRelLogger);
    13221322#endif
    13231323        if (rc != VINF_VMM_CALL_HOST)
    … …  
    20052005        PRTLOGGERRC pRelLogger = pVM->vmm.s.pRCRelLoggerR3;
    20062006        if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
    2007             RTLogFlushRC(RTLogRelDefaultInstance(), pRelLogger);
     2007            RTLogFlushRC(RTLogRelGetDefaultInstance(), pRelLogger);
    20082008#endif
    20092009        if (rc == VERR_TRPM_PANIC || rc == VERR_TRPM_DONT_PANIC)
    … …  
    21152115        PRTLOGGERRC pRelLogger = pVM->vmm.s.pRCRelLoggerR3;
    21162116        if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
    2117             RTLogFlushRC(RTLogRelDefaultInstance(), pRelLogger);
     2117            RTLogFlushRC(RTLogRelGetDefaultInstance(), pRelLogger);
    21182118# endif
    21192119        if (rc == VERR_TRPM_PANIC || rc == VERR_TRPM_DONT_PANIC)

  • trunk/src/VBox/VMM/VMMR3/VMMGuruMeditation.cpp

    r54728 r55980  
    155155     * The loggers.
    156156     */
    157     pHlp->pRelLogger  = RTLogRelDefaultInstance();
     157    pHlp->pRelLogger  = RTLogRelGetDefaultInstance();
    158158#ifdef LOG_ENABLED
    159159    pHlp->pLogger     = RTLogDefaultInstance();

  • trunk/src/VBox/VMM/VMMR3/VMMTests.cpp

    r54862 r55980  
    223223    PRTLOGGERRC pRelLogger = pVM->vmm.s.pRCRelLoggerR3;
    224224    if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
    225         RTLogFlushRC(RTLogRelDefaultInstance(), pRelLogger);
     225        RTLogFlushRC(RTLogRelGetDefaultInstance(), pRelLogger);
    226226# endif
    227227#endif

  • trunk/src/VBox/VMM/VMMRC/VMMRC.def

    r54270 r55980  
    3737    PGMPhysSimpleDirtyWriteGCPtr
    3838    RTLogDefaultInstance
    39     RTLogRelDefaultInstance
     39    RTLogDefaultInstanceEx
     40    RTLogRelGetDefaultInstance
     41    RTLogRelGetDefaultInstanceEx
    4042    RTTimeMilliTS
    4143    RTTraceBufAddMsgF

  • trunk/src/recompiler/Sun/crt/stdio.h

    r44528 r55980  
    6161
    6262#define fflush(file)            RTLogFlush(NULL)
    63 #define printf(...)             LogIt(LOG_INSTANCE, 0, LOG_GROUP_REM_PRINTF, (__VA_ARGS__))
    64 #define fprintf(logfile, ...)   LogIt(LOG_INSTANCE, 0, LOG_GROUP_REM_PRINTF, (__VA_ARGS__))
     63#define printf(...)             LogIt(0, LOG_GROUP_REM_PRINTF, (__VA_ARGS__))
     64#define fprintf(logfile, ...)   LogIt(0, LOG_GROUP_REM_PRINTF, (__VA_ARGS__))
    6565
    6666#ifdef DEBUG_TMP_LOGGING

  • trunk/src/recompiler/VBoxREMWrapper.cpp

    r55899 r55980  
    10831083    { REMPARMDESC_FLAGS_INT,        sizeof(const char *),       NULL },
    10841084    { REMPARMDESC_FLAGS_VALIST,     0,                          NULL }
     1085};
     1086static const REMPARMDESC g_aArgsRTLogGetDefaultInstanceEx[] =
     1087{
     1088    { REMPARMDESC_FLAGS_INT,        sizeof(uint32_t),           NULL },
     1089    { REMPARMDESC_FLAGS_INT,        sizeof(uint32_t),           NULL }
    10851090};
    10861091static const REMPARMDESC g_aArgsRTLogFlags[] =
    … …  
    13371342    { "RTAssertShouldPanic",                    (void *)(uintptr_t)&RTAssertShouldPanic,            NULL,                                       0,                                                     REMFNDESC_FLAGS_RET_INT,    sizeof(bool),       NULL },
    13381343    { "RTLogDefaultInstance",                   (void *)(uintptr_t)&RTLogDefaultInstance,           NULL,                                       0,                                                     REMFNDESC_FLAGS_RET_INT,    sizeof(PRTLOGGER),  NULL },
    1339     { "RTLogRelDefaultInstance",                (void *)(uintptr_t)&RTLogRelDefaultInstance,        NULL,                                       0,                                                     REMFNDESC_FLAGS_RET_INT,    sizeof(PRTLOGGER),  NULL },
     1344    { "RTLogRelGetDefaultInstance",             (void *)(uintptr_t)&RTLogRelGetDefaultInstance,     NULL,                                       0,                                                     REMFNDESC_FLAGS_RET_INT,    sizeof(PRTLOGGER),  NULL },
     1345    { "RTLogDefaultInstanceEx",                 (void *)(uintptr_t)&RTLogDefaultInstance,           &g_aArgsRTLogGetDefaultInstanceEx[0],       RT_ELEMENTS(g_aArgsRTLogGetDefaultInstanceEx),         REMFNDESC_FLAGS_RET_INT,    sizeof(PRTLOGGER),  NULL },
     1346    { "RTLogRelGetDefaultInstanceEx",           (void *)(uintptr_t)&RTLogRelGetDefaultInstance,     &g_aArgsRTLogGetDefaultInstanceEx[0],       RT_ELEMENTS(g_aArgsRTLogGetDefaultInstanceEx),         REMFNDESC_FLAGS_RET_INT,    sizeof(PRTLOGGER),  NULL },
    13401347    { "RTLogFlags",                             (void *)(uintptr_t)&RTLogFlags,                     &g_aArgsRTLogFlags[0],                      RT_ELEMENTS(g_aArgsRTLogFlags),                        REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    13411348    { "RTLogFlush",                             (void *)(uintptr_t)&RTLogFlush,                     &g_aArgsRTLogFlush[0],                      RT_ELEMENTS(g_aArgsRTLogFlush),                        REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },

  • trunk/src/recompiler/VBoxRecompiler.c

    r55899 r55980  
    19721972{
    19731973    LogFlow(("remR3TimersRun:\n"));
    1974     LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP_TM, ("remR3TimersRun\n"));
     1974    LogIt(RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP_TM, ("remR3TimersRun\n"));
    19751975    remR3ProfileStop(STATS_QEMU_RUN_EMULATED_CODE);
    19761976    remR3ProfileStart(STATS_QEMU_RUN_TIMERS);
    … …  
    42984298        if (pVM->rem.s.Env.pVCpu == pVCpuDst)
    42994299        {
    4300             LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP_TM, ("REMR3NotifyTimerPending: setting\n"));
     4300            LogIt(RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP_TM, ("REMR3NotifyTimerPending: setting\n"));
    43014301            ASMAtomicOrS32((int32_t volatile *)&pVM->rem.s.Env.interrupt_request,
    43024302                           CPU_INTERRUPT_EXTERNAL_TIMER);
    43034303        }
    43044304        else
    4305             LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP_TM, ("REMR3NotifyTimerPending: pVCpu:%p != pVCpuDst:%p\n", pVM->rem.s.Env.pVCpu, pVCpuDst));
     4305            LogIt(RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP_TM, ("REMR3NotifyTimerPending: pVCpu:%p != pVCpuDst:%p\n", pVM->rem.s.Env.pVCpu, pVCpuDst));
    43064306    }
    43074307    else
    4308         LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP_TM, ("REMR3NotifyTimerPending: !fInREM; cpu state=%d\n", VMCPU_GET_STATE(pVCpuDst)));
     4308        LogIt(RTLOGGRPFLAGS_LEVEL_5, LOG_GROUP_TM, ("REMR3NotifyTimerPending: !fInREM; cpu state=%d\n", VMCPU_GET_STATE(pVCpuDst)));
    43094309#endif
    43104310}

  • trunk/src/recompiler/osdep.h

    r37675 r55980  
    3030/* Misc wrappers */
    3131#define fflush(file)            RTLogFlush(NULL)
    32 #define printf(...)             LogIt(LOG_INSTANCE, 0, LOG_GROUP_REM_PRINTF, (__VA_ARGS__))
     32#define printf(...)             LogIt(0, LOG_GROUP_REM_PRINTF, (__VA_ARGS__))
    3333/* If DEBUG_TMP_LOGGING - goes to QEMU log file */
    3434#ifndef DEBUG_TMP_LOGGING
    35 # define fprintf(logfile, ...)  LogIt(LOG_INSTANCE, 0, LOG_GROUP_REM_PRINTF, (__VA_ARGS__))
     35# define fprintf(logfile, ...)  LogIt(0, LOG_GROUP_REM_PRINTF, (__VA_ARGS__))
    3636#endif
    3737

  • trunk/src/recompiler/qemu-log.h

    r37689 r55980  
    5050# define qemu_log_vprintf(fmt, va) do { \
    5151        if (LogIsEnabled()) \
    52             RTLogLoggerExV(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, fmt, va); \
     52            RTLogLoggerExV(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP, fmt, va); \
    5353    } while (0)
    5454#endif
    … …  
    100100#define qemu_log_flush() fflush(logfile)
    101101#else
    102 # define qemu_log_flush()           RTLogFlush(LOG_INSTANCE)
     102# define qemu_log_flush()           RTLogFlush(NULL)
    103103#endif
    104104
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette