Implement /RundownMaxMB using an ETW-based file-size limitation. (#2148)

This ensures that if PerfView crashes or is killed, the file size
limitation will still be respected.

Author: brianrob

src/PerfView/CommandProcessor.cs

@@ -3431,6 +3431,11 @@ private void DoClrRundownForSession(string fileName, string sessionName, Command
                 using (TraceEventSession clrRundownSession = new TraceEventSession(sessionName + "Rundown", rundownFile))
                 {
                     clrRundownSession.BufferSizeMB = Math.Max(parsedArgs.BufferSizeMB, 256);
+                    if (parsedArgs.RundownMaxMB > 0)
+                    {
+                        LogFile.WriteLine($"Maximum rundown file size is {parsedArgs.RundownMaxMB}MB.  Use /RundownMaxMB to change.");
+                        clrRundownSession.MaximumFileMB = parsedArgs.RundownMaxMB;
+                    }
 
                     TraceEventProviderOptions options = null;
                     if (parsedArgs.FocusProcess != null && TraceEventProviderOptions.FilteringSupported)
@@ -3561,7 +3566,7 @@ private void DoClrRundownForSession(string fileName, string sessionName, Command
                     PerfViewLogger.Log.WaitForIdle();
 
                     // Wait for rundown to complete.
-                    WaitForRundownIdle(parsedArgs.MinRundownTime, parsedArgs.RundownTimeout, parsedArgs.RundownMaxMB, rundownFile);
+                    WaitForRundownIdle(parsedArgs.MinRundownTime, parsedArgs.RundownTimeout, rundownFile);
 
                     // Complete perfview rundown.
                     DotNetVersionLogger.Stop();
@@ -3587,10 +3592,9 @@ private void DoClrRundownForSession(string fileName, string sessionName, Command
         /// Currently there is no good way to know when rundown is finished.  We basically wait as long as
         /// the rundown file is growing.  
         /// </summary>
-        private void WaitForRundownIdle(int minSeconds, int maxSeconds, int maxSizeMB, string rundownFilePath)
+        private void WaitForRundownIdle(int minSeconds, int maxSeconds, string rundownFilePath)
         {
             LogFile.WriteLine("Waiting up to {0} sec for rundown events.  Use /RundownTimeout to change.", maxSeconds);
-            LogFile.WriteLine($"Maximum rundown file size is {maxSizeMB}MB.  Use /RundownMaxMB to change.");
             LogFile.WriteLine("If you know your process has exited, use /noRundown qualifer to skip this step.");
 
             long rundownFileLen = 0;
@@ -3607,12 +3611,6 @@ private void WaitForRundownIdle(int minSeconds, int maxSeconds, int maxSizeMB, s
                 LogFile.WriteLine("Rundown File Length: {0:n1}MB delta: {1:n1}MB", newRundownFileLen / 1000000.0, delta / 1000000.0);
                 rundownFileLen = newRundownFileLen;
 
-                if ((maxSizeMB > 0) && rundownFileLen >= ((long)maxSizeMB * 1024 * 1024))
-                {
-                    LogFile.WriteLine($"Exceeded maximum rundown file size of {maxSizeMB}MB.");
-                    break;
-                }
-
                 if (i >= minSeconds)
                 {
                     if (delta == 0 && newRundownFileLen != 0)

src/TraceEvent/TraceEventSession.cs

@@ -138,6 +138,10 @@ public TraceEventSession(string sessionName, TraceEventSessionOptions options =
                     m_FileName = null;
                     m_CircularBufferMB = m_BufferSizeMB;
                 }
+                if ((properties->LogFileMode & TraceEventNativeMethods.EVENT_TRACE_FILE_MODE_SEQUENTIAL) != 0)
+                {
+                    m_MaximumFileMB = (int)properties->MaximumFileSize;
+                }
                 if ((properties->LogFileMode & TraceEventNativeMethods.EVENT_TRACE_NO_PER_PROCESSOR_BUFFERING) != 0)
                 {
                     m_NoPerProcessBuffering = true;
@@ -1164,7 +1168,12 @@ public int CircularBufferMB
 
                 if (m_MultiFileMB != 0)
                 {
-                    throw new InvalidOperationException("Cannot specify both CircularBufferMB and MultiFileMB.");
+                    throw new InvalidOperationException("Cannot specify more than one of CircularBufferMB, MultiFileMB, and MaximumFileMB.");
+                }
+
+                if (m_MaximumFileMB != 0)
+                {
+                    throw new InvalidOperationException("Cannot specify more than one of CircularBufferMB, MultiFileMB, and MaximumFileMB.");
                 }
 
                 m_CircularBufferMB = value;
@@ -1197,7 +1206,12 @@ public int MultiFileMB
 
                 if (m_CircularBufferMB != 0)
                 {
-                    throw new InvalidOperationException("Cannot specify both CircularBufferMB and MultiFileMB.");
+                    throw new InvalidOperationException("Cannot specify more than one of CircularBufferMB, MultiFileMB, and MaximumFileMB.");
+                }
+
+                if (m_MaximumFileMB != 0)
+                {
+                    throw new InvalidOperationException("Cannot specify more than one of CircularBufferMB, MultiFileMB, and MaximumFileMB.");
                 }
 
                 if (!m_FileName.EndsWith(".etl", StringComparison.OrdinalIgnoreCase))
@@ -1222,6 +1236,50 @@ public int MultiFileMB
                 m_MultiFileMB = value;
             }
         }
+
+        /// <summary>
+        /// Cause the as a set of files with a given maximum size.   The file name must end in .ETL and the
+        /// output is then a series of files of the form *NNN.ETL (That is it adds a number just before the
+        /// .etl suffix).   If you make your file name *.user.etl then the output will be *.user1.etl, *.user2.etl ...
+        /// And the MergeInPlace command below will merge them all nicely.
+        ///
+        /// You can have more control over this by using a normal sequential file but use the SetFileName()
+        /// method to redirect the data to new files as needed.
+        /// </summary>
+        public int MaximumFileMB
+        {
+            get { return m_MaximumFileMB; }
+            set
+            {
+                if (IsActive)
+                {
+                    throw new InvalidOperationException("Property can't be changed after a provider has started.");
+                }
+
+                if (m_FileName == null)
+                {
+                    throw new InvalidOperationException("MultiFile is only allowed on sessions with files.");
+                }
+
+                if (m_CircularBufferMB != 0)
+                {
+                    throw new InvalidOperationException("Cannot specify more than one of CircularBufferMB, MultiFileMB, and MaximumFileMB.");
+                }
+
+                if (m_MultiFileMB != 0)
+                {
+                    throw new InvalidOperationException("Cannot specify more than one of CircularBufferMB, MultiFileMB, and MaximumFileMB.");
+                }
+
+                if (!m_FileName.EndsWith(".etl", StringComparison.OrdinalIgnoreCase))
+                {
+                    throw new InvalidOperationException("FileName must have .etl suffix");
+                }
+
+                m_MaximumFileMB = value;
+            }
+        }
+
         /// <summary>
         /// Sets the size of the buffer the operating system should reserve to avoid lost packets.   Starts out
         /// as a very generous 64MB for files.  If events are lost, this can be increased, but keep in mind that
@@ -2400,6 +2458,7 @@ private void EnsureStarted(TraceEventNativeMethods.EVENT_TRACE_PROPERTIES* prope
                 else
                 {
                     properties->LogFileMode |= TraceEventNativeMethods.EVENT_TRACE_FILE_MODE_SEQUENTIAL;
+                    properties->MaximumFileSize = (uint)m_MaximumFileMB;
                 }
 
                 if (m_FileName.Length > MaxNameSize - 1)
@@ -2557,6 +2616,7 @@ public static int GetMaxLastBranchRecordingSources()
         private int m_BufferQuantumKB;
         private int m_CircularBufferMB;
         private int m_MultiFileMB;
+        private int m_MaximumFileMB;
         private bool m_IsPrivateLogger;
         private bool m_IsPrivateInProcLogger;