Bug 1674452: Add interface information to ORPC profiler markers; r=Jamie

* We add a new function to `mscom/Utils.h`: `DiagnosticNameForIID`. Its
  purpose is to generate a friendly name for an interface, given an IID.
  For special interfaces internal to COM, we add our own descriptive strings.
  If the interface does not have a description, we simply convert the IID
  to string format using GUIDToString.
* We modify `ProfilerMarkerChannelHook` to include the additional diagnostic
  information for IIDs in its markers.
* Since each marker is now differentiated by IID, we remove the restriction
  that we only use markers for the outermost COM call. In particular, this
  assumption doesn't hold for asynchronous COM calls, so we would be losing
  data in the case where an async call was pending while the main thread was
  still making COM calls on other interfaces.
  * There isn't really an effective way to distinguish between sync and
    async calls at the channel hook layer. I'm thinking about how we could
    perhaps modify `AsyncInvoker` to help mark these, but it's a bit messy.
    I'm going to postpone that to future work.
* Other potential future work is expanding the number of interfaces for which
  we have frendly names. I could see us annotating our various COM interfaces
  in a way that we could automagically generate human-readable descriptions for
  those interfaces.

Differential Revision: https://phabricator.services.mozilla.com/D97042

Author: dblohm7

ipc/mscom/ProfilerMarkers.cpp

@@ -11,11 +11,13 @@
 #include "mozilla/Assertions.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/DebugOnly.h"
+#include "mozilla/mscom/Utils.h"
 #include "mozilla/Services.h"
 #include "nsCOMPtr.h"
 #include "nsIObserver.h"
 #include "nsIObserverService.h"
 #include "nsISupportsImpl.h"
+#include "nsString.h"
 #include "nsXULAppAPI.h"
 
 #include <objbase.h>
