VirtualBox

Changeset 41040 in vbox


Ignore:
Timestamp:
Apr 24, 2012 10:13:40 AM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
77602
Message:

Main+Frontends: move release logging setup to the glue code (to eliminate spreading code duplication), various minor fixes and cleanups

Location:
trunk
Files:
1 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/com/com.h

    r35638 r41040  
    55
    66/*
    7  * Copyright (C) 2006-2007 Oracle Corporation
     7 * Copyright (C) 2005-2012 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    7878 *  @return         VBox status code.
    7979 */
    80 int GetVBoxUserHomeDirectory (char *aDir, size_t aDirLen);
     80int GetVBoxUserHomeDirectory(char *aDir, size_t aDirLen);
     81
     82/**
     83 *  Creates a release log file, used both in VBoxSVC and in API clients.
     84 *
     85 *  @param pcszEntity       Human readable name of the program.
     86 *  @param pcszLogFile      Name of the release log file.
     87 *  @param fFlags           Logger instance flags.
     88 *  @param pcszGroupSettings Group logging settings.
     89 *  @param pcszEnvVarBase   Base environment variable name for the logger.
     90 *  @param fDestFlags       Logger destination flags.
     91 *  @param cMaxEntriesPerGroup Limit for log entries per group. UINT32_MAX for no limit.
     92 *  @param cHistory         Number of old log files to keep.
     93 *  @param uHistoryFileTime Maximum amount of time to put in a log file.
     94 *  @param uHistoryFileSize Maximum size of a log file before rotating.
     95 *  @param pszError         In case of creation failure: buffer for error message.
     96 *  @param cbError          Size of error message buffer.
     97 *  @return         VBox status code.
     98 */
     99int VBoxLogRelCreate(const char *pcszEntity, const char *pcszLogFile,
     100                     uint32_t fFlags, const char *pcszGroupSettings,
     101                     const char *pcszEnvVarBase, uint32_t fDestFlags,
     102                     uint32_t cMaxEntriesPerGroup, uint32_t cHistory,
     103                     uint32_t uHistoryFileTime, uint64_t uHistoryFileSize,
     104                     char *pszError, size_t cbError);
    81105
    82106} /* namespace com */

  • trunk/src/VBox/Frontends/VBoxBalloonCtrl/VBoxWatchdog.cpp

    r40013 r41040  
    784784}
    785785
    786 static void logHeaderFooter(PRTLOGGER pLoggerRelease, RTLOGPHASE enmPhase, PFNRTLOGPHASEMSG pfnLog)
    787 {
    788     /* Some introductory information. */
    789     static RTTIMESPEC s_TimeSpec;
    790     char szTmp[256];
    791     if (enmPhase == RTLOGPHASE_BEGIN)
    792         RTTimeNow(&s_TimeSpec);
    793     RTTimeSpecToString(&s_TimeSpec, szTmp, sizeof(szTmp));
    794 
    795     switch (enmPhase)
    796     {
    797         case RTLOGPHASE_BEGIN:
    798         {
    799             pfnLog(pLoggerRelease,
    800                    "VirtualBox Watchdog %s r%u %s (%s %s) release log\n"
    801 #ifdef VBOX_BLEEDING_EDGE
    802                    "EXPERIMENTAL build " VBOX_BLEEDING_EDGE "\n"
    803 #endif
    804                    "Log opened %s\n",
    805                    VBOX_VERSION_STRING, RTBldCfgRevision(), VBOX_BUILD_TARGET,
    806                    __DATE__, __TIME__, szTmp);
    807 
    808             int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
    809             if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    810                 pfnLog(pLoggerRelease, "OS Product: %s\n", szTmp);
    811             vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
    812             if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    813                 pfnLog(pLoggerRelease, "OS Release: %s\n", szTmp);
    814             vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
    815             if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    816                 pfnLog(pLoggerRelease, "OS Version: %s\n", szTmp);
    817             if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    818                 pfnLog(pLoggerRelease, "OS Service Pack: %s\n", szTmp);
    819 
    820             /* the package type is interesting for Linux distributions */
    821             char szExecName[RTPATH_MAX];
    822             char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
    823             pfnLog(pLoggerRelease,
    824                    "Executable: %s\n"
    825                    "Process ID: %u\n"
    826                    "Package type: %s"
    827 #ifdef VBOX_OSE
    828                    " (OSE)"
    829 #endif
    830                    "\n",
    831                    pszExecName ? pszExecName : "unknown",
    832                    RTProcSelf(),
    833                    VBOX_PACKAGE_STRING);
    834             break;
    835         }
    836 
    837         case RTLOGPHASE_PREROTATE:
    838             pfnLog(pLoggerRelease, "Log rotated - Log started %s\n", szTmp);
    839             break;
    840 
    841         case RTLOGPHASE_POSTROTATE:
    842             pfnLog(pLoggerRelease, "Log continuation - Log started %s\n", szTmp);
    843             break;
    844 
    845         case RTLOGPHASE_END:
    846             pfnLog(pLoggerRelease, "End of log file - Log started %s\n", szTmp);
    847             break;
    848 
    849         default:
    850             /* nothing */;
    851     }
    852 }
    853 
    854786static void displayHeader()
    855787{
    … …  
    11121044    displayHeader();
    11131045
    1114     /* create release logger */
    1115     PRTLOGGER pLoggerRelease;
    1116     static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
    1117     RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
    1118 #if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
    1119     fFlags |= RTLOGFLAGS_USECRLF;
    1120 #endif
    1121     char szError[RTPATH_MAX + 128] = "";
    1122     rc = RTLogCreateEx(&pLoggerRelease, fFlags, "all",
    1123                        "VBOXBALLOONCTRL_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups, RTLOGDEST_STDOUT,
    1124                        logHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
    1125                        szError, sizeof(szError), pszLogFile);
    1126     if (RT_SUCCESS(rc))
    1127     {
    1128         /* register this logger as the release logger */
    1129         RTLogRelSetDefaultInstance(pLoggerRelease);
    1130 
    1131         /* Explicitly flush the log in case of VBOXWEBSRV_RELEASE_LOG=buffered. */
    1132         RTLogFlush(pLoggerRelease);
    1133     }
    1134     else
     1046    /* create release logger, to stdout */
     1047    char szError[RTPATH_MAX + 128];
     1048    rc = com::VBoxLogRelCreate("Watchdog", g_fDaemonize ? NULL : pszLogFile,
     1049                               RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG,
     1050                               "all", "VBOXBALLOONCTRL_RELEASE_LOG",
     1051                               RTLOGDEST_STDOUT, UINT32_MAX /* cMaxEntriesPerGroup */,
     1052                               g_cHistory, g_uHistoryFileTime, g_uHistoryFileSize,
     1053                               szError, sizeof(szError));
     1054    if (RT_FAILURE(rc))
    11351055        return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", szError, rc);
    11361056
    … …  
    11411061        char szLogFile[RTPATH_MAX];
    11421062
    1143         rc = com::GetVBoxUserHomeDirectory(szLogFile, sizeof(szLogFile));
    1144         if (RT_FAILURE(rc))
    1145              return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not get base directory for logging: %Rrc", rc);
    1146         rc = RTPathAppend(szLogFile, sizeof(szLogFile), "vboxballoonctrl.log");
    1147         if (RT_FAILURE(rc))
    1148              return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not construct logging path: %Rrc", rc);
     1063        if (!pszLogFile || !*pszLogFile)
     1064        {
     1065            rc = com::GetVBoxUserHomeDirectory(szLogFile, sizeof(szLogFile));
     1066            if (RT_FAILURE(rc))
     1067                 return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not get base directory for logging: %Rrc", rc);
     1068            rc = RTPathAppend(szLogFile, sizeof(szLogFile), "vboxballoonctrl.log");
     1069            if (RT_FAILURE(rc))
     1070                 return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not construct logging path: %Rrc", rc);
     1071            pszLogFile = szLogFile;
     1072        }
    11491073
    11501074        rc = RTProcDaemonizeUsingFork(false /* fNoChDir */, false /* fNoClose */, pszPidFile);
    … …  
    11521076            return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to daemonize, rc=%Rrc. exiting.", rc);
    11531077
    1154         /* create release logger */
    1155         PRTLOGGER pLoggerReleaseFile;
    1156         static const char * const s_apszGroupsFile[] = VBOX_LOGGROUP_NAMES;
    1157         RTUINT fFlagsFile = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
    1158 #if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
    1159         fFlagsFile |= RTLOGFLAGS_USECRLF;
    1160 #endif
    1161         char szErrorFile[RTPATH_MAX + 128] = "";
    1162         int vrc = RTLogCreateEx(&pLoggerReleaseFile, fFlagsFile, "all",
    1163                                 "VBOXBALLOONCTRL_RELEASE_LOG", RT_ELEMENTS(s_apszGroupsFile), s_apszGroupsFile, RTLOGDEST_FILE,
    1164                                 logHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
    1165                                 szErrorFile, sizeof(szErrorFile), szLogFile);
    1166         if (RT_SUCCESS(vrc))
    1167         {
    1168             /* register this logger as the release logger */
    1169             RTLogRelSetDefaultInstance(pLoggerReleaseFile);
    1170 
    1171             /* Explicitly flush the log in case of VBOXBALLOONCTRL_RELEASE_LOG=buffered. */
    1172             RTLogFlush(pLoggerReleaseFile);
    1173         }
    1174         else
    1175             return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", szErrorFile, vrc);
     1078        /* create release logger, to file */
     1079        rc = com::VBoxLogRelCreate("Watchdog", pszLogFile,
     1080                                   RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG,
     1081                                   "all", "VBOXBALLOONCTRL_RELEASE_LOG",
     1082                                   RTLOGDEST_FILE, UINT32_MAX /* cMaxEntriesPerGroup */,
     1083                                   g_cHistory, g_uHistoryFileTime, g_uHistoryFileSize,
     1084                                   szError, sizeof(szError));
     1085        if (RT_FAILURE(rc))
     1086            return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", szError, rc);
    11761087    }
    11771088#endif

  • trunk/src/VBox/Main/Makefile.kmk

    r40993 r41040  
    55
    66#
    7 # Copyright (C) 2006-2012 Oracle Corporation
     7# Copyright (C) 2004-2012 Oracle Corporation
    88#
    99# This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    103103 OTHERS         += $(VBOX_IDL_FILE.XPCOM) $(VBOX_IDL_TYPELIB.XPCOM) $(VBOX_IDL_HEADER.XPCOM)
    104104 OTHER_CLEAN    += \
    105     $(VBOX_IDL_FILE.XPCOM) \
    106     $(VBOX_IDL_HEADER.XPCOM) \
    107     $(VBOX_IDL_TYPELIB.XPCOM)
     105        $(VBOX_IDL_FILE.XPCOM) \
     106        $(VBOX_IDL_HEADER.XPCOM) \
     107        $(VBOX_IDL_TYPELIB.XPCOM)
    108108
    109109 VBOX_MAIN_PREREQS += $(VBOX_IDL_TYPELIB.XPCOM) $(VBOX_IDL_HEADER.XPCOM)
    … …  
    175175VBox-python-glue_SOURCES = \
    176176        glue/vboxapi.py=>__init__.py \
    177         $(VBox-python-glue_0_OUTDIR)/VirtualBox_constants.py
     177        $(VBox-python-glue_0_OUTDIR)/VirtualBox_constants.py
    178178VBox-python-glue_CLEAN = \
    179         $(VBox-python-glue_0_OUTDIR)/VirtualBox_constants.py
     179        $(VBox-python-glue_0_OUTDIR)/VirtualBox_constants.py
    180180
    181181$$(VBox-python-glue_0_OUTDIR)/VirtualBox_constants.py:  \
    … …  
    275275        devinfo \
    276276        socket \
    277         $(LIB_VMM)
    278        
     277        $(LIB_VMM)
     278
    279279VBoxSVC_INTERMEDIATES = \
    280280        $(VBOX_MAIN_PREREQS) \
    … …  
    310310        src-server/HostNetworkInterfaceImpl.cpp \
    311311        src-server/HostPower.cpp \
    312         src-server/Logging.cpp \
    313312        src-server/MachineImpl.cpp \
    314313        src-server/MachineImplCloneVM.cpp \
    … …  
    345344        src-server/win/HostPowerWin.cpp \
    346345        src-server/win/VBoxSVC.rc \
    347         src-server/win/VBoxComEvents.cpp
     346        src-server/win/VBoxComEvents.cpp
    348347
    349348VBoxSVC_SOURCES.linux = \
    … …  
    356355VBoxSVC_SOURCES.freebsd = \
    357356        src-server/freebsd/HostHardwareFreeBSD.cpp
    358 
    359 src-server/Logging.cpp_DEFS = \
    360         VBOX_BUILD_TARGET=\"$(KBUILD_TARGET).$(KBUILD_TARGET_ARCH)\" \
    361         $(if $(VBOX_BLEEDING_EDGE),VBOX_BLEEDING_EDGE=\"$(VBOX_BLEEDING_EDGE)\",)
    362357
    363358
    … …  
    579574ifdef VBOX_WITH_NETFLT
    580575 VBoxC_LIBS.win += \
    581         $(PATH_STAGE_LIB)/VBoxDrvCfg$(VBOX_SUFF_LIB) \
    582         $(PATH_SDK_W2K3DDK_LIB)/Newdev.lib \
    583         $(PATH_STAGE_LIB)/WinNetConfig$(VBOX_SUFF_LIB) \
    584         $(PATH_TOOL_$(VBOX_VCC_TOOL)_LIB)/comsupp.lib \
    585         $(PATH_SDK_WINPSDK_LIB)/WbemUuid.Lib
     576        $(PATH_STAGE_LIB)/VBoxDrvCfg$(VBOX_SUFF_LIB) \
     577        $(PATH_SDK_W2K3DDK_LIB)/Newdev.lib \
     578        $(PATH_STAGE_LIB)/WinNetConfig$(VBOX_SUFF_LIB) \
     579        $(PATH_TOOL_$(VBOX_VCC_TOOL)_LIB)/comsupp.lib \
     580        $(PATH_SDK_WINPSDK_LIB)/WbemUuid.Lib
    586581endif
    587582
    … …  
    688683
    689684src-client/ConsoleImpl.cpp_DEFS = \
    690         VBOX_BUILD_TARGET=\"$(KBUILD_TARGET).$(KBUILD_TARGET_ARCH)\" \
    691685        $(if $(VBOX_BLEEDING_EDGE),VBOX_BLEEDING_EDGE=\"$(VBOX_BLEEDING_EDGE)\",)
    692686
    … …  
    726720endif # !win
    727721
     722glue/com.cpp_DEFS = \
     723        $(if $(VBOX_BLEEDING_EDGE),VBOX_BLEEDING_EDGE=\"$(VBOX_BLEEDING_EDGE)\",)
     724
    728725
    729726#
    … …  
    739736        src-all/ExtPackUtil.cpp
    740737 VBoxExtPackHelperApp_LIBS = \
    741         $(LIB_RUNTIME)
     738        $(LIB_RUNTIME)
    742739endif # VBOX_WITH_EXTPACK
    743740

  • trunk/src/VBox/Main/glue/com.cpp

    r39926 r41040  
    55
    66/*
    7  * Copyright (C) 2006-2007 Oracle Corporation
     7 * Copyright (C) 2005-2012 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    4141#include "VBox/com/array.h"
    4242
     43#include <package-generated.h>
     44
     45#include <iprt/buildconfig.h>
    4346#include <iprt/param.h>
    4447#include <iprt/path.h>
    … …  
    4649#include <iprt/env.h>
    4750#include <iprt/string.h>
     51#include <iprt/system.h>
     52#include <iprt/process.h>
    4853
    4954#include <VBox/err.h>
     55#include <VBox/version.h>
    5056
    5157#ifdef RT_OS_DARWIN
    … …  
    212218}
    213219
     220static const char *g_pszLogEntity = NULL;
     221
     222static void vboxHeaderFooter(PRTLOGGER pReleaseLogger, RTLOGPHASE enmPhase, PFNRTLOGPHASEMSG pfnLog)
     223{
     224    /* some introductory information */
     225    static RTTIMESPEC s_TimeSpec;
     226    char szTmp[256];
     227    if (enmPhase == RTLOGPHASE_BEGIN)
     228        RTTimeNow(&s_TimeSpec);
     229    RTTimeSpecToString(&s_TimeSpec, szTmp, sizeof(szTmp));
     230
     231    switch (enmPhase)
     232    {
     233        case RTLOGPHASE_BEGIN:
     234        {
     235            bool fOldBuffered = RTLogSetBuffering(pReleaseLogger, true /*fBuffered*/);
     236            pfnLog(pReleaseLogger,
     237                   "VirtualBox %s %s r%u %s (%s %s) release log\n"
     238#ifdef VBOX_BLEEDING_EDGE
     239                   "EXPERIMENTAL build " VBOX_BLEEDING_EDGE "\n"
     240#endif
     241                   "Log opened %s\n",
     242                   g_pszLogEntity, VBOX_VERSION_STRING, RTBldCfgRevision(),
     243                   RTBldCfgTargetDotArch(), __DATE__, __TIME__, szTmp);
     244
     245            int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
     246            if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
     247                pfnLog(pReleaseLogger, "OS Product: %s\n", szTmp);
     248            vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
     249            if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
     250                pfnLog(pReleaseLogger, "OS Release: %s\n", szTmp);
     251            vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
     252            if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
     253                pfnLog(pReleaseLogger, "OS Version: %s\n", szTmp);
     254            vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp));
     255            if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
     256                pfnLog(pReleaseLogger, "OS Service Pack: %s\n", szTmp);
     257
     258            vrc = RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_NAME, szTmp, sizeof(szTmp));
     259            if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
     260                pfnLog(pReleaseLogger, "DMI Product Name: %s\n", szTmp);
     261            vrc = RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_VERSION, szTmp, sizeof(szTmp));
     262            if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
     263                pfnLog(pReleaseLogger, "DMI Product Version: %s\n", szTmp);
     264
     265            uint64_t cbHostRam = 0, cbHostRamAvail = 0;
     266            vrc = RTSystemQueryTotalRam(&cbHostRam);
     267            if (RT_SUCCESS(vrc))
     268                vrc = RTSystemQueryAvailableRam(&cbHostRamAvail);
     269            if (RT_SUCCESS(vrc))
     270                pfnLog(pReleaseLogger, "Host RAM: %lluMB RAM, available: %lluMB\n",
     271                       cbHostRam / _1M, cbHostRamAvail / _1M);
     272
     273            /* the package type is interesting for Linux distributions */
     274            char szExecName[RTPATH_MAX];
     275            char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
     276            pfnLog(pReleaseLogger,
     277                   "Executable: %s\n"
     278                   "Process ID: %u\n"
     279                   "Package type: %s"
     280#ifdef VBOX_OSE
     281                   " (OSE)"
     282#endif
     283                   "\n",
     284                   pszExecName ? pszExecName : "unknown",
     285                   RTProcSelf(),
     286                   VBOX_PACKAGE_STRING);
     287            RTLogSetBuffering(pReleaseLogger, fOldBuffered);
     288            break;
     289        }
     290        case RTLOGPHASE_PREROTATE:
     291            pfnLog(pReleaseLogger, "Log rotated - Log started %s\n", szTmp);
     292            break;
     293
     294        case RTLOGPHASE_POSTROTATE:
     295            pfnLog(pReleaseLogger, "Log continuation - Log started %s\n", szTmp);
     296            break;
     297
     298        case RTLOGPHASE_END:
     299            pfnLog(pReleaseLogger, "End of log file - Log started %s\n", szTmp);
     300            break;
     301
     302        default:
     303            /* nothing */;
     304    }
     305}
     306
     307int VBoxLogRelCreate(const char *pcszEntity, const char *pcszLogFile,
     308                     uint32_t fFlags, const char *pcszGroupSettings,
     309                     const char *pcszEnvVarBase, uint32_t fDestFlags,
     310                     uint32_t cMaxEntriesPerGroup, uint32_t cHistory,
     311                     uint32_t uHistoryFileTime, uint64_t uHistoryFileSize,
     312                     char *pszError, size_t cbError)
     313{
     314    Assert(cbError >= RTPATH_MAX + 128);
     315
     316    /* create release logger */
     317    PRTLOGGER pReleaseLogger;
     318    static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
     319#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
     320    fFlags |= RTLOGFLAGS_USECRLF;
     321#endif
     322    g_pszLogEntity = pcszEntity;
     323    int vrc = RTLogCreateEx(&pReleaseLogger, fFlags, "all all.restrict default.unrestricted",
     324                            pcszEnvVarBase, RT_ELEMENTS(s_apszGroups), s_apszGroups, fDestFlags,
     325                            vboxHeaderFooter, cHistory, uHistoryFileSize, uHistoryFileTime,
     326                            pszError, cbError, pcszLogFile);
     327    if (RT_SUCCESS(vrc))
     328    {
     329        /* make sure that we don't flood logfiles */
     330        RTLogSetGroupLimit(pReleaseLogger, cMaxEntriesPerGroup);
     331
     332        /* explicitly flush the log, to have some info when buffering */
     333        RTLogFlush(pReleaseLogger);
     334
     335        /* register this logger as the release logger */
     336        RTLogRelSetDefaultInstance(pReleaseLogger);
     337    }
     338    return vrc;
     339}
     340
     341
    214342/* static */
    215343const Guid Guid::Empty; /* default ctor is OK */

  • trunk/src/VBox/Main/include/Logging.h

    r38037 r41040  
    77
    88/*
    9  * Copyright (C) 2006-2011 Oracle Corporation
     9 * Copyright (C) 2004-2012 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    4444#include <VBox/log.h>
    4545
    46 int VBoxSVCLogRelCreate(const char *pszLogFile, uint32_t cHistory,
    47                         uint32_t uHistoryFileTime, uint64_t uHistoryFileSize);
    48 
    4946#endif // ____H_LOGGING
    5047/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

    r40715 r41040  
    55
    66/*
    7  * Copyright (C) 2006-2012 Oracle Corporation
     7 * Copyright (C) 2005-2012 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    6363#include "ConsoleVRDPServer.h"
    6464#include "VMMDev.h"
    65 #include "package-generated.h"
    6665#ifdef VBOX_WITH_EXTPACK
    6766# include "ExtPackManagerImpl.h"
    … …  
    105104#include <VBox/param.h>
    106105#include <VBox/vusb.h>
    107 #include <VBox/version.h>
    108106
    109107#include <VBox/VMMDev.h>
    … …  
    60676065    Bstr logFolder;
    60686066    hrc = aMachine->COMGETTER(LogFolder)(logFolder.asOutParam());
    6069     if (FAILED(hrc)) return hrc;
     6067    if (FAILED(hrc))
     6068        return hrc;
    60706069
    60716070    Utf8Str logDir = logFolder;
    … …  
    61166115    }
    61176116
    6118     static const char * const   s_apszGroups[] = VBOX_LOGGROUP_NAMES;
    6119     char                        szError[RTPATH_MAX + 128] = "";
    6120     PRTLOGGER                   pReleaseLogger;
    6121     uint32_t                    fFlags = RTLOGFLAGS_PREFIX_TIME_PROG | RTLOGFLAGS_RESTRICT_GROUPS;
    6122 #if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
    6123     fFlags |= RTLOGFLAGS_USECRLF;
    6124 #endif
    6125     int vrc = RTLogCreateEx(&pReleaseLogger, fFlags, "all all.restrict default.unrestricted",
    6126                             "VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups, RTLOGDEST_FILE,
    6127                             NULL /* pfnBeginEnd */, 0 /* cHistory */, 0 /* cbHistoryFileMax */, 0 /* uHistoryTimeMax */,
    6128                             szError, sizeof(szError), logFile.c_str());
    6129     if (RT_SUCCESS(vrc))
    6130     {
    6131         RTLogSetGroupLimit(pReleaseLogger, 32768);
    6132         bool fOldBuffered = RTLogRelSetBuffering(true /*fBuffered*/);
    6133 
    6134         /* some introductory information */
    6135         RTTIMESPEC timeSpec;
    6136         char szTmp[256];
    6137         RTTimeSpecToString(RTTimeNow(&timeSpec), szTmp, sizeof(szTmp));
    6138         RTLogRelLogger(pReleaseLogger, 0, ~0U,
    6139                        "VirtualBox %s r%u %s (%s %s) release log\n"
    6140 #ifdef VBOX_BLEEDING_EDGE
    6141                        "EXPERIMENTAL build " VBOX_BLEEDING_EDGE "\n"
    6142 #endif
    6143                        "Log opened %s\n",
    6144                        VBOX_VERSION_STRING, RTBldCfgRevision(), VBOX_BUILD_TARGET,
    6145                        __DATE__, __TIME__, szTmp);
    6146 
    6147         vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
    6148         if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    6149             RTLogRelLogger(pReleaseLogger, 0, ~0U, "OS Product: %s\n", szTmp);
    6150         vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
    6151         if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    6152             RTLogRelLogger(pReleaseLogger, 0, ~0U, "OS Release: %s\n", szTmp);
    6153         vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
    6154         if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    6155             RTLogRelLogger(pReleaseLogger, 0, ~0U, "OS Version: %s\n", szTmp);
    6156         vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp));
    6157         if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    6158             RTLogRelLogger(pReleaseLogger, 0, ~0U, "OS Service Pack: %s\n", szTmp);
    6159         vrc = RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_NAME, szTmp, sizeof(szTmp));
    6160         if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    6161             RTLogRelLogger(pReleaseLogger, 0, ~0U, "DMI Product Name: %s\n", szTmp);
    6162         vrc = RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_VERSION, szTmp, sizeof(szTmp));
    6163         if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    6164             RTLogRelLogger(pReleaseLogger, 0, ~0U, "DMI Product Version: %s\n", szTmp);
    6165 
    6166         ComPtr<IHost> pHost;
    6167         pVirtualBox->COMGETTER(Host)(pHost.asOutParam());
    6168         ULONG cMbHostRam = 0;
    6169         ULONG cMbHostRamAvail = 0;
    6170         pHost->COMGETTER(MemorySize)(&cMbHostRam);
    6171         pHost->COMGETTER(MemoryAvailable)(&cMbHostRamAvail);
    6172         RTLogRelLogger(pReleaseLogger, 0, ~0U, "Host RAM: %uMB RAM, available: %uMB\n",
    6173                        cMbHostRam, cMbHostRamAvail);
    6174 
    6175         /* the package type is interesting for Linux distributions */
    6176         char szExecName[RTPATH_MAX];
    6177         char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
    6178         RTLogRelLogger(pReleaseLogger, 0, ~0U,
    6179                        "Executable: %s\n"
    6180                        "Process ID: %u\n"
    6181                        "Package type: %s"
    6182 #ifdef VBOX_OSE
    6183                        " (OSE)"
    6184 #endif
    6185                        "\n",
    6186                        pszExecName ? pszExecName : "unknown",
    6187                        RTProcSelf(),
    6188                        VBOX_PACKAGE_STRING);
    6189 
    6190         /* register this logger as the release logger */
    6191         RTLogRelSetDefaultInstance(pReleaseLogger);
    6192         hrc = S_OK;
    6193 
    6194         /* Restore the buffering setting and xplicitly flush the log. */
    6195         RTLogRelSetBuffering(fOldBuffered);
    6196         RTLogFlush(pReleaseLogger);
    6197     }
    6198     else
    6199         hrc = setError(E_FAIL,
    6200             tr("Failed to open release log (%s, %Rrc)"),
    6201             szError, vrc);
     6117    char szError[RTPATH_MAX + 128];
     6118    int vrc = com::VBoxLogRelCreate("VM", logFile.c_str(),
     6119                                    RTLOGFLAGS_PREFIX_TIME_PROG | RTLOGFLAGS_RESTRICT_GROUPS,
     6120                                    "all all.restrict default.unrestricted",
     6121                                    "VBOX_RELEASE_LOG", RTLOGDEST_FILE,
     6122                                    32768 /* cMaxEntriesPerGroup */,
     6123                                    0 /* cHistory */, 0 /* uHistoryFileTime */,
     6124                                    0 /* uHistoryFileSize */, szError, sizeof(szError));
     6125    if (RT_FAILURE(vrc))
     6126        hrc = setError(E_FAIL, tr("Failed to open release log (%s, %Rrc)"),
     6127                       szError, vrc);
    62026128
    62036129    /* If we've made any directory changes, flush the directory to increase
    … …  
    85718497    static char saBuildID[40];
    85728498    RTStrPrintf(saBuildID, sizeof(saBuildID), "%s%s%s%s VirtualBox %s r%u %s%s%s%s",
    8573                 "BU", "IL", "DI", "D", VBOX_VERSION_STRING, RTBldCfgRevision(), "BU", "IL", "DI", "D");
     8499                "BU", "IL", "DI", "D", RTBldCfgVersion(), RTBldCfgRevision(), "BU", "IL", "DI", "D");
    85748500
    85758501    ComObjPtr<Console> pConsole = task->mConsole;

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

    r38636 r41040  
    55
    66/*
    7  * Copyright (C) 2006-2011 Oracle Corporation
     7 * Copyright (C) 2004-2012 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    336336                pszLogFile = RTStrDup(szLogFile);
    337337        }
    338         VBoxSVCLogRelCreate(pszLogFile, cHistory, uHistoryFileTime, uHistoryFileSize);
     338        vrc = com::VBoxLogRelCreate("COM Server", pszLogFile,
     339                                    RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG,
     340                                    "all", "VBOXSVC_RELEASE_LOG",
     341                                    RTLOGDEST_FILE, UINT32_MAX /* cMaxEntriesPerGroup */,
     342                                    cHistory, uHistoryFileTime, uHistoryFileSize,
     343                                    szError, sizeof(szError));
     344        if (RT_FAILURE(vrc))
     345            return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", szError, vrc);
    339346    }
    340347

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

    r39459 r41040  
    55
    66/*
    7  * Copyright (C) 2006-2011 Oracle Corporation
     7 * Copyright (C) 2004-2012 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    3636
    3737#include <VBox/param.h>
    38 #include <VBox/version.h>
    3938
    4039#include <iprt/buildconfig.h>
    … …  
    892891            pszLogFile = RTStrDup(szLogFile);
    893892    }
    894     VBoxSVCLogRelCreate(pszLogFile, cHistory, uHistoryFileTime, uHistoryFileSize);
     893    char szError[RTPATH_MAX + 128];
     894    vrc = com::VBoxLogRelCreate("XPCOM Server", pszLogFile,
     895                                RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG,
     896                                "all", "VBOXSVC_RELEASE_LOG",
     897                                RTLOGDEST_FILE, UINT32_MAX /* cMaxEntriesPerGroup */,
     898                                cHistory, uHistoryFileTime, uHistoryFileSize,
     899                                szError, sizeof(szError));
     900    if (RT_FAILURE(vrc))
     901        return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", szError, vrc);
    895902
    896903    daemon_pipe_wr = PR_GetInheritedFD(VBOXSVC_STARTUP_PIPE_NAME);
    … …  
    10011008                putchar('*');
    10021009            RTPrintf("\n%s\n", szBuf);
    1003             RTPrintf("(C) 2008-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
     1010            RTPrintf("(C) 2004-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
    10041011                     "All rights reserved.\n");
    10051012#ifdef DEBUG

  • trunk/src/VBox/Main/webservice/Makefile.kmk

    r40526 r41040  
    77
    88#
    9 # Copyright (C) 2006-2012 Oracle Corporation
     9# Copyright (C) 2007-2012 Oracle Corporation
    1010#
    1111# This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    318318
    319319 vboxweb.cpp_DEFS = \
    320         VBOX_BUILD_TARGET=\"$(KBUILD_TARGET).$(KBUILD_TARGET_ARCH)\" \
    321320        $(if $(VBOX_BLEEDING_EDGE),VBOX_BLEEDING_EDGE=\"$(VBOX_BLEEDING_EDGE)\",)
    322321

  • trunk/src/VBox/Main/webservice/vboxweb.cpp

    r40312 r41040  
    66 *      server, to which clients can connect.
    77 *
    8  * Copyright (C) 2006-2012 Oracle Corporation
     8 * Copyright (C) 2007-2012 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    3131#include <VBox/version.h>
    3232#include <VBox/log.h>
    33 
    34 #include <package-generated.h>
    3533
    3634#include <iprt/buildconfig.h>
    … …  
    721719}
    722720
    723 static void WebLogHeaderFooter(PRTLOGGER pLoggerRelease, RTLOGPHASE enmPhase, PFNRTLOGPHASEMSG pfnLog)
    724 {
    725     /* some introductory information */
    726     static RTTIMESPEC s_TimeSpec;
    727     char szTmp[256];
    728     if (enmPhase == RTLOGPHASE_BEGIN)
    729         RTTimeNow(&s_TimeSpec);
    730     RTTimeSpecToString(&s_TimeSpec, szTmp, sizeof(szTmp));
    731 
    732     switch (enmPhase)
    733     {
    734         case RTLOGPHASE_BEGIN:
    735         {
    736             pfnLog(pLoggerRelease,
    737                    "VirtualBox web service %s r%u %s (%s %s) release log\n"
    738 #ifdef VBOX_BLEEDING_EDGE
    739                    "EXPERIMENTAL build " VBOX_BLEEDING_EDGE "\n"
    740 #endif
    741                    "Log opened %s\n",
    742                    VBOX_VERSION_STRING, RTBldCfgRevision(), VBOX_BUILD_TARGET,
    743                    __DATE__, __TIME__, szTmp);
    744 
    745             int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
    746             if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    747                 pfnLog(pLoggerRelease, "OS Product: %s\n", szTmp);
    748             vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
    749             if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    750                 pfnLog(pLoggerRelease, "OS Release: %s\n", szTmp);
    751             vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
    752             if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    753                 pfnLog(pLoggerRelease, "OS Version: %s\n", szTmp);
    754             if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
    755                 pfnLog(pLoggerRelease, "OS Service Pack: %s\n", szTmp);
    756 
    757             /* the package type is interesting for Linux distributions */
    758             char szExecName[RTPATH_MAX];
    759             char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
    760             pfnLog(pLoggerRelease,
    761                    "Executable: %s\n"
    762                    "Process ID: %u\n"
    763                    "Package type: %s"
    764 #ifdef VBOX_OSE
    765                    " (OSE)"
    766 #endif
    767                    "\n",
    768                    pszExecName ? pszExecName : "unknown",
    769                    RTProcSelf(),
    770                    VBOX_PACKAGE_STRING);
    771             break;
    772         }
    773 
    774         case RTLOGPHASE_PREROTATE:
    775             pfnLog(pLoggerRelease, "Log rotated - Log started %s\n", szTmp);
    776             break;
    777 
    778         case RTLOGPHASE_POSTROTATE:
    779             pfnLog(pLoggerRelease, "Log continuation - Log started %s\n", szTmp);
    780             break;
    781 
    782         case RTLOGPHASE_END:
    783             pfnLog(pLoggerRelease, "End of log file - Log started %s\n", szTmp);
    784             break;
    785 
    786         default:
    787             /* nothing */;
    788     }
    789 }
    790 
    791721#ifdef WITH_OPENSSL
    792722/****************************************************************************
    … …  
    1020950    g_mapThreads[RTThreadSelf()] = "[M  ]";
    1021951
    1022     RTStrmPrintf(g_pStdErr, VBOX_PRODUCT " web service version " VBOX_VERSION_STRING "\n"
    1023                             "(C) 2005-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
     952    RTStrmPrintf(g_pStdErr, VBOX_PRODUCT " web service Version " VBOX_VERSION_STRING "\n"
     953                            "(C) 2007-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
    1024954                            "All rights reserved.\n");
    1025955
    … …  
    11631093    }
    11641094
    1165     /* create release logger */
    1166     PRTLOGGER pLoggerRelease;
    1167     static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
    1168     RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
    1169 #if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
    1170     fFlags |= RTLOGFLAGS_USECRLF;
    1171 #endif
    1172     char szError[RTPATH_MAX + 128] = "";
    1173     int vrc = RTLogCreateEx(&pLoggerRelease, fFlags, "all",
    1174                             "VBOXWEBSRV_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups, RTLOGDEST_STDOUT,
    1175                             WebLogHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
    1176                             szError, sizeof(szError), pszLogFile);
    1177     if (RT_SUCCESS(vrc))
    1178     {
    1179         /* register this logger as the release logger */
    1180         RTLogRelSetDefaultInstance(pLoggerRelease);
    1181 
    1182         /* Explicitly flush the log in case of VBOXWEBSRV_RELEASE_LOG=buffered. */
    1183         RTLogFlush(pLoggerRelease);
    1184     }
    1185     else
    1186         return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", szError, vrc);
     1095    /* create release logger, to stdout */
     1096    char szError[RTPATH_MAX + 128];
     1097    rc = com::VBoxLogRelCreate("web service", g_fDaemonize ? NULL : pszLogFile,
     1098                               RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG,
     1099                               "all", "VBOXWEBSRV_RELEASE_LOG",
     1100                               RTLOGDEST_STDOUT, UINT32_MAX /* cMaxEntriesPerGroup */,
     1101                               g_cHistory, g_uHistoryFileTime, g_uHistoryFileSize,
     1102                               szError, sizeof(szError));
     1103    if (RT_FAILURE(rc))
     1104        return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", szError, rc);
    11871105
    11881106#if defined(RT_OS_DARWIN) || defined(RT_OS_LINUX) || defined (RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)
    … …  
    11921110        char szLogFile[RTPATH_MAX];
    11931111
    1194         rc = com::GetVBoxUserHomeDirectory(szLogFile, sizeof(szLogFile));
    1195         if (RT_FAILURE(rc))
    1196              return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not get base directory for logging: %Rrc", rc);
    1197         rc = RTPathAppend(szLogFile, sizeof(szLogFile), "vboxwebsrv.log");
    1198         if (RT_FAILURE(rc))
    1199              return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not construct logging path: %Rrc", rc);
     1112        if (!pszLogFile || !*pszLogFile)
     1113        {
     1114            rc = com::GetVBoxUserHomeDirectory(szLogFile, sizeof(szLogFile));
     1115            if (RT_FAILURE(rc))
     1116                 return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not get base directory for logging: %Rrc", rc);
     1117            rc = RTPathAppend(szLogFile, sizeof(szLogFile), "vboxwebsrv.log");
     1118            if (RT_FAILURE(rc))
     1119                 return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not construct logging path: %Rrc", rc);
     1120            pszLogFile = szLogFile;
     1121        }
    12001122
    12011123        rc = RTProcDaemonizeUsingFork(false /* fNoChDir */, false /* fNoClose */, pszPidFile);
    … …  
    12031125            return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to daemonize, rc=%Rrc. exiting.", rc);
    12041126
    1205         /* create release logger */
    1206         PRTLOGGER pLoggerReleaseFile;
    1207         static const char * const s_apszGroupsFile[] = VBOX_LOGGROUP_NAMES;
    1208         RTUINT fFlagsFile = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
    1209 #if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
    1210         fFlagsFile |= RTLOGFLAGS_USECRLF;
    1211 #endif
    1212         char szErrorFile[RTPATH_MAX + 128] = "";
    1213         int vrc = RTLogCreateEx(&pLoggerReleaseFile, fFlagsFile, "all",
    1214                                 "VBOXWEBSRV_RELEASE_LOG", RT_ELEMENTS(s_apszGroupsFile), s_apszGroupsFile, RTLOGDEST_FILE,
    1215                                 WebLogHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
    1216                                 szErrorFile, sizeof(szErrorFile), szLogFile);
    1217         if (RT_SUCCESS(vrc))
    1218         {
    1219             /* register this logger as the release logger */
    1220             RTLogRelSetDefaultInstance(pLoggerReleaseFile);
    1221 
    1222             /* Explicitly flush the log in case of VBOXWEBSRV_RELEASE_LOG=buffered. */
    1223             RTLogFlush(pLoggerReleaseFile);
    1224         }
    1225         else
    1226             return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", szErrorFile, vrc);
     1127        /* create release logger, to file */
     1128        rc = com::VBoxLogRelCreate("web service", pszLogFile,
     1129                                   RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG,
     1130                                   "all", "VBOXWEBSRV_RELEASE_LOG",
     1131                                   RTLOGDEST_FILE, UINT32_MAX /* cMaxEntriesPerGroup */,
     1132                                   g_cHistory, g_uHistoryFileTime, g_uHistoryFileSize,
     1133                                   szError, sizeof(szError));
     1134        if (RT_FAILURE(rc))
     1135            return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", szError, rc);
    12271136    }
    12281137#endif

  • trunk/src/VBox/Main/webservice/websrv-cpp.xsl

    r39091 r41040  
    1212        generated for the webservice.
    1313
    14      Copyright (C) 2006-2010 Oracle Corporation
     14     Copyright (C) 2007-2012 Oracle Corporation
    1515
    1616     This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    6868#include <VBox/com/EventQueue.h>
    6969#include <VBox/VBoxAuth.h>
    70 #include <VBox/version.h>
    7170
    7271#include <iprt/assert.h>
Note: See TracChangeset for help on using the changeset viewer.

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