Changeset 69745 in vbox

Timestamp:

Nov 18, 2017 8:52:38 PM (7 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

119145

Message:

IPRT: Added tweak (RTLOGDEST_F_DELAY_FILE) for delaying log file opening untill the RTLogClearFileDelayFlag function is called.

Location:

trunk

Files:

• include/iprt/log.h (modified) (2 diffs)
• include/iprt/mangling.h (modified) (1 diff)
• src/VBox/Runtime/common/log/log.cpp (modified) (14 diffs)

trunk/include/iprt/log.h

@@ -457 +457 @@
     /** Open files with no deny (share read, write, delete) on Windows. */
     RTLOGDEST_F_NO_DENY     = 0x00010000,
+    /** Delay opening the log file, logging to the buffer untill
+     * RTLogClearFileDelayFlag is called. */
+    RTLOGDEST_F_DELAY_FILE  = 0x00020000,
     /** Just a dummy flag to be used when no other flag applies. */
     RTLOGDEST_DUMMY         = 0x20000000,
@@ -2269 +2272 @@
 
 /**
+ * Clear the file delay flag if set, opening the destination and flushing.
+ *
+ * @returns IPRT status code.
+ * @param   pLogger             Logger instance (NULL for default logger).
+ * @param   pszValue            The value to parse.
+ * @param   pErrInfo            Where to return extended error info.  Optional.
+ */
+RTDECL(int) RTLogClearFileDelayFlag(PRTLOGGER pLogger, PRTERRINFO pErrInfo);
+
+/**
  * Get the current log destinations as a string.
  *

trunk/include/iprt/mangling.h

@@ -1234 +1234 @@
 # define RTLogBackdoorPrintfV                           RT_MANGLER(RTLogBackdoorPrintfV) /* r0drv-guest */
 # define RTLogCalcSizeForR0                             RT_MANGLER(RTLogCalcSizeForR0)
+# define RTLogClearFileDelayFlag                        RT_MANGLER(RTLogClearFileDelayFlag)
 # define RTLogCloneRC                                   RT_MANGLER(RTLogCloneRC)
 # define RTLogComPrintf                                 RT_MANGLER(RTLogComPrintf)

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

@@ -228 +228 @@
 #endif
 #ifdef IN_RING3
-static int rtlogFileOpen(PRTLOGGER pLogger, char *pszErrorMsg, size_t cchErrorMsg);
-static void rtlogRotate(PRTLOGGER pLogger, uint32_t uTimeSlot, bool fFirst);
+static int  rtR3LogOpenFileDestination(PRTLOGGER pLogger, char *pszErrorMsg, size_t cchErrorMsg);
 #endif
 #ifndef IN_RC
 static void rtLogRingBufFlush(PRTLOGGER pLogger);
 #endif
-static void rtlogFlush(PRTLOGGER pLogger);
+static void rtlogFlush(PRTLOGGER pLogger, bool fNeedSpace);
 static DECLCALLBACK(size_t) rtLogOutput(void *pv, const char *pachChars, size_t cbChars);
 static DECLCALLBACK(size_t) rtLogOutputPrefixed(void *pv, const char *pachChars, size_t cbChars);
@@ -776 +775 @@
 # endif
 }
-
-
 
 
@@ -947 +944 @@
              */
             rc = VINF_SUCCESS;
+            if ((pLogger->fDestFlags & (RTLOGDEST_F_DELAY_FILE | RTLOGDEST_FILE)) == RTLOGDEST_F_DELAY_FILE)
+                pLogger->fDestFlags &= ~RTLOGDEST_F_DELAY_FILE;
 # ifdef IN_RING3
