Basic infrastructure for binder tracing

src/System.Private.CoreLib/shared/System/Diagnostics/Tracing/ActivityTracker.cs

@@ -588,6 +588,25 @@ private void ActivityChanging(AsyncLocalValueChangedArgs<ActivityInfo?> args)
             // currently we do nothing, as that seems better than setting to Guid.Emtpy.
         }
 
+        // Assembly bind runtime activity name
+        private const string AssemblyBindName = "AssemblyBind";
+
+        /// <summary>
+        /// Called by the runtime to start an assembly bind activity
+        /// </summary>
+        private static void StartAssemblyBind(ref Guid activityId, ref Guid relatedActivityId)
+        {
+            Instance.OnStart(NativeRuntimeEventSource.Log.Name, AssemblyBindName, 0, ref activityId, ref relatedActivityId, EventActivityOptions.Recursive);
+        }
+
+        /// <summary>
+        /// Called by the runtime to stop an assembly bind activity
+        /// </summary>
+        private static void StopAssemblyBind(ref Guid activityId)
+        {
+            Instance.OnStop(NativeRuntimeEventSource.Log.Name, AssemblyBindName, 0, ref activityId);
+        }
+
         /// <summary>
         /// Async local variables have the property that the are automatically copied whenever a task is created and used
         /// while that task is running.   Thus m_current 'flows' to any task that is caused by the current thread that

src/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs

@@ -123,5 +123,8 @@ public static Assembly GetCallingAssembly()
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal static extern uint GetAssemblyCount();
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern bool IsBinderTracingEnabled();
     }
 }

src/binder/CMakeLists.txt

