src/vm/eventpipeevent.cpp

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 #include "common.h"
   6 #include "eventpipeevent.h"
   7 #include "eventpipeprovider.h"
   8
   9 #ifdef FEATURE_PERFTRACING
  10
  11 EventPipeEvent::EventPipeEvent(
  12     EventPipeProvider &provider,
  13     INT64 keywords,
  14     unsigned int eventID,
  15     unsigned int eventVersion,
  16     EventPipeEventLevel level,
  17     bool needStack,
  18     BYTE *pMetadata,
  19     unsigned int metadataLength) : m_pProvider(&provider),
  20                                    m_keywords(keywords),
  21                                    m_eventID(eventID),
  22                                    m_eventVersion(eventVersion),
  23                                    m_level(level),
  24                                    m_needStack(needStack),
  25                                    m_enabledMask(0),
  26                                    m_pMetadata(nullptr)
  27 {
  28     CONTRACTL
  29     {
  30         THROWS;
  31         GC_NOTRIGGER;
  32         MODE_ANY;
  33         PRECONDITION(&provider != nullptr);
  34     }
  35     CONTRACTL_END;
  36
  37     if (pMetadata != nullptr)
  38     {
  39         m_pMetadata = new BYTE[metadataLength];
  40         memcpy(m_pMetadata, pMetadata, metadataLength);
  41         m_metadataLength = metadataLength;
  42     }
  43     else
  44     {
  45         // if metadata is not provided, we have to build the minimum version. It's required by the serialization contract
  46         m_pMetadata = BuildMinimumMetadata();
  47         m_metadataLength = MinimumMetadataLength;
  48     }
  49 }
  50
  51 EventPipeEvent::~EventPipeEvent()
  52 {
  53     CONTRACTL
  54     {
  55         NOTHROW;
  56         GC_NOTRIGGER;
  57         MODE_ANY;
  58     }
  59     CONTRACTL_END;
  60
  61     delete[] m_pMetadata;
  62 }
  63
  64 BYTE *EventPipeEvent::BuildMinimumMetadata()
  65 {
  66     CONTRACTL
  67     {
  68         THROWS;
  69         GC_NOTRIGGER;
  70         MODE_ANY;
  71     }
  72     CONTRACTL_END;
  73
  74     BYTE *minmumMetadata = new BYTE[MinimumMetadataLength];
  75     BYTE *currentPtr = minmumMetadata;
  76
  77     // the order of fields is defined in coreclr\src\mscorlib\shared\System\Diagnostics\Tracing\EventSource.cs DefineEventPipeEvents method
  78     memcpy(currentPtr, &m_eventID, sizeof(m_eventID));
  79     currentPtr += sizeof(m_eventID);
  80
  81     SString eventName = SString::Empty();
  82     unsigned int eventNameSize = (eventName.GetCount() + 1) * sizeof(WCHAR);
  83     memcpy(currentPtr, (BYTE *)eventName.GetUnicode(), eventNameSize);
  84     currentPtr += eventNameSize;
  85
  86     memcpy(currentPtr, &m_keywords, sizeof(m_keywords));
  87     currentPtr += sizeof(m_keywords);
  88
  89     memcpy(currentPtr, &m_eventVersion, sizeof(m_eventVersion));
  90     currentPtr += sizeof(m_eventVersion);
  91
  92     memcpy(currentPtr, &m_level, sizeof(m_level));
  93     currentPtr += sizeof(m_level);
  94
  95     unsigned int noParameters = 0;
  96     memcpy(currentPtr, &noParameters, sizeof(noParameters));
  97     currentPtr += sizeof(noParameters);
  98
  99     return minmumMetadata;
 100 }
 101
 102 EventPipeProvider *EventPipeEvent::GetProvider() const
 103 {
 104     LIMITED_METHOD_CONTRACT;
 105     return m_pProvider;
 106 }
 107
 108 INT64 EventPipeEvent::GetKeywords() const
 109 {
 110     LIMITED_METHOD_CONTRACT;
 111     return m_keywords;
 112 }
 113
 114 unsigned int EventPipeEvent::GetEventID() const
 115 {
 116     LIMITED_METHOD_CONTRACT;
 117     return m_eventID;
 118 }
 119
 120 unsigned int EventPipeEvent::GetEventVersion() const
 121 {
 122     LIMITED_METHOD_CONTRACT;
 123     return m_eventVersion;
 124 }
 125
 126 EventPipeEventLevel EventPipeEvent::GetLevel() const
 127 {
 128     LIMITED_METHOD_CONTRACT;
 129     return m_level;
 130 }
 131
 132 bool EventPipeEvent::NeedStack() const
 133 {
 134     LIMITED_METHOD_CONTRACT;
 135     return m_needStack;
 136 }
 137
 138 bool EventPipeEvent::IsEnabled() const
 139 {
 140     LIMITED_METHOD_CONTRACT;
 141     return m_enabledMask != 0;
 142 }
 143
 144 BYTE *EventPipeEvent::GetMetadata() const
 145 {
 146     LIMITED_METHOD_CONTRACT;
 147     return m_pMetadata;
 148 }
 149
 150 unsigned int EventPipeEvent::GetMetadataLength() const
 151 {
 152     LIMITED_METHOD_CONTRACT;
 153     return m_metadataLength;
 154 }
 155
 156 void EventPipeEvent::RefreshState()
 157 {
 158     LIMITED_METHOD_CONTRACT;
 159     _ASSERTE(EventPipe::IsLockOwnedByCurrentThread());
 160     m_enabledMask = m_pProvider->ComputeEventEnabledMask(m_keywords, m_level);
 161 }
 162
 163 bool EventPipeEvent::IsEnabled(uint64_t sessionMask) const
 164 {
 165     LIMITED_METHOD_CONTRACT;
 166     _ASSERTE(m_pProvider != nullptr);
 167     return (m_pProvider->IsEnabled(sessionMask) && (m_enabledMask & sessionMask) != 0);
 168 }
 169
 170 #endif // FEATURE_PERFTRACING