[trace][intelpt] Support system-wide tracing [7] - Create a base IntelPTProcessTrace class

[wallace]

Summary

We have two different "process trace" implementations: per thread and per core. As a way to simplify the collector who uses both, I'm creating a base abstract class that is used by these implementations. This effectively simplify a good chunk of code.

[wallace]

lldb/source/Plugins/Process/Linux/IntelPTCollector.cpp

70

this shouldn't have been here since the beginning

lldb/source/Plugins/Process/Linux/IntelPTSingleBufferTrace.cpp

320 ↗

(On Diff #429077)

I've just found this bug. I'll try to create a unit test later.

[wallace]

rebase

[jj10306]

lldb/source/Plugins/Process/Linux/IntelPTCollector.h

73

Could this be moved to be a part of the new IntelPTProcessTrace abstract class or is this also needed for handling thread trace?

lldb/source/Plugins/Process/Linux/IntelPTMultiCoreTrace.cpp

36–38

If this now returns IntelPTProcessTraceUP instead of an instance of itself, then we are basically forcing any uses of this class to be done using dynamic polymorphism (behind the indirection of a pointer to the super class). Should this instead return an instance of itself and then leave it up to the caller to decide if they want to use the object directly or behind a pointer?
I know that currently the only use of this is behind the IntelPTProcessTraceUP (stored on the collector), but maybe in the future we would want to use it directly.
wdyt?

119–125

In TracesThread you check that the tid is a thread of m_process but in TraceStart you return success for all threads without checking if it's a part of the process.
I don't think it particularly matters if we do the check or not, but I do think that the behavior should be consistent between these functions.

lldb/source/Plugins/Process/Linux/IntelPTPerThreadProcessTrace.cpp

58

same comment here as above on the other subclasss

lldb/source/Plugins/Process/Linux/IntelPTProcessTrace.h

20

[wallace]

lldb/source/Plugins/Process/Linux/IntelPTCollector.h

73

i can't because you the reason you mention: thread trace

lldb/source/Plugins/Process/Linux/IntelPTMultiCoreTrace.cpp

36–38

good call

119–125

ahh you are right

lldb/source/Plugins/Process/Linux/IntelPTPerThreadProcessTrace.cpp

58

+1

lldb/source/Plugins/Process/Linux/IntelPTProcessTrace.h

20

+1

[wallace]

This was fixed in https://reviews.llvm.org/D127456

lldb/source/Plugins/Process/Linux/IntelPTCollector.h

 
 private:
   llvm::Error TraceStop(lldb::tid_t tid);
 
   /// Start tracing a specific thread.
   llvm::Error TraceStart(lldb::tid_t tid,
                          const TraceIntelPTStartRequest &request);
 
-  llvm::Expected<IntelPTSingleBufferTrace &> GetTracedThread(lldb::tid_t tid);
-
-  bool IsProcessTracingEnabled() const;
-
-  void ClearProcessTracing();
-
+  /// The target process.
   NativeProcessProtocol &m_process;
   /// Threads traced due to "thread tracing"
   IntelPTThreadTraceCollection m_thread_traces;
 
-  /// Only one of the following "process tracing" handlers can be active at a
-  /// given time.
-  ///
-  /// \{
-  /// Threads traced due to per-thread "process tracing".  This might be \b
-  /// nullptr.
-  IntelPTPerThreadProcessTraceUP m_per_thread_process_trace_up;
-  /// Cores traced due to per-core "process tracing".  This might be \b nullptr.
-  IntelPTMultiCoreTraceUP m_per_core_process_trace_up;
-  /// \}
+  /// Only one instance of "process trace" can be active at a given time.
+  /// It might be \b nullptr.
+  IntelPTProcessTraceUP m_process_trace_up;
 
   /// TSC to wall time conversion.
   TraceTscConversionUP m_tsc_conversion;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // liblldb_IntelPTCollector_H_

lldb/source/Plugins/Process/Linux/IntelPTCollector.cpp

if (Expected<LinuxPerfZeroTscConversion> tsc_conversion =
     m_tsc_conversion =
         std::make_unique<LinuxPerfZeroTscConversion>(*tsc_conversion);
   else
     LLDB_LOG_ERROR(GetLog(POSIXLog::Trace), tsc_conversion.takeError(),
                    "unable to load TSC to wall time conversion: {0}");
 }
 
 Error IntelPTCollector::TraceStop(lldb::tid_t tid) {
-  if (m_per_thread_process_trace_up &&
-      m_per_thread_process_trace_up->TracesThread(tid))
-    return m_per_thread_process_trace_up->TraceStop(tid);
-  else if (m_per_core_process_trace_up)
-    return createStringError(inconvertibleErrorCode(),
-                             "Can't stop tracing an individual thread when "
-                             "per-core process tracing is enabled.");
+  if (m_process_trace_up && m_process_trace_up->TracesThread(tid))
+    return m_process_trace_up->TraceStop(tid);
   return m_thread_traces.TraceStop(tid);
 }
 
 Error IntelPTCollector::TraceStop(const TraceStopRequest &request) {
   if (request.IsProcessTracing()) {
     Clear();
     return Error::success();
   } else {
     Error error = Error::success();
     for (int64_t tid : *request.tids)
       error = joinErrors(std::move(error),
                          TraceStop(static_cast<lldb::tid_t>(tid)));
     return error;
   }
 }
 
-Expected<IntelPTPerThreadProcessTraceUP>
-IntelPTPerThreadProcessTrace::Start(const TraceIntelPTStartRequest &request,
-                                    ArrayRef<lldb::tid_t> current_tids) {
-  IntelPTPerThreadProcessTraceUP trace(
-      new IntelPTPerThreadProcessTrace(request));
-
-  Error error = Error::success();
-  for (lldb::tid_t tid : current_tids)
-    error = joinErrors(std::move(error), trace->TraceStart(tid));
-  if (error)
-    return std::move(error);
-  return std::move(trace);
-}
-
 Error IntelPTCollector::TraceStart(const TraceIntelPTStartRequest &request) {
   if (request.IsProcessTracing()) {
-    if (IsProcessTracingEnabled()) {
+    if (m_process_trace_up) {
       return createStringError(
           inconvertibleErrorCode(),
           "Process currently traced. Stop process tracing first");
     }
     if (request.IsPerCoreTracing()) {
       if (m_thread_traces.GetTracedThreadsCount() > 0)
         return createStringError(
             inconvertibleErrorCode(),
             "Threads currently traced. Stop tracing them first.");
-      if (Expected<IntelPTMultiCoreTraceUP> trace =
-              IntelPTMultiCoreTrace::StartOnAllCores(request)) {
-        m_per_core_process_trace_up = std::move(*trace);
+      if (Expected<IntelPTProcessTraceUP> trace =
+              IntelPTMultiCoreTrace::StartOnAllCores(request, m_process)) {
+        m_process_trace_up = std::move(*trace);
         return Error::success();
       } else {
         return trace.takeError();
       }
     } else {
       std::vector<lldb::tid_t> process_threads;
       for (size_t i = 0; m_process.GetThreadAtIndex(i); i++)
         process_threads.push_back(m_process.GetThreadAtIndex(i)->GetID());
 
       // per-thread process tracing
-      if (Expected<IntelPTPerThreadProcessTraceUP> trace =
+      if (Expected<IntelPTProcessTraceUP> trace =
               IntelPTPerThreadProcessTrace::Start(request, process_threads)) {
-        m_per_thread_process_trace_up = std::move(trace.get());
+        m_process_trace_up = std::move(trace.get());
         return Error::success();
       } else {
         return trace.takeError();
       }
     }
   } else {
     // individual thread tracing
-    if (m_per_core_process_trace_up)
-      return createStringError(inconvertibleErrorCode(),
-                               "Process currently traced with per-core "
-                               "tracing. Stop process tracing first");
-
     Error error = Error::success();
-    for (int64_t tid : *request.tids)
+    for (int64_t tid : *request.tids) {
+      if (m_process_trace_up && m_process_trace_up->TracesThread(tid))
+        error = joinErrors(
+            std::move(error),
+            createStringError(inconvertibleErrorCode(),
+                              formatv("Thread with tid {0} is currently "
+                                      "traced. Stop tracing it first.",
+                                      tid)
+                                  .str()
+                                  .c_str()));
+      else
         error = joinErrors(std::move(error),
                            m_thread_traces.TraceStart(tid, request));
+    }
     return error;
   }
 }
 
 void IntelPTCollector::OnProcessStateChanged(lldb::StateType state) {
-  if (m_per_core_process_trace_up)
-    m_per_core_process_trace_up->OnProcessStateChanged(state);
+  if (m_process_trace_up)
+    m_process_trace_up->OnProcessStateChanged(state);
 }
 
 Error IntelPTCollector::OnThreadCreated(lldb::tid_t tid) {
-  if (m_per_thread_process_trace_up)
-    return m_per_thread_process_trace_up->TraceStart(tid);
+  if (m_process_trace_up)
+    return m_process_trace_up->TraceStart(tid);
 
   return Error::success();
 }
 
 Error IntelPTCollector::OnThreadDestroyed(lldb::tid_t tid) {
-  if (m_per_thread_process_trace_up &&
-      m_per_thread_process_trace_up->TracesThread(tid))
-    return m_per_thread_process_trace_up->TraceStop(tid);
+  if (m_process_trace_up && m_process_trace_up->TracesThread(tid))
+    return m_process_trace_up->TraceStop(tid);
   else if (m_thread_traces.TracesThread(tid))
     return m_thread_traces.TraceStop(tid);
   return Error::success();
 }
 
 Expected<json::Value> IntelPTCollector::GetState() {
   Expected<ArrayRef<uint8_t>> cpu_info = GetProcfsCpuInfo();
   if (!cpu_info)
     return cpu_info.takeError();
 
   TraceGetStateResponse state;
+  if (m_process_trace_up)
+    state = m_process_trace_up->GetState();
+
   state.process_binary_data.push_back(
       {IntelPTDataKinds::kProcFsCpuInfo, cpu_info->size()});
 
   m_thread_traces.ForEachThread(
       [&](lldb::tid_t tid, const IntelPTSingleBufferTrace &thread_trace) {
         state.traced_threads.push_back({tid,
                                         {{IntelPTDataKinds::kTraceBuffer,
                                           thread_trace.GetTraceBufferSize()}}});
       });
-
-  if (m_per_thread_process_trace_up) {
-    m_per_thread_process_trace_up->GetThreadTraces().ForEachThread(
-        [&](lldb::tid_t tid, const IntelPTSingleBufferTrace &thread_trace) {
-          state.traced_threads.push_back(
-              {tid,
-               {{IntelPTDataKinds::kTraceBuffer,
-                 thread_trace.GetTraceBufferSize()}}});
-        });
-  }
-
-  if (m_per_core_process_trace_up) {
-    for (size_t i = 0; m_process.GetThreadAtIndex(i); i++)
-      state.traced_threads.push_back(
-          TraceThreadState{m_process.GetThreadAtIndex(i)->GetID(), {}});
-
-    state.cores.emplace();
-    m_per_core_process_trace_up->ForEachCore(
-        [&](lldb::core_id_t core_id,
-            const IntelPTSingleBufferTrace &core_trace) {
-          state.cores->push_back({core_id,
-                                  {{IntelPTDataKinds::kTraceBuffer,
-                                    core_trace.GetTraceBufferSize()}}});
-        });
-  }
   return toJSON(state);
 }
 
-Expected<IntelPTSingleBufferTrace &>
-IntelPTCollector::GetTracedThread(lldb::tid_t tid) {
-  if (m_per_thread_process_trace_up &&
-      m_per_thread_process_trace_up->TracesThread(tid))
-    return m_per_thread_process_trace_up->GetThreadTraces().GetTracedThread(
-        tid);
-  return m_thread_traces.GetTracedThread(tid);
-}
-
 Expected<std::vector<uint8_t>>
 IntelPTCollector::GetBinaryData(const TraceGetBinaryDataRequest &request) {
   if (request.kind == IntelPTDataKinds::kTraceBuffer) {
+    if (!request.tid)
+      return createStringError(
+          inconvertibleErrorCode(),
+          "Getting a trace buffer without a tid is currently unsupported");
+
+    if (m_process_trace_up && m_process_trace_up->TracesThread(*request.tid))
+      return m_process_trace_up->GetBinaryData(request);
+
     if (Expected<IntelPTSingleBufferTrace &> trace =
-            GetTracedThread(*request.tid))
+            m_thread_traces.GetTracedThread(*request.tid))
       return trace->GetTraceBuffer(request.offset, request.size);
     else
       return trace.takeError();
   } else if (request.kind == IntelPTDataKinds::kProcFsCpuInfo) {
     return GetProcfsCpuInfo();
   }
   return createStringError(inconvertibleErrorCode(),
                            "Unsuported trace binary data kind: %s",
                            request.kind.c_str());
 }
 
-void IntelPTCollector::ClearProcessTracing() {
-  m_per_thread_process_trace_up.reset();
-  m_per_core_process_trace_up.reset();
-}
-
 bool IntelPTCollector::IsSupported() {
   if (Expected<uint32_t> intel_pt_type = GetIntelPTOSEventType()) {
     return true;
   } else {
     llvm::consumeError(intel_pt_type.takeError());
     return false;
   }
 }
 
-bool IntelPTCollector::IsProcessTracingEnabled() const {
-  return (bool)m_per_thread_process_trace_up ||
-         (bool)m_per_core_process_trace_up;
-}
-
 void IntelPTCollector::Clear() {
-  ClearProcessTracing();
+  m_process_trace_up.reset();
   m_thread_traces.Clear();
 }

lldb/source/Plugins/Process/Linux/IntelPTMultiCoreTrace.h

 //===-- IntelPTMultiCoreTrace.h ------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_IntelPTMultiCoreTrace_H_
 #define liblldb_IntelPTMultiCoreTrace_H_
 
+#include "IntelPTProcessTrace.h"
 #include "IntelPTSingleBufferTrace.h"
 
+#include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/Support/Error.h"
 
 #include <memory>
 
 namespace lldb_private {
 namespace process_linux {
 
-class IntelPTMultiCoreTrace;
-using IntelPTMultiCoreTraceUP = std::unique_ptr<IntelPTMultiCoreTrace>;
-
-class IntelPTMultiCoreTrace {
+class IntelPTMultiCoreTrace : public IntelPTProcessTrace {
 public:
   /// Start tracing all CPU cores.
   ///
   /// \param[in] request
   ///   Intel PT configuration parameters.
   ///
+  /// \param[in] process
+  ///   The process being debugged.
+  ///
   /// \return
   ///   An \a IntelPTMultiCoreTrace instance if tracing was successful, or
   ///   an \a llvm::Error otherwise.
-  static llvm::Expected<IntelPTMultiCoreTraceUP>
-  StartOnAllCores(const TraceIntelPTStartRequest &request);
+  static llvm::Expected<IntelPTProcessTraceUP>
+  StartOnAllCores(const TraceIntelPTStartRequest &request,
+                  NativeProcessProtocol &process);
 
   /// Execute the provided callback on each core that is being traced.
   ///
   /// \param[in] callback.core_id
   ///   The core id that is being traced.
   ///
   /// \param[in] callback.core_trace
   ///   The single-buffer trace instance for the given core.
   void ForEachCore(std::function<void(lldb::core_id_t core_id,
                                       IntelPTSingleBufferTrace &core_trace)>
                        callback);
 
-  /// This method should be invoked as early as possible whenever the process
-  /// resumes or stops so that intel-pt collection is not enabled when
-  /// the process is not running. This is done to prevent polluting the core
-  /// traces with executions of unrelated processes, which increases the data
-  /// loss of the target process, given that core traces don't filter by
-  /// process.
-  /// A possible way to avoid this is to use CR3 filtering, which is equivalent
-  /// to process filtering, but the perf_event API doesn't support it.
-  void OnProcessStateChanged(lldb::StateType state);
+  void OnProcessStateChanged(lldb::StateType state) override;
+
+  TraceGetStateResponse GetState() override;
+
+  bool TracesThread(lldb::tid_t tid) const override;
+
+  llvm::Error TraceStart(lldb::tid_t tid) override;
+
+  llvm::Error TraceStop(lldb::tid_t tid) override;
+
+  llvm::Expected<std::vector<uint8_t>>
+  GetBinaryData(const TraceGetBinaryDataRequest &request) override;
 
 private:
   IntelPTMultiCoreTrace(
       llvm::DenseMap<lldb::core_id_t, IntelPTSingleBufferTraceUP>
-          &&traces_per_core)
-      : m_traces_per_core(std::move(traces_per_core)) {}
+          &&traces_per_core,
+      NativeProcessProtocol &process)
+      : m_traces_per_core(std::move(traces_per_core)), m_process(process) {}
 
   llvm::DenseMap<lldb::core_id_t, IntelPTSingleBufferTraceUP> m_traces_per_core;
 
   /// The initial state is stopped because tracing can only start when the
   /// process is paused.
   lldb::StateType m_process_state = lldb::StateType::eStateStopped;
+
+  /// The target process.
+  NativeProcessProtocol &m_process;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // liblldb_IntelPTMultiCoreTrace_H_

lldb/source/Plugins/Process/Linux/IntelPTMultiCoreTrace.cpp

 static Error IncludePerfEventParanoidMessageInError(Error &&error) {
   return createStringError(
       inconvertibleErrorCode(),
       "%s\nYou might need to rerun as sudo or to set "
       "/proc/sys/kernel/perf_event_paranoid to a value of 0 or -1.",
       toString(std::move(error)).c_str());
 }
 
-Expected<IntelPTMultiCoreTraceUP> IntelPTMultiCoreTrace::StartOnAllCores(
-    const TraceIntelPTStartRequest &request) {
+Expected<IntelPTProcessTraceUP>
+IntelPTMultiCoreTrace::StartOnAllCores(const TraceIntelPTStartRequest &request,
+                                       NativeProcessProtocol &process) {
   Expected<ArrayRef<core_id_t>> core_ids = GetAvailableLogicalCoreIDs();
   if (!core_ids)
     return core_ids.takeError();
 
   if (IsTotalBufferLimitReached(*core_ids, request))
     return createStringError(
         inconvertibleErrorCode(),
         "The process can't be traced because the process trace size limit "
         "has been reached. Consider retracing with a higher limit.");
 
   llvm::DenseMap<core_id_t, IntelPTSingleBufferTraceUP> buffers;
   for (core_id_t core_id : *core_ids) {
     if (Expected<IntelPTSingleBufferTraceUP> core_trace =
             IntelPTSingleBufferTrace::Start(request, /*tid=*/None, core_id,
                                             TraceCollectionState::Paused))
       buffers.try_emplace(core_id, std::move(*core_trace));
     else
       return IncludePerfEventParanoidMessageInError(core_trace.takeError());
   }
 
-  return IntelPTMultiCoreTraceUP(new IntelPTMultiCoreTrace(std::move(buffers)));
+  return IntelPTProcessTraceUP(
+      new IntelPTMultiCoreTrace(std::move(buffers), process));
 }
 
 void IntelPTMultiCoreTrace::ForEachCore(
     std::function<void(core_id_t core_id, IntelPTSingleBufferTrace &core_trace)>
         callback) {
   for (auto &it : m_traces_per_core)
     callback(it.first, *it.second);
 }
ForEachCore([](core_id_t core_id, IntelPTSingleBufferTrace &core_trace) {
       }
     });
     break;
   }
   default:
     break;
   }
 }
+
+TraceGetStateResponse IntelPTMultiCoreTrace::GetState() {
+  TraceGetStateResponse state;
+
+  for (size_t i = 0; m_process.GetThreadAtIndex(i); i++)
+    state.traced_threads.push_back(
+        TraceThreadState{m_process.GetThreadAtIndex(i)->GetID(), {}});
+
+  state.cores.emplace();
+  ForEachCore([&](lldb::core_id_t core_id,
+                  const IntelPTSingleBufferTrace &core_trace) {
+    state.cores->push_back(
+        {core_id,
+         {{IntelPTDataKinds::kTraceBuffer, core_trace.GetTraceBufferSize()}}});
+  });
+
+  return state;
+}
+
+bool IntelPTMultiCoreTrace::TracesThread(lldb::tid_t tid) const {
+  // All the process' threads are being traced automatically.
+  return (bool)m_process.GetThreadByID(tid);
+}
+
+llvm::Error IntelPTMultiCoreTrace::TraceStart(lldb::tid_t tid) {
+  // This instance is already tracing all threads automatically.
+  return llvm::Error::success();
+}
+
+Error IntelPTMultiCoreTrace::TraceStop(lldb::tid_t tid) {
+  return createStringError(inconvertibleErrorCode(),
+                           "Can't stop tracing an individual thread when "
+                           "per-core process tracing is enabled.");
+}
+
+Expected<std::vector<uint8_t>>
+IntelPTMultiCoreTrace::GetBinaryData(const TraceGetBinaryDataRequest &request) {
+  return createStringError(inconvertibleErrorCode(), "Unimplemented");
+}

lldb/source/Plugins/Process/Linux/IntelPTPerThreadProcessTrace.h

 //===-- IntelPTPerThreadProcessTrace.h ------------------------ -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_IntelPTPerThreadProcessTrace_H_
 #define liblldb_IntelPTPerThreadProcessTrace_H_
 
+#include "IntelPTProcessTrace.h"
 #include "IntelPTSingleBufferTrace.h"
 #include "IntelPTThreadTraceCollection.h"
 
 namespace lldb_private {
 namespace process_linux {
 
-class IntelPTPerThreadProcessTrace;
-using IntelPTPerThreadProcessTraceUP =
-    std::unique_ptr<IntelPTPerThreadProcessTrace>;
-
 /// Manages a "process trace" instance by tracing each thread individually.
-class IntelPTPerThreadProcessTrace {
+class IntelPTPerThreadProcessTrace : public IntelPTProcessTrace {
 public:
   /// Start tracing the current process by tracing each of its tids
   /// individually.
   ///
   /// \param[in] request
   ///   Intel PT configuration parameters.
   ///
   /// \param[in] current_tids
   ///   List of tids currently alive. In the future, whenever a new thread is
   ///   spawned, they should be traced by calling the \a TraceStart(tid) method.
   ///
   /// \return
   ///   An \a IntelPTMultiCoreTrace instance if tracing was successful, or
   ///   an \a llvm::Error otherwise.
-  static llvm::Expected<IntelPTPerThreadProcessTraceUP>
+  static llvm::Expected<IntelPTProcessTraceUP>
   Start(const TraceIntelPTStartRequest &request,
         llvm::ArrayRef<lldb::tid_t> current_tids);
 
-  bool TracesThread(lldb::tid_t tid) const;
+  bool TracesThread(lldb::tid_t tid) const override;
+
+  llvm::Error TraceStart(lldb::tid_t tid) override;
 
-  IntelPTThreadTraceCollection &GetThreadTraces();
+  llvm::Error TraceStop(lldb::tid_t tid) override;
 
-  /// \copydoc IntelPTThreadTraceCollection::TraceStart()
-  llvm::Error TraceStart(lldb::tid_t tid);
+  TraceGetStateResponse GetState() override;
 
-  /// \copydoc IntelPTThreadTraceCollection::TraceStop()
-  llvm::Error TraceStop(lldb::tid_t tid);
+  llvm::Expected<std::vector<uint8_t>>
+  GetBinaryData(const TraceGetBinaryDataRequest &request) override;
 
 private:
   IntelPTPerThreadProcessTrace(const TraceIntelPTStartRequest &request)
       : m_tracing_params(request) {}
 
   IntelPTThreadTraceCollection m_thread_traces;
   /// Params used to trace threads when the user started "process tracing".
   TraceIntelPTStartRequest m_tracing_params;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // liblldb_IntelPTPerThreadProcessTrace_H_

lldb/source/Plugins/Process/Linux/IntelPTPerThreadProcessTrace.cpp

return createStringError(
         "Thread %" PRIu64 " can't be traced as the process trace size limit "
         "has been reached. Consider retracing with a higher "
         "limit.",
         tid);
 
   return m_thread_traces.TraceStart(tid, m_tracing_params);
 }
 
-IntelPTThreadTraceCollection &IntelPTPerThreadProcessTrace::GetThreadTraces() {
-  return m_thread_traces;
+TraceGetStateResponse IntelPTPerThreadProcessTrace::GetState() {
+  TraceGetStateResponse state;
+  m_thread_traces.ForEachThread(
+      [&](lldb::tid_t tid, const IntelPTSingleBufferTrace &thread_trace) {
+        state.traced_threads.push_back({tid,
+                                        {{IntelPTDataKinds::kTraceBuffer,
+                                          thread_trace.GetTraceBufferSize()}}});
+      });
+  return state;
+}
+
+Expected<std::vector<uint8_t>> IntelPTPerThreadProcessTrace::GetBinaryData(
+    const TraceGetBinaryDataRequest &request) {
+  if (Expected<IntelPTSingleBufferTrace &> trace =
+          m_thread_traces.GetTracedThread(*request.tid))
+    return trace->GetTraceBuffer(request.offset, request.size);
+  else
+    return trace.takeError();
+}
+
+Expected<IntelPTProcessTraceUP>
+IntelPTPerThreadProcessTrace::Start(const TraceIntelPTStartRequest &request,
+                                    ArrayRef<lldb::tid_t> current_tids) {
+  IntelPTProcessTraceUP trace(new IntelPTPerThreadProcessTrace(request));
+
+  Error error = Error::success();
+  for (lldb::tid_t tid : current_tids)
+    error = joinErrors(std::move(error), trace->TraceStart(tid));
+  if (error)
+    return std::move(error);
+  return trace;
 }

lldb/source/Plugins/Process/Linux/IntelPTProcessTrace.h

+//===-- IntelPTProcessTrace.h --------------------------------- -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_IntelPTProcessTrace_H_
+#define liblldb_IntelPTProcessTrace_H_
+
+#include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
+
+#include <memory>
+
+namespace lldb_private {
+namespace process_linux {
+
+// Abstract class to be inherited by all the process tracing strategies.
+class IntelPTProcessTrace {
+public:
+  virtual ~IntelPTProcessTrace() = default;
+
+  /// This method should be invoked as early as possible whenever the process
+  /// resumes or stops so that intel-pt collection is not enabled when
+  /// the process is not running. A case in which this is useful in when
+  /// tracing is done per-core. In this case we want to prevent polluting the
+  /// core traces with executions of unrelated processes, which increases the
+  /// data loss of the target process, given that core traces don't filter by
+  /// process.
+  /// A possible way to avoid this is to use CR3 filtering, which is equivalent
+  /// to process filtering, but the perf_event API doesn't support it.
+  ///
+  /// \param[in] state
+  ///     The new state of the target process.
+  virtual void OnProcessStateChanged(lldb::StateType state){};
+
+  /// Construct a minimal jLLDBTraceGetState response for this process trace.
+  virtual TraceGetStateResponse GetState() = 0;
+
+  virtual bool TracesThread(lldb::tid_t tid) const = 0;
+
+  /// \copydoc IntelPTThreadTraceCollection::TraceStart()
+  virtual llvm::Error TraceStart(lldb::tid_t tid) = 0;
+
+  /// \copydoc IntelPTThreadTraceCollection::TraceStop()
+  virtual llvm::Error TraceStop(lldb::tid_t tid) = 0;
+
+  /// Get binary data owned by this instance.
+  virtual llvm::Expected<std::vector<uint8_t>>
+  GetBinaryData(const TraceGetBinaryDataRequest &request) = 0;
+};
+
+using IntelPTProcessTraceUP = std::unique_ptr<IntelPTProcessTrace>;
+
+} // namespace process_linux
+} // namespace lldb_private
+
+#endif // liblldb_IntelPTProcessTrace_H_

lldb/test/API/commands/trace/multiple-threads/TestTraceStartStopMultipleThreads.py

def testStartPerCoreSession(self):
         self.traceStartProcess(perCoreTracing=True)
         # We can't support multiple per-core tracing sessions.
         self.traceStartProcess(error=True, perCoreTracing=True,
             substrs=["Process currently traced. Stop process tracing first"])
 
         # We can't support tracing per thread is per core is enabled.
         self.traceStartThread(
             error="True",
-            substrs=["Process currently traced with per-core tracing. Stop process tracing first"])
+            substrs=["Thread with tid ", "is currently traced"])
 
         # We can't stop individual thread when per core is enabled.
         self.traceStopThread(error="True",
             substrs=["Can't stop tracing an individual thread when per-core process tracing is enabled"])
 
         # The GetState packet should return trace buffers per core and at least one traced thread
         self.expect("""process plugin packet send 'jLLDBTraceGetState:{"type":"intel-pt"}]'""",
             substrs=['''[{"kind":"traceBuffer","size":4096}],"coreId":''', '"tid":'])
 
         self.traceStopProcess()