[EventPipe] Adding an IPC server to handle out of process communication. (#23106)

This is the first commit to enable a "diagnostic port" using IPC (Named Pipe on Windows and Unix Domain Socket on other platforms). This change currently enable EventPipe to be enabled/disabled without the use of a file drop.
- Split the DiagnosticsIpc into (DiagnosticsIpc/IpcStream)
  - DiagnosticsIpc (IPC listener) is meant to be used by the Diagnostic server.
  - IpcStream (IPC channel) is meant to be use to communicate with the connected client.
- Change the FastSerializer dependency from `CFileStream` to `StreamWriter`
  This abstraction is meant decouple the writing of objects in order to extend its usability.
  The main objective is to reuse FastSerializer to stream data through the open IPC channel.
- Moved the EventPipeSessionProvider* classes to their own file.
- Added a more streamlined parsing achievable by defining a simpler binary protocol (by noahfalk).
  1. Only one allocation is needed for the EventPipeProviderConfiguration array, no allocations or copies are needed for strings because we can refer to them directly out of the incoming command buffer
  2. No change to the EventPipe API for enable is required. EventPipeProviderConfiguration retains its current behavior of not deleting the string pointers it holds.
  3. No leaks happen because the command buffer owns the string memory and ensures that it stays alive for the duration of the Enable() call.

1 files changed, 107 insertions, 219 deletions

diff --git a/src/vm/eventpipe.h b/src/vm/eventpipe.h
index c77b94dbdc..494a8c5c98 100644
--- a/src/vm/eventpipe.h
+++ b/src/vm/eventpipe.h
@@ -14,8 +14,6 @@ class EventPipeConfiguration;
 class EventPipeEvent;
 class EventPipeEventInstance;
 class EventPipeFile;
-class EventPipeJsonFile;
-class EventPipeBuffer;
 class EventPipeBufferManager;
 class EventPipeEventSource;
 class EventPipeProvider;
@@ -35,13 +33,13 @@ struct EventFilterDescriptor
     ULONGLONG Ptr;
 
     // The size of the filter data, in bytes. The maximum size is 1024 bytes.
-    ULONG     Size;
+    ULONG Size;
 
     // The type of filter data. The type is application-defined. An event
     // controller that knows about the provider and knows details about the
     // provider's events can use the Type field to send the provider an
     // arbitrary set of data for use as enhancements to the filtering of events.
-    ULONG     Type;
+    ULONG Type;
 };
 
 // Define the event pipe callback to match the ETW callback signature.