@@ -31,7 +33,7 @@ class ProfilerMarkerChannelHook final : public IChannelHook {
   ~ProfilerMarkerChannelHook() = default;
 
  public:
-  ProfilerMarkerChannelHook() : mRefCnt(0), mMainThreadORPCDepth(0) {}
+  ProfilerMarkerChannelHook() : mRefCnt(0) {}
 
   // IUnknown
   STDMETHODIMP QueryInterface(REFIID aIid, void** aOutInterface) override;
@@ -58,10 +60,6 @@ class ProfilerMarkerChannelHook final : public IChannelHook {
    *
    * Finally, our implementation responds to any request matching our extension
    * ID, however we only care about main thread COM calls.
-   *
-   * Further note that COM allows re-entrancy, however for our purposes we only
-   * care about the outermost IPC call on the main thread, so we use the
-   * mMainThreadORPCDepth variable to track that.
    */
 
   // IChannelHook
@@ -91,9 +89,11 @@ class ProfilerMarkerChannelHook final : public IChannelHook {
   ServerFillBuffer(REFGUID aExtensionId, REFIID aIid, ULONG* aDataSize,
                    void* aDataBuf, HRESULT aFault) override {}
 
+ private:
+  void BuildMarkerName(REFIID aIid, nsACString& aOutMarkerName);
+
  private:
   mozilla::Atomic<ULONG> mRefCnt;
-  ULONG mMainThreadORPCDepth;
 };
 
 HRESULT ProfilerMarkerChannelHook::QueryInterface(REFIID aIid,
@@ -118,16 +118,23 @@ ULONG ProfilerMarkerChannelHook::Release() {
   return result;
 }
 
+void ProfilerMarkerChannelHook::BuildMarkerName(REFIID aIid,
+                                                nsACString& aOutMarkerName) {
+  aOutMarkerName.AssignLiteral("ORPC Call for ");
+
+  nsAutoCString iidStr;
+  mozilla::mscom::DiagnosticNameForIID(aIid, iidStr);
+  aOutMarkerName.Append(iidStr);
+}
+
 void ProfilerMarkerChannelHook::ClientGetSize(REFGUID aExtensionId, REFIID aIid,
                                               ULONG* aOutDataSize) {
   if (aExtensionId == GUID_MozProfilerMarkerExtension) {
     if (NS_IsMainThread()) {
-      if (!mMainThreadORPCDepth) {
-        PROFILER_TRACING_MARKER("MSCOM", "ORPC Call", IPC,
-                                TRACING_INTERVAL_START);
-      }
-
-      ++mMainThreadORPCDepth;
+      nsAutoCString markerName;
+      BuildMarkerName(aIid, markerName);
+      PROFILER_TRACING_MARKER("MSCOM", markerName.get(), IPC,
+                              TRACING_INTERVAL_START);
     }
 
     if (aOutDataSize) {
@@ -140,12 +147,11 @@ void ProfilerMarkerChannelHook::ClientGetSize(REFGUID aExtensionId, REFIID aIid,
 void ProfilerMarkerChannelHook::ClientNotify(REFGUID aExtensionId, REFIID aIid,
                                              ULONG aDataSize, void* aDataBuffer,
                                              DWORD aDataRep, HRESULT aFault) {
-  if (aExtensionId == GUID_MozProfilerMarkerExtension && NS_IsMainThread()) {
-    MOZ_ASSERT(mMainThreadORPCDepth > 0);
-    --mMainThreadORPCDepth;
-    if (!mMainThreadORPCDepth) {
-      PROFILER_TRACING_MARKER("MSCOM", "ORPC Call", IPC, TRACING_INTERVAL_END);
-    }
+  if (NS_IsMainThread() && aExtensionId == GUID_MozProfilerMarkerExtension) {
+    nsAutoCString markerName;
+    BuildMarkerName(aIid, markerName);
+    PROFILER_TRACING_MARKER("MSCOM", markerName.get(), IPC,
+                            TRACING_INTERVAL_END);
   }
 }
 

ipc/mscom/Utils.cpp

@@ -28,6 +28,8 @@
 #include <shlwapi.h>
 #include <winnt.h>
 
+#include <utility>
+
 #if defined(_MSC_VER)
 extern "C" IMAGE_DOS_HEADER __ImageBase;
 #endif
@@ -317,6 +319,82 @@ void GUIDToString(REFGUID aGuid, nsAString& aOutString) {
   }
 }
 
+// Undocumented IIDs that are relevant for diagnostic purposes
+static const IID IID_ISCMLocalActivator = {
+    0x00000136,
+    0x0000,
+    0x0000,
+    {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}};
+static const IID IID_IRundown = {
+    0x00000134,
+    0x0000,
+    0x0000,
+    {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}};
+static const IID IID_IRemUnknown = {
+    0x00000131,
+    0x0000,
+    0x0000,
+    {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}};
+static const IID IID_IRemUnknown2 = {
+    0x00000143,
+    0x0000,
+    0x0000,
+    {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}};
+
+struct IIDToLiteralMapEntry {
+  constexpr IIDToLiteralMapEntry(REFIID aIid, nsLiteralCString&& aStr)
+      : mIid(aIid), mStr(std::forward<nsLiteralCString>(aStr)) {}
+
+  REFIID mIid;
+  const nsLiteralCString mStr;
+};
+
+/**
+ * Given the name of an interface, the IID_ENTRY macro generates a pair
+ * containing a reference to the interface ID and a stringified version of
+ * the interface name.
+ *
+ * For example:
+ *
+ *   {IID_ENTRY(IUnknown)}
+ * is expanded to:
+ *   {IID_IUnknown, "IUnknown"_ns}
+ *
+ */
+// clang-format off
+#  define IID_ENTRY_STRINGIFY(iface) #iface##_ns
+#  define IID_ENTRY(iface) IID_##iface, IID_ENTRY_STRINGIFY(iface)
+// clang-format on
+
+// Mapping of selected IIDs to friendly, human readable descriptions for each
+// interface.
+static constexpr IIDToLiteralMapEntry sIidDiagStrs[] = {
+    {IID_ENTRY(IUnknown)},
+    {IID_IRemUnknown, "cross-apartment IUnknown"_ns},
+    {IID_IRundown, "cross-apartment object management"_ns},
+    {IID_ISCMLocalActivator, "out-of-process object instantiation"_ns},
+    {IID_IRemUnknown2, "cross-apartment IUnknown"_ns}};
+
+#  undef IID_ENTRY
+#  undef IID_ENTRY_STRINGIFY
+
+void DiagnosticNameForIID(REFIID aIid, nsACString& aOutString) {
+  // If the IID matches something in sIidDiagStrs, output its string.
+  for (const auto& curEntry : sIidDiagStrs) {
+    if (curEntry.mIid == aIid) {
+      aOutString.Assign(curEntry.mStr);
+      return;
+    }
+  }
+
+  // Otherwise just convert the IID to string form and output that.
+  nsAutoString strIid;
+  GUIDToString(aIid, strIid);
+
+  aOutString.AssignLiteral("IID ");
+  AppendUTF16toUTF8(strIid, aOutString);
+}
+
 #else
 
 void GUIDToString(REFGUID aGuid,

ipc/mscom/Utils.h

@@ -105,6 +105,15 @@ constexpr size_t kGuidRegFormatCharLenInclNul = 39;
 bool IsClassThreadAwareInprocServer(REFCLSID aClsid);
 
 void GUIDToString(REFGUID aGuid, nsAString& aOutString);
+
+/**
+ * Converts an IID to a human-readable string for the purposes of diagnostic
+ * tools such as the profiler. For some special cases, we output a friendly
+ * string that describes the purpose of the interface. If no such description
+ * exists, we simply fall back to outputting the IID as a string formatted by
+ * GUIDToString().
+ */
+void DiagnosticNameForIID(REFIID aIid, nsACString& aOutString);
 #else
 void GUIDToString(REFGUID aGuid,
                   wchar_t (&aOutBuf)[kGuidRegFormatCharLenInclNul]);