Line data    Source code

       1             : /*
       2             :  *    Copyright (c) 2023 Project CHIP Authors
       3             :  *    All rights reserved.
       4             :  *
       5             :  *    Licensed under the Apache License, Version 2.0 (the "License");
       6             :  *    you may not use this file except in compliance with the License.
       7             :  *    You may obtain a copy of the License at
       8             :  *
       9             :  *        http://www.apache.org/licenses/LICENSE-2.0
      10             :  *
      11             :  *    Unless required by applicable law or agreed to in writing, software
      12             :  *    distributed under the License is distributed on an "AS IS" BASIS,
      13             :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      14             :  *    See the License for the specific language governing permissions and
      15             :  *    limitations under the License.
      16             :  */
      17             : #include <lib/support/IntrusiveList.h>
      18             : 
      19             : #include <matter/tracing/build_config.h>
      20             : #include <platform/LockTracker.h>
      21             : #include <tracing/registry.h>
      22             : 
      23             : namespace chip {
      24             : namespace Tracing {
      25             : namespace {
      26             : 
      27             : IntrusiveList<Backend> gTracingBackends;
      28             : 
      29             : } // namespace
      30             : 
      31           0 : void Register(Backend & backend)
      32             : {
      33           0 :     assertChipStackLockedByCurrentThread();
      34           0 :     if (!backend.IsInList())
      35             :     {
      36           0 :         backend.Open();
      37           0 :         gTracingBackends.PushBack(&backend);
      38             :     }
      39           0 : }
      40             : 
      41           0 : void Unregister(Backend & backend)
      42             : {
      43           0 :     assertChipStackLockedByCurrentThread();
      44           0 :     if (backend.IsInList())
      45             :     {
      46           0 :         gTracingBackends.Remove(&backend);
      47           0 :         backend.Close();
      48             :     }
      49           0 : }
      50             : 
      51             : #if MATTER_TRACING_ENABLED
      52             : 
      53             : namespace Internal {
      54             : 
      55             : void Begin(const char * label, const char * group)
      56             : {
      57             :     for (auto & backend : gTracingBackends)
      58             :     {
      59             :         backend.TraceBegin(label, group);
      60             :     }
      61             : }
      62             : 
      63             : void End(const char * label, const char * group)
      64             : {
      65             :     for (auto & backend : gTracingBackends)
      66             :     {
      67             :         backend.TraceEnd(label, group);
      68             :     }
      69             : }
      70             : 
      71             : void Instant(const char * label, const char * group)
      72             : {
      73             :     for (auto & backend : gTracingBackends)
      74             :     {
      75             :         backend.TraceInstant(label, group);
      76             :     }
      77             : }
      78             : 
      79             : void Counter(const char * label)
      80             : {
      81             :     for (auto & backend : gTracingBackends)
      82             :     {
      83             :         backend.TraceCounter(label);
      84             :     }
      85             : }
      86             : 
      87             : void Metric(const char * label, int32_t value)
      88             : {
      89             :     for (auto & backend : gTracingBackends)
      90             :     {
      91             :         backend.TraceMetric(label, value);
      92             :     }
      93             : }
      94             : 
      95             : void LogMessageSend(::chip::Tracing::MessageSendInfo & info)
      96             : {
      97             :     for (auto & backend : gTracingBackends)
      98             :     {
      99             :         backend.LogMessageSend(info);
     100             :     }
     101             : }
     102             : 
     103             : void LogMessageReceived(::chip::Tracing::MessageReceivedInfo & info)
     104             : {
     105             :     for (auto & backend : gTracingBackends)
     106             :     {
     107             :         backend.LogMessageReceived(info);
     108             :     }
     109             : }
     110             : 
     111             : void LogNodeLookup(::chip::Tracing::NodeLookupInfo & info)
     112             : {
     113             :     for (auto & backend : gTracingBackends)
     114             :     {
     115             :         backend.LogNodeLookup(info);
     116             :     }
     117             : }
     118             : 
     119             : void LogNodeDiscovered(::chip::Tracing::NodeDiscoveredInfo & info)
     120             : {
     121             :     for (auto & backend : gTracingBackends)
     122             :     {
     123             :         backend.LogNodeDiscovered(info);
     124             :     }
     125             : }
     126             : 
     127             : void LogNodeDiscoveryFailed(::chip::Tracing::NodeDiscoveryFailedInfo & info)
     128             : {
     129             :     for (auto & backend : gTracingBackends)
     130             :     {
     131             :         backend.LogNodeDiscoveryFailed(info);
     132             :     }
     133             : }
     134             : 
     135             : } // namespace Internal
     136             : 
     137             : #endif // MATTTER_TRACING_ENABLED
     138             : 
     139             : } // namespace Tracing
     140             : } // namespace chip