-            if (pLogger->fDestFlags & RTLOGDEST_FILE)
-            {
-                if (pLogger->fFlags & RTLOGFLAGS_APPEND)
-                {
-                    rc = rtlogFileOpen(pLogger, pszErrorMsg, cchErrorMsg);
-
-                    /* Rotate in case of appending to a too big log file,
-                       otherwise this simply doesn't do anything. */
-                    rtlogRotate(pLogger, 0, true /* fFirst */);
-                }
-                else
-                {
-                    /* Force rotation if it is configured. */
-                    pLogger->pInt->cbHistoryFileWritten = UINT64_MAX;
-                    rtlogRotate(pLogger, 0, true /* fFirst */);
-
-                    /* If the file is not open then rotation is not set up. */
-                    if (pLogger->pInt->hFile == NIL_RTFILE)
-                    {
-                        pLogger->pInt->cbHistoryFileWritten = 0;
-                        rc = rtlogFileOpen(pLogger, pszErrorMsg, cchErrorMsg);
-                    }
-                }
-            }
-# endif  /* IN_RING3 */
+            if ((pLogger->fDestFlags & (RTLOGDEST_FILE | RTLOGDEST_F_DELAY_FILE)) == RTLOGDEST_FILE)
+                rc = rtR3LogOpenFileDestination(pLogger, pszErrorMsg, cchErrorMsg);
+# endif
 
             if ((pLogger->fDestFlags & RTLOGDEST_RINGBUF) && RT_SUCCESS(rc))
@@ -1102 +1079 @@
      * Flush it.
      */
-    rtlogFlush(pLogger);
+    rtlogFlush(pLogger, false /*fNeedSpace*/);
 
 # ifdef IN_RING3
@@ -2449 +2426 @@
 
 /**
+ * Clear the file delay flag if set, opening the destination and flushing.
+ *
+ * @returns IPRT status code.
+ * @param   pLogger             Logger instance (NULL for default logger).
+ * @param   pszValue            The value to parse.
+ * @param   pErrInfo            Where to return extended error info.  Optional.
+ */
+RTDECL(int) RTLogClearFileDelayFlag(PRTLOGGER pLogger, PRTERRINFO pErrInfo)
+{
+    /*
+     * Resolve defaults.
+     */
+    if (!pLogger)
+    {
+        pLogger = RTLogDefaultInstance();
+        if (!pLogger)
+            return VINF_SUCCESS;
+    }
+
+    /*
+     * Do the work.
+     */
+    int rc = rtlogLock(pLogger);
+    if (RT_SUCCESS(rc))
+    {
+        if (pLogger->fDestFlags & RTLOGDEST_F_DELAY_FILE)
+        {
+            pLogger->fDestFlags &= ~RTLOGDEST_F_DELAY_FILE;
+# ifdef IN_RING3
+            if (   pLogger->fDestFlags & RTLOGDEST_FILE
+                && pLogger->pInt->hFile == NIL_RTFILE)
+            {
+                int rc = rtR3LogOpenFileDestination(pLogger, NULL, 0);
+                if (RT_SUCCESS(rc))
+                    rtlogFlush(pLogger, false /*fNeedSpace*/);
+            }
+# endif
+            RT_NOREF(pErrInfo); /** @todo fix create API to use RTErrInfo */
+        }
+        rtlogUnlock(pLogger);
+    }
+    return VINF_SUCCESS;
+}
+RT_EXPORT_SYMBOL(RTLogClearFileDelayFlag);
+
+
+/**
  * Get the current log destinations as a string.
  *
@@ -2605 +2629 @@
          * Call worker.
          */
-        rtlogFlush(pLogger);
+        rtlogFlush(pLogger, false /*fNeedSpace*/);
 
 #ifndef IN_RC
@@ -3317 +3341 @@
 }
 