@@ -56,7 +54,6 @@ typedef void (*EventPipeCallback)(
 
 struct EventData
 {
-public:
     UINT64 Ptr;
     unsigned int Size;
     unsigned int Reserved;
@@ -91,7 +88,7 @@ public:
     // Get the flat formatted data in this payload
     // This method will allocate a buffer if it does not already contain flattened data
     // This method will return NULL on OOM if a buffer needed to be allocated
-    BYTE* GetFlatData();
+    BYTE *GetFlatData();
 
     // Return true is the data is stored in a flat buffer
     bool IsFlattened() const
@@ -109,7 +106,7 @@ public:
         return m_size;
     }
 
-    EventData* GetEventDataArray() const
+    EventData *GetEventDataArray() const
     {
         LIMITED_METHOD_CONTRACT;
 
@@ -120,7 +117,6 @@ public:
 class StackContents
 {
 private:
-
     const static unsigned int MAX_STACK_DEPTH = 100;
 
     // Array of IP values from a stack crawl.
@@ -130,14 +126,13 @@ private:
 #ifdef _DEBUG
     // Parallel array of MethodDesc pointers.
     // Used for debug-only stack printing.
-    MethodDesc* m_methods[MAX_STACK_DEPTH];
+    MethodDesc *m_methods[MAX_STACK_DEPTH];
 #endif // _DEBUG
 
     // The next available slot in StackFrames.
     unsigned int m_nextAvailableFrame;
 
 public:
-
     StackContents()
     {
         LIMITED_METHOD_CONTRACT;
@@ -152,7 +147,7 @@ public:
 
         memcpy_s(pDest->m_stackFrames, MAX_STACK_DEPTH * sizeof(UINT_PTR), m_stackFrames, sizeof(UINT_PTR) * m_nextAvailableFrame);
 #ifdef _DEBUG
-        memcpy_s(pDest->m_methods, MAX_STACK_DEPTH * sizeof(MethodDesc*), m_methods, sizeof(MethodDesc*) * m_nextAvailableFrame);
+        memcpy_s(pDest->m_methods, MAX_STACK_DEPTH * sizeof(MethodDesc *), m_methods, sizeof(MethodDesc *) * m_nextAvailableFrame);
 #endif
         pDest->m_nextAvailableFrame = m_nextAvailableFrame;
     }
@@ -192,7 +187,7 @@ public:
     }
 
 #ifdef _DEBUG
-    MethodDesc* GetMethod(unsigned int frameIndex)
+    MethodDesc *GetMethod(unsigned int frameIndex)
     {
         LIMITED_METHOD_CONTRACT;
         _ASSERTE(frameIndex < MAX_STACK_DEPTH);
@@ -210,7 +205,7 @@ public:
     {
         LIMITED_METHOD_CONTRACT;
 
-        if(m_nextAvailableFrame < MAX_STACK_DEPTH)
+        if (m_nextAvailableFrame < MAX_STACK_DEPTH)
         {
             m_stackFrames[m_nextAvailableFrame] = controlPC;
 #ifdef _DEBUG
@@ -220,11 +215,11 @@ public:
         }
     }
 
-    BYTE* GetPointer() const
+    BYTE *GetPointer() const
     {
         LIMITED_METHOD_CONTRACT;
 
-        return (BYTE*)m_stackFrames;
+        return (BYTE *)m_stackFrames;
     }
 
     unsigned int GetSize() const
@@ -246,146 +241,128 @@ class EventPipe
     friend class EventPipeBufferManager;
     friend class SampleProfiler;
 
-    public:
-
-        // Initialize the event pipe.
-        static void Initialize();
-
-        // Shutdown the event pipe.
-        static void Shutdown();
-
-        // Enable tracing via the event pipe.
-        static EventPipeSessionID Enable(
-            LPCWSTR strOutputPath,
-            unsigned int circularBufferSizeInMB,
-            EventPipeProviderConfiguration *pProviders,
-            int numProviders,
-            UINT64 multiFileTraceLengthInSeconds);
-
-        // Disable tracing via the event pipe.
-        static void Disable(EventPipeSessionID id);
-
-        // Get the session for the specified session ID.
-        static EventPipeSession* GetSession(EventPipeSessionID id);
-
-        // Specifies whether or not the event pipe is enabled.
-        static bool Enabled();
-
-        // Create a provider.
-        static EventPipeProvider* CreateProvider(const SString &providerName, EventPipeCallback pCallbackFunction = NULL, void *pCallbackData = NULL);
-
-        // Get a provider.
-        static EventPipeProvider* GetProvider(const SString &providerName);
-
-        // Delete a provider.
-        static void DeleteProvider(EventPipeProvider *pProvider);
-
-        // Write out an event from a flat buffer.
-        // Data is written as a serialized blob matching the ETW serialization conventions.
-        static void WriteEvent(EventPipeEvent &event, BYTE *pData, unsigned int length, LPCGUID pActivityId = NULL, LPCGUID pRelatedActivityId = NULL);
-
-        // Write out an event from an EventData array.
-        // Data is written as a serialized blob matching the ETW serialization conventions.
-        static void WriteEvent(EventPipeEvent &event, EventData *pEventData, unsigned int eventDataCount, LPCGUID pActivityId = NULL, LPCGUID pRelatedActivityId = NULL);
-
-        // Write out a sample profile event.
-        static void WriteSampleProfileEvent(Thread *pSamplingThread, EventPipeEvent *pEvent, Thread *pTargetThread, StackContents &stackContents, BYTE *pData = NULL, unsigned int length = 0);
-
-        // Get the managed call stack for the current thread.
-        static bool WalkManagedStackForCurrentThread(StackContents &stackContents);
+public:
+    // Initialize the event pipe.
+    static void Initialize();
 
-        // Get the managed call stack for the specified thread.
-        static bool WalkManagedStackForThread(Thread *pThread, StackContents &stackContents);
+    // Shutdown the event pipe.
+    static void Shutdown();
 
-        // Save the command line for the current process.
-        static void SaveCommandLine(LPCWSTR pwzAssemblyPath, int argc, LPCWSTR *argv);
+    // Enable tracing via the event pipe.
+    static EventPipeSessionID Enable(
+        LPCWSTR strOutputPath,
+        uint32_t circularBufferSizeInMB,
+        uint64_t profilerSamplingRateInNanoseconds,
+        const EventPipeProviderConfiguration *pProviders,
+        uint32_t numProviders,
+        uint64_t multiFileTraceLengthInSeconds);
 
-        // Get next event.
-        static EventPipeEventInstance* GetNextEvent();
+    // Disable tracing via the event pipe.
+    static void Disable(EventPipeSessionID id);
 
-    protected:
+    // Get the session for the specified session ID.
+    static EventPipeSession *GetSession(EventPipeSessionID id);
 
-        // The counterpart to WriteEvent which after the payload is constructed
-        static void WriteEventInternal(EventPipeEvent &event, EventPipeEventPayload &payload, LPCGUID pActivityId = NULL, LPCGUID pRelatedActivityId = NULL);
+    // Specifies whether or not the event pipe is enabled.
+    static bool Enabled();
 
-    private:
+    // Create a provider.
+    static EventPipeProvider *CreateProvider(const SString &providerName, EventPipeCallback pCallbackFunction = NULL, void *pCallbackData = NULL);
 
-        // Enable the specified EventPipe session.
-        static EventPipeSessionID Enable(LPCWSTR strOutputPath, EventPipeSession *pSession);
+    // Get a provider.
+    static EventPipeProvider *GetProvider(const SString &providerName);
 
-        static void CreateFileSwitchTimer();
+    // Delete a provider.
+    static void DeleteProvider(EventPipeProvider *pProvider);
 
-        static void DeleteFileSwitchTimer();
+    // Write out an event from a flat buffer.
+    // Data is written as a serialized blob matching the ETW serialization conventions.
+    static void WriteEvent(EventPipeEvent &event, BYTE *pData, unsigned int length, LPCGUID pActivityId = NULL, LPCGUID pRelatedActivityId = NULL);
 
-        // Performs one polling operation to determine if it is necessary to switch to a new file.
-        // If the polling operation decides it is time, it will perform the switch.
-        // Called directly from the timer when the timer is triggered.
-        static void WINAPI SwitchToNextFileTimerCallback(PVOID parameter, BOOLEAN timerFired);
+    // Write out an event from an EventData array.
+    // Data is written as a serialized blob matching the ETW serialization conventions.
+    static void WriteEvent(EventPipeEvent &event, EventData *pEventData, unsigned int eventDataCount, LPCGUID pActivityId = NULL, LPCGUID pRelatedActivityId = NULL);
 
-        // If event pipe has been configured to write multiple files, switch to the next file.
-        static void SwitchToNextFile();
+    // Write out a sample profile event.
+    static void WriteSampleProfileEvent(Thread *pSamplingThread, EventPipeEvent *pEvent, Thread *pTargetThread, StackContents &stackContents, BYTE *pData = NULL, unsigned int length = 0);
 
-        // Generate the file path for the next trace file.
-        // This is used when event pipe has been configured to create multiple trace files with a specified maximum length of time.
-        static void GetNextFilePath(EventPipeSession *pSession, SString &nextTraceFilePath);
+    // Get the managed call stack for the current thread.
+    static bool WalkManagedStackForCurrentThread(StackContents &stackContents);
 
-        // Callback function for the stack walker.  For each frame walked, this callback is invoked.
-        static StackWalkAction StackWalkCallback(CrawlFrame *pCf, StackContents *pData);
+    // Get the managed call stack for the specified thread.
+    static bool WalkManagedStackForThread(Thread *pThread, StackContents &stackContents);
 
-        // Get the configuration object.
-        // This is called directly by the EventPipeProvider constructor to register the new provider.
-        static EventPipeConfiguration* GetConfiguration();
+    // Save the command line for the current process.
+    static void SaveCommandLine(LPCWSTR pwzAssemblyPath, int argc, LPCWSTR *argv);
 
-        // Get the event pipe configuration lock.
-        static CrstStatic* GetLock();
+    // Get next event.
+    static EventPipeEventInstance *GetNextEvent();
 
-        static CrstStatic s_configCrst;
-        static bool s_tracingInitialized;
-        static EventPipeConfiguration *s_pConfig;
-        static EventPipeSession *s_pSession;
-        static EventPipeBufferManager *s_pBufferManager;
-        static LPCWSTR s_pOutputPath;
-        static unsigned long s_nextFileIndex;
-        static EventPipeFile *s_pFile;
-        static EventPipeEventSource *s_pEventSource;
-        static LPCWSTR s_pCommandLine;
-        const static DWORD FileSwitchTimerPeriodMS = 1000;
-        static HANDLE s_fileSwitchTimerHandle;
-        static ULONGLONG s_lastFileSwitchTime;
+private:
+    // The counterpart to WriteEvent which after the payload is constructed
+    static void WriteEventInternal(EventPipeEvent &event, EventPipeEventPayload &payload, LPCGUID pActivityId = NULL, LPCGUID pRelatedActivityId = NULL);
+
+    // Enable the specified EventPipe session.
+    static EventPipeSessionID Enable(LPCWSTR strOutputPath, EventPipeSession *pSession);
+
+    static void CreateFileSwitchTimer();
+
+    static void DeleteFileSwitchTimer();
+
+    // Performs one polling operation to determine if it is necessary to switch to a new file.
+    // If the polling operation decides it is time, it will perform the switch.
+    // Called directly from the timer when the timer is triggered.
+    static void WINAPI SwitchToNextFileTimerCallback(PVOID parameter, BOOLEAN timerFired);
+
+    // If event pipe has been configured to write multiple files, switch to the next file.
+    static void SwitchToNextFile();
+
+    // Generate the file path for the next trace file.
+    // This is used when event pipe has been configured to create multiple trace files with a specified maximum length of time.
+    static void GetNextFilePath(EventPipeSession *pSession, SString &nextTraceFilePath);
+
+    // Callback function for the stack walker.  For each frame walked, this callback is invoked.
+    static StackWalkAction StackWalkCallback(CrawlFrame *pCf, StackContents *pData);
+
+    // Get the configuration object.
+    // This is called directly by the EventPipeProvider constructor to register the new provider.
+    static EventPipeConfiguration *GetConfiguration();
+
+    // Get the event pipe configuration lock.
+    static CrstStatic *GetLock();
+
+    static CrstStatic s_configCrst;
+    static bool s_tracingInitialized;
+    static EventPipeConfiguration *s_pConfig;
+    static EventPipeSession *s_pSession;
+    static EventPipeBufferManager *s_pBufferManager;
+    static LPCWSTR s_pOutputPath;
+    static unsigned long s_nextFileIndex;
+    static EventPipeFile *s_pFile;
+    static EventPipeEventSource *s_pEventSource;
+    static LPCWSTR s_pCommandLine;
+    const static DWORD FileSwitchTimerPeriodMS = 1000;
+    static HANDLE s_fileSwitchTimerHandle;
+    static ULONGLONG s_lastFileSwitchTime;
 };
 
 struct EventPipeProviderConfiguration
 {
-
 private:
-
-    LPCWSTR m_pProviderName;
-    UINT64 m_keywords;
-    UINT32 m_loggingLevel;
-    LPCWSTR m_pFilterData;
+    LPCWSTR m_pProviderName = nullptr;
+    UINT64 m_keywords = 0;
+    UINT32 m_loggingLevel = 0;
+    LPCWSTR m_pFilterData = nullptr;
 
 public:
+    EventPipeProviderConfiguration() = default;
 
-    EventPipeProviderConfiguration()
+    EventPipeProviderConfiguration(LPCWSTR pProviderName, UINT64 keywords, UINT32 loggingLevel, LPCWSTR pFilterData) :
+        m_pProviderName(pProviderName),
+        m_keywords(keywords),
+        m_loggingLevel(loggingLevel),
+        m_pFilterData(pFilterData)
     {
-        LIMITED_METHOD_CONTRACT;
-        m_pProviderName = NULL;
-        m_keywords = NULL;
-        m_loggingLevel = 0;
-        m_pFilterData = NULL;
-    }
-
-    EventPipeProviderConfiguration(
-        LPCWSTR pProviderName,
-        UINT64 keywords,
-        UINT32 loggingLevel,
-        LPCWSTR pFilterData)
-    {
-        LIMITED_METHOD_CONTRACT;
-        m_pProviderName = pProviderName;
-        m_keywords = keywords;
-        m_loggingLevel = loggingLevel;
-        m_pFilterData = pFilterData;
     }
 
     LPCWSTR GetProviderName() const
@@ -413,95 +390,6 @@ public:
     }
 };
 
-class EventPipeInternal
-{
-private:
-
-    enum class ActivityControlCode
-    {
-        EVENT_ACTIVITY_CONTROL_GET_ID = 1,
-        EVENT_ACTIVITY_CONTROL_SET_ID = 2,
-        EVENT_ACTIVITY_CONTROL_CREATE_ID = 3,
-        EVENT_ACTIVITY_CONTROL_GET_SET_ID = 4,
-        EVENT_ACTIVITY_CONTROL_CREATE_SET_ID = 5
-    };
-
-    struct EventPipeEventInstanceData
-    {
-    public:
-        void *ProviderID;
-        unsigned int EventID;
-        unsigned int ThreadID;
-        LARGE_INTEGER TimeStamp;
-        GUID ActivityId;
-        GUID RelatedActivityId;
-        const BYTE *Payload;
-        unsigned int PayloadLength;
-    };
-
-    struct EventPipeSessionInfo
-    {
-    public:
-        FILETIME StartTimeAsUTCFileTime;
-        LARGE_INTEGER StartTimeStamp;
-        LARGE_INTEGER TimeStampFrequency;
-    };
-
-public:
-
-    static UINT64 QCALLTYPE Enable(
-        __in_z LPCWSTR outputFile,
-        UINT32 circularBufferSizeInMB,
-        INT64 profilerSamplingRateInNanoseconds,
-        EventPipeProviderConfiguration *pProviders,
-        INT32 numProviders,
-        UINT64 multiFileTraceLengthInSeconds);
-
-    static void QCALLTYPE Disable(UINT64 sessionID);
-
-    static bool QCALLTYPE GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo);
-
-    static INT_PTR QCALLTYPE CreateProvider(
-        __in_z LPCWSTR providerName,
-        EventPipeCallback pCallbackFunc);
-
-    static INT_PTR QCALLTYPE DefineEvent(
-        INT_PTR provHandle,
-        UINT32 eventID,
-        __int64 keywords,
-        UINT32 eventVersion,
-        UINT32 level,
-        void *pMetadata,
-        UINT32 metadataLength);
-
-    static INT_PTR QCALLTYPE GetProvider(
-        __in_z LPCWSTR providerName);
-
-    static void QCALLTYPE DeleteProvider(
-        INT_PTR provHandle);
-
-    static int QCALLTYPE EventActivityIdControl(
-        uint controlCode,
-        GUID *pActivityId);
-
-    static void QCALLTYPE WriteEvent(
-        INT_PTR eventHandle,
-        UINT32 eventID,
-        void *pData,
-        UINT32 length,
-        LPCGUID pActivityId, LPCGUID pRelatedActivityId);
-
-    static void QCALLTYPE WriteEventData(
-        INT_PTR eventHandle,
-        UINT32 eventID,
-        EventData *pEventData,
-        UINT32 eventDataCount,
-        LPCGUID pActivityId, LPCGUID pRelatedActivityId);
-
-    static bool QCALLTYPE GetNextEvent(
-        EventPipeEventInstanceData *pInstance);
-};
-
 #endif // FEATURE_PERFTRACING
 
 #endif // __EVENTPIPE_H__