@@ -21,6 +21,7 @@ set(BINDER_COMMON_SOURCES
     assemblyidentitycache.cpp
     coreclrbindercommon.cpp
     fusionassemblyname.cpp
+    bindertracing.cpp
 )
 
 set(BINDER_COMMON_HEADERS
@@ -38,6 +39,7 @@ set(BINDER_COMMON_HEADERS
     inc/assemblyversion.hpp
     inc/assemblyversion.inl
     inc/bindertypes.hpp
+    inc/bindertracing.h
     inc/bindinglog.hpp
     inc/bindinglog.inl
     inc/bindresult.hpp
@@ -64,11 +66,13 @@ set(BINDER_COMMON_HEADERS
 
 set(BINDER_SOURCES
     ${BINDER_COMMON_SOURCES}
+    activitytracker.cpp
     clrprivbinderassemblyloadcontext.cpp
 )
 
 set(BINDER_HEADERS
     ${BINDER_COMMON_HEADERS}
+    inc/activitytracker.h
     inc/clrprivbinderassemblyloadcontext.h
     inc/contextentry.hpp
 )

src/binder/activitytracker.cpp

@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// ============================================================
+//
+// activitytracker.cpp
+//
+
+
+//
+// Helpers for interaction with the managed ActivityTracker
+//
+// ============================================================
+
+#include "common.h"
+#include "activitytracker.h"
+
+void ActivityTracker::Start(/*out*/ GUID *activityId, /*out*/ GUID *relatedActivityId)
+{
+    GCX_COOP();
+
+    PREPARE_NONVIRTUAL_CALLSITE(METHOD__ACTIVITY_TRACKER__START_ASSEMBLY_BIND);
+    DECLARE_ARGHOLDER_ARRAY(args, 1);
+    args[ARGNUM_0] = PTR_TO_ARGHOLDER(activityId);
+    args[ARGNUM_1] = PTR_TO_ARGHOLDER(relatedActivityId);
+
+    CALL_MANAGED_METHOD_NORET(args)
+}
+
+void ActivityTracker::Stop(/*out*/ GUID *activityId)
+{
+    GCX_COOP();
+
+    PREPARE_NONVIRTUAL_CALLSITE(METHOD__ACTIVITY_TRACKER__STOP_ASSEMBLY_BIND);
+    DECLARE_ARGHOLDER_ARRAY(args, 1);
+    args[ARGNUM_0] = PTR_TO_ARGHOLDER(activityId);
+
+    CALL_MANAGED_METHOD_NORET(args)
+}

src/binder/bindertracing.cpp

@@ -0,0 +1,116 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// ============================================================
+//
+// bindertracing.cpp
+//
+
+
+//
+// Implements helpers for binder tracing
+//
+// ============================================================
+
+#include "common.h"
+#include "bindertracing.h"
+
+#include "activitytracker.h"
+
+#ifdef FEATURE_EVENT_TRACE
+#include "eventtracebase.h"
+#endif // FEATURE_EVENT_TRACE
+
+using namespace BINDER_SPACE;
+
+namespace
+{
+    thread_local bool s_trackingBind = false;
+
+    void FireAssemblyBindStart(const BinderTracing::AssemblyBindEvent::BindRequest &request)
+    {
+#ifdef FEATURE_EVENT_TRACE
+        if (!EventEnabledAssemblyBindStart())
+            return;
+
+        GUID activityId = GUID_NULL;
+        GUID relatedActivityId = GUID_NULL;
+        ActivityTracker::Start(&activityId, &relatedActivityId);
+
+        FireEtwAssemblyBindStart(
+            GetClrInstanceId(),
+            request.AssemblyName,
+            request.AssemblyPath,
+            request.ParentAssembly,
+            request.AssemblyLoadContext,
+            &activityId,
+            &relatedActivityId);
+#endif // FEATURE_EVENT_TRACE
+    }
+
+    void FireAssemblyBindStop(const BinderTracing::AssemblyBindEvent::BindRequest &request, bool success, const WCHAR *resultName, const WCHAR *resultPath, bool cached)
+    {
+#ifdef FEATURE_EVENT_TRACE
+        if (!EventEnabledAssemblyBindStop())
+            return;
+
+        GUID activityId = GUID_NULL;
+        ActivityTracker::Stop(&activityId);
+
+        FireEtwAssemblyBindStop(
+            GetClrInstanceId(), 
+            request.AssemblyName,
+            request.AssemblyPath,
+            request.ParentAssembly,
+            request.AssemblyLoadContext,
+            success,
+            resultName,
+            resultPath,
+            cached,
+            &activityId);
+#endif // FEATURE_EVENT_TRACE
+    }
+}
+
+bool BinderTracing::IsEnabled()
+{
+#ifdef FEATURE_EVENT_TRACE
+    // Just check for the AssemblyBindStart event being enabled.
+    return EventEnabledAssemblyBindStart();
+#endif // FEATURE_EVENT_TRACE
+    return false;
+}
+
+namespace BinderTracing
+{
+    AssemblyBindEvent::AssemblyBindEvent(AssemblySpec *assemblySpec)
+        : m_bindRequest { assemblySpec }
+        , m_prevTrackingBind { s_trackingBind }
+        , m_success { false }
+        , m_cached { false }
+    {
+        _ASSERTE(assemblySpec != nullptr);
+
+        // ActivityTracker or EventSource may have triggered the system satellite load.
+        // Don't track system satellite binding to avoid potential infinite recursion.
+        s_trackingBind = BinderTracing::IsEnabled() && !m_bindRequest.AssemblySpec->IsMscorlibSatellite();
+        if (s_trackingBind)
+        {
+            m_bindRequest.AssemblySpec->GetFileOrDisplayName(ASM_DISPLAYF_VERSION | ASM_DISPLAYF_CULTURE | ASM_DISPLAYF_PUBLIC_KEY_TOKEN, m_bindRequest.AssemblyName);
+            FireAssemblyBindStart(m_bindRequest);
+        }
+    }
+
+    AssemblyBindEvent::~AssemblyBindEvent()
+    {
+        if (s_trackingBind)
+            FireAssemblyBindStop(m_bindRequest, m_success, m_resultName.GetUnicode(), m_resultPath.GetUnicode(), m_cached);
+
+        s_trackingBind = m_prevTrackingBind;
+    }
+
+    void AssemblyBindEvent::SetResult(PEAssembly *assembly)
+    {
+        m_success = assembly != nullptr;
+    }
+}

src/binder/inc/activitytracker.h

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+//
+// activitytracker.h
+//
+
+#ifndef __ACTIVITY_TRACKER_H__
+#define __ACTIVITY_TRACKER_H__
+
+namespace ActivityTracker
+{
+    void Start(/*out*/ GUID *activityId, /*out*/ GUID *relatedActivityId);
+    void Stop(/*out*/ GUID *activityId);
+};
+
+#endif // __ACTIVITY_TRACKER_H__

src/binder/inc/bindertracing.h

@@ -0,0 +1,50 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+//
+// bindertracing.h
+//
+
+#ifndef __BINDER_TRACING_H__
+#define __BINDER_TRACING_H__
+
+class AssemblySpec;
+class PEAssembly;
+
+namespace BinderTracing
+{
+    bool IsEnabled();
+
+    // If tracing is enabled, this class fires an assembly bind start event on construction
+    // and the corresponding stop event on destruction
+    class AssemblyBindEvent
+    {
+    public:
+        // This class assumes the assembly spec will have a longer lifetime than itself
+        AssemblyBindEvent(AssemblySpec *assemblySpec);
+        ~AssemblyBindEvent();
+
+        void SetResult(PEAssembly *assembly);
+
+        struct BindRequest
+        {
+            AssemblySpec *AssemblySpec;
+            SString AssemblyName;
+            SString AssemblyPath;
+            SString ParentAssembly;
+            SString AssemblyLoadContext;
+        };
+
+    private:
+        BindRequest m_bindRequest;
+
+        bool m_prevTrackingBind;
+
+        bool m_success;
+        SString m_resultName;
+        SString m_resultPath;
+        bool m_cached;
+    };
+};
+
+#endif // __BINDER_TRACING_H__