+
+/**
+ * Worker for RTLogCreateExV and RTLogClearFileDelayFlag.
+ *
+ * This will later be used to reopen the file by RTLogDestinations.
+ *
+ * @returns IPRT status code.
+ * @param   pLogger             The logger.
+ * @param   pszErrorMsg         Where to return error info. Optional.
+ * @param   cchErrorMsg         Size of @a pszErrorMsg buffer.
+ */
+static int rtR3LogOpenFileDestination(PRTLOGGER pLogger, char *pszErrorMsg, size_t cchErrorMsg)
+{
+    int rc;
+    if (pLogger->fFlags & RTLOGFLAGS_APPEND)
+    {
+        rc = rtlogFileOpen(pLogger, pszErrorMsg, cchErrorMsg);
+
+        /* Rotate in case of appending to a too big log file,
+           otherwise this simply doesn't do anything. */
+        rtlogRotate(pLogger, 0, true /* fFirst */);
+    }
+    else
+    {
+        /* Force rotation if it is configured. */
+        pLogger->pInt->cbHistoryFileWritten = UINT64_MAX;
+        rtlogRotate(pLogger, 0, true /* fFirst */);
+
+        /* If the file is not open then rotation is not set up. */
+        if (pLogger->pInt->hFile == NIL_RTFILE)
+        {
+            pLogger->pInt->cbHistoryFileWritten = 0;
+            rc = rtlogFileOpen(pLogger, pszErrorMsg, cchErrorMsg);
+        }
+        else
+            rc = VINF_SUCCESS;
+    }
+    return rc;
+}
+
 #endif /* IN_RING3 */
 
@@ -3323 +3387 @@
  * Writes the buffer to the given log device without checking for buffered
  * data or anything.
+ *
  * Used by the RTLogFlush() function.
  *
  * @param   pLogger     The logger instance to write to. NULL is not allowed!
- */
-static void rtlogFlush(PRTLOGGER pLogger)
+ * @param   fNeedSpace  Set if the caller assumes space will be made available.
+ */
+static void rtlogFlush(PRTLOGGER pLogger, bool fNeedSpace)
 {
     uint32_t const cchScratch = pLogger->offScratch;
     if (cchScratch == 0)
         return; /* nothing to flush. */
+    NOREF(fNeedSpace);
 
 #ifndef IN_RC
@@ -3345 +3412 @@
         pLogger->offScratch = 0; /* empty the buffer. */
     }
+    /*
+     * In file delay mode, we ignore flush requests except when we're full
+     * and the caller really needs some scratch space to get work done.
+     */
     else
+# ifdef IN_RING3
+        if (!(pLogger->fDestFlags & RTLOGDEST_F_DELAY_FILE))
+# endif
 #endif
     {
@@ -3410 +3484 @@
 #endif
     }
+#ifdef IN_RING3
+    else
+    {
+        /*
+         * Delay file open but the caller really need some space.  So, give him half a
+         * buffer and insert a message indicating that we've dropped output.
+         */
+        uint32_t offHalf = sizeof(pLogger->achScratch) / 2;
+        if (cchScratch > offHalf)
+        {
+            if (pLogger->fFlags & RTLOGFLAGS_USECRLF)
+                pLogger->achScratch[offHalf++] = '\r';
+            static const char s_szDropMsg[] = "\n[DROP DROP DROP]";
+            memcpy(&pLogger->achScratch[offHalf], RT_STR_TUPLE(s_szDropMsg));
+            offHalf += sizeof(s_szDropMsg) - 1;
+            if (pLogger->fFlags & RTLOGFLAGS_USECRLF)
+                pLogger->achScratch[offHalf++] = '\r';
+            pLogger->achScratch[offHalf++] = '\n';
+
+            pLogger->offScratch = offHalf;
+        }
+    }
+#endif
 }
 
@@ -3455 +3552 @@
 
             /* flush */
-            rtlogFlush(pLogger);
+            rtlogFlush(pLogger, true /*fNeedSpace*/);
         }
 
@@ -3552 +3649 @@
                 if (cb < 256 + 16)
                 {
-                    rtlogFlush(pLogger);
+                    rtlogFlush(pLogger, true /*fNeedSpace*/);
                     offScratch = pLogger->offScratch;
                     cb = sizeof(pLogger->achScratch) - offScratch - 1;
@@ -3850 +3947 @@
             else if (cb <= 0)
             {
-                rtlogFlush(pLogger);
+                rtlogFlush(pLogger, true /*fNeedSpace*/);
                 offScratch = pLogger->offScratch;
                 cb = sizeof(pLogger->achScratch) - offScratch - 1;
@@ -3953 +4050 @@
     if (    !(pLogger->fFlags & RTLOGFLAGS_BUFFERED)
         &&  pLogger->offScratch)
-        rtlogFlush(pLogger);
+        rtlogFlush(pLogger, false /*fNeedSpace*/);
 }