Use function pointers instead of marshalled delegates in EventSource

src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Eventing/EventPipe.CoreCLR.cs

@@ -29,7 +29,9 @@ private static unsafe partial ulong Enable(
         // These PInvokes are used by EventSource to interact with the EventPipe.
         //
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_CreateProvider", StringMarshalling = StringMarshalling.Utf16)]
-        internal static partial IntPtr CreateProvider(string providerName, Interop.Advapi32.EtwEnableCallback callbackFunc);
+        internal static unsafe partial IntPtr CreateProvider(string providerName,
+            delegate* unmanaged<byte*, int, byte, long, long, Interop.Advapi32.EVENT_FILTER_DESCRIPTOR*, void*, void> callbackFunc,
+            void* callbackContext);
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DefineEvent")]
         internal static unsafe partial IntPtr DefineEvent(IntPtr provHandle, uint eventID, long keywords, uint eventVersion, uint level, void *pMetadata, uint metadataLength);

src/coreclr/scripts/genEventPipe.py

@@ -1035,7 +1035,7 @@ def getMonoEventPipeImplFilePrefix():
 
     ep_return_null_if_nok (provider_name_utf8 != NULL);
 
-    EventPipeProvider *provider = ep_create_provider (provider_name_utf8, callback_func, NULL, NULL);
+    EventPipeProvider *provider = ep_create_provider (provider_name_utf8, callback_func, NULL);
 
     g_free (provider_name_utf8);
     return provider;

src/coreclr/vm/eventpipeadapter.h

@@ -318,7 +318,7 @@ class EventPipeAdapter final
 		ep_add_provider_to_session (provider, session);
 	}
 
-	static inline EventPipeProvider * CreateProvider(const SString &providerName, EventPipeCallback callback)
+	static inline EventPipeProvider * CreateProvider(const SString &providerName, EventPipeCallback callback, void* callbackContext = nullptr)
 	{
 		CONTRACTL
 		{
@@ -329,7 +329,7 @@ class EventPipeAdapter final
 		CONTRACTL_END;
 
 		ep_char8_t *providerNameUTF8 = ep_rt_utf16_to_utf8_string(reinterpret_cast<const ep_char16_t *>(providerName.GetUnicode ()), -1);
-		EventPipeProvider * provider = ep_create_provider (providerNameUTF8, callback, NULL, NULL);
+		EventPipeProvider * provider = ep_create_provider (providerNameUTF8, callback, callbackContext);
 		ep_rt_utf8_string_free (providerNameUTF8);
 		return provider;
 	}

src/coreclr/vm/eventpipeinternal.cpp

@@ -85,15 +85,16 @@ extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, Eve
 
 extern "C" INT_PTR QCALLTYPE EventPipeInternal_CreateProvider(
     _In_z_ LPCWSTR providerName,
-    EventPipeCallback pCallbackFunc)
+    EventPipeCallback pCallbackFunc,
+    void* pCallbackContext)
 {
     QCALL_CONTRACT;
 
     EventPipeProvider *pProvider = NULL;
 
     BEGIN_QCALL;
 
-    pProvider = EventPipeAdapter::CreateProvider(providerName, pCallbackFunc);
+    pProvider = EventPipeAdapter::CreateProvider(providerName, pCallbackFunc, pCallbackContext);
 
     END_QCALL;
 

src/coreclr/vm/eventpipeinternal.h

@@ -55,7 +55,8 @@ extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, Eve
 
 extern "C" INT_PTR QCALLTYPE EventPipeInternal_CreateProvider(
     _In_z_ LPCWSTR providerName,
-    EventPipeCallback pCallbackFunc);
+    EventPipeCallback pCallbackFunc,
+    void* pCallbackContext);
 
 extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent(
     INT_PTR provHandle,

src/libraries/Common/src/Interop/Windows/Advapi32/Interop.EtwEnableCallback.cs

@@ -19,14 +19,5 @@ internal struct EVENT_FILTER_DESCRIPTOR
             public int Size;
             public int Type;
         }
-
-        internal unsafe delegate void EtwEnableCallback(
-            Guid* sourceId,
-            int isEnabled,
-            byte level,
-            long matchAnyKeywords,
-            long matchAllKeywords,
-            EVENT_FILTER_DESCRIPTOR* filterData,
-            void* callbackContext);
     }
 }

src/libraries/Common/src/Interop/Windows/Advapi32/Interop.EventRegister.cs

@@ -10,9 +10,9 @@ internal static partial class Advapi32
     {
         [LibraryImport(Libraries.Advapi32)]
         internal static unsafe partial uint EventRegister(
-            in Guid providerId,
-            EtwEnableCallback enableCallback,
+            Guid* providerId,
+            delegate* unmanaged<Guid*, int, byte, long, long, EVENT_FILTER_DESCRIPTOR*, void*, void> enableCallback,
             void* callbackContext,
-            ref long registrationHandle);
+            long* registrationHandle);
     }
 }

src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs

@@ -1,47 +1,59 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Runtime.InteropServices;
+
 namespace System.Diagnostics.Tracing
 {
     internal sealed class EventPipeEventProvider : IEventProvider
     {
-        // The EventPipeProvider handle.
-        private IntPtr m_provHandle = IntPtr.Zero;
+        private EventEnableCallback? _enableCallback;
+        private IntPtr _provHandle;
+        private GCHandle _gcHandle;
+
+        [UnmanagedCallersOnly]
+        private static unsafe void Callback(byte* sourceId, int isEnabled, byte level,
+            long matchAnyKeywords, long matchAllKeywords, Interop.Advapi32.EVENT_FILTER_DESCRIPTOR* filterData, void* callbackContext)
+        {
+            ((EventPipeEventProvider)GCHandle.FromIntPtr((IntPtr)callbackContext).Target!)._enableCallback!(
+                isEnabled, level, matchAnyKeywords, matchAllKeywords, filterData);
+        }
 
         // Register an event provider.
-        unsafe uint IEventProvider.EventRegister(
+        unsafe void IEventProvider.EventRegister(
             EventSource eventSource,
-            Interop.Advapi32.EtwEnableCallback enableCallback,
-            void* callbackContext,
-            ref long registrationHandle)
+            EventEnableCallback enableCallback)
         {
-            uint returnStatus = 0;
-            m_provHandle = EventPipeInternal.CreateProvider(eventSource.Name, enableCallback);
-            if (m_provHandle != IntPtr.Zero)
-            {
-                // Fixed registration handle because a new EventPipeEventProvider
-                // will be created for each new EventSource.
-                registrationHandle = 1;
-            }
-            else
+            _enableCallback = enableCallback;
+
+            Debug.Assert(!_gcHandle.IsAllocated);
+            _gcHandle = GCHandle.Alloc(this);
+
+            _provHandle = EventPipeInternal.CreateProvider(eventSource.Name, &Callback, (void*)GCHandle.ToIntPtr(_gcHandle));
+            if (_provHandle == 0)
             {
                 // Unable to create the provider.
-                returnStatus = 1;
+                _gcHandle.Free();
+                throw new OutOfMemoryException();
             }
-
-            return returnStatus;
         }
 
         // Unregister an event provider.
-        uint IEventProvider.EventUnregister(long registrationHandle)
+        void IEventProvider.EventUnregister()
         {
-            EventPipeInternal.DeleteProvider(m_provHandle);
-            return 0;
+            if (_provHandle != 0)
+            {
+                EventPipeInternal.DeleteProvider(_provHandle);
+                _provHandle = 0;
+            }
+            if (_gcHandle.IsAllocated)
+            {
+                _gcHandle.Free();
+            }
         }
 
         // Write an event.
         unsafe EventProvider.WriteEventErrorCode IEventProvider.EventWriteTransfer(
-            long registrationHandle,
             in EventDescriptor eventDescriptor,
             IntPtr eventHandle,
             Guid* activityId,
@@ -82,8 +94,7 @@ int IEventProvider.EventActivityIdControl(Interop.Advapi32.ActivityControl contr
         unsafe IntPtr IEventProvider.DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level,
             byte *pMetadata, uint metadataLength)
         {
-            IntPtr eventHandlePtr = EventPipeInternal.DefineEvent(m_provHandle, eventID, keywords, eventVersion, level, pMetadata, metadataLength);
-            return eventHandlePtr;
+            return EventPipeInternal.DefineEvent(_provHandle, eventID, keywords, eventVersion, level, pMetadata, metadataLength);
         }
 
         // Get or set the per-thread activity ID.