VirtualBox

Changeset 55980 in vbox for trunk/src


Ignore:
Timestamp:
May 20, 2015 5:35:22 PM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
100489
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/src
Files:
49 edited

Legend:

Unmodified
Added
Removed

  • 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