[trace][intelpt] Support system-wide tracing [12] - Support multi-core trace load and save

[wallace]

Summary

This diff is massive, but it's because it connects the client with lldb-server
and also ensures that the postmortem case works.

• Flatten the postmortem trace schema. The reason is that the schema has become quite complex due to the new multicore case, which defeats the original purpose of having a schema that could work for every trace plug-in. At this point, it's better that each trace plug-in defines it's own full schema. This means that the only common field is "type".
  • Because of this new approach, I merged the "common" trace load and saving functionalities into the IntelPT one. This simplified the code quite a bit. If we eventually implement another trace plug-in, we can see then what we could reuse.
  • The new schema, which is flattened, has now better comments and is parsed better. A change I did was to disallow hex addresses, because they are a bit error prone. I'm asking now to print the address in decimal.
  • Renamed "intel" to "GenuineIntel" in the schema because that's what you see in /proc/cpuinfo.
• Implemented reading the context switch trace data buffer. I had to do

some refactors to do that cleanly.

• • A major change that I did here was to simplify the perf_event circular buffer reading logic. It was too complex. Maybe the original Intel author had something different in mind.
• Implemented all the necessary bits to read trace.json files with per-core data.
• Implemented all the necessary bits to save to disk per-core trace session.
• Added a test that ensures that parsing and saving to disk works.

[wallace]

nit

[jj10306]

feedback-v1

lldb/include/lldb/Target/Trace.h

520

Would this work instead? I noticed that the several other maps around this code also use unordered_map and string, maybe we could update those too at some point.

538

same as comment above related to using LLVM types rather than std types wherever possible.

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

193–209

Expected<Optional<...>> feels weirddddd. Are both of these "layers" needed?
I noticed this in a couple places but I'm just leaving a single comment here.

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

191

Be careful with the "strong" language here. The AUX head only wraps around when the AUX buffer is mmaped with read-only, if it is mmapped with write perms, then the AUX head behaves like the data head (it doesn't auto wrap)

See this snipped of kernel code, the overwrite flag is set based on the mmap PROT and that overwrite flag is passed to the intelpt code.
https://github.com/torvalds/linux/blob/df0cc57e/kernel/events/ring_buffer.c#L670-L733

[jj10306]

feedback-v2

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

183

Do we need the offset/size? These arguments make the reading logic much more involved versus reading the whole buffer.
I understand that this is a more "general" method, but iiuc currently we only read the entire buffer. I guess in the future somebody could want the flexibility of providing an offset/size, but I don't see the need currently.
wdyt?
Same comment applies to the AUX buffer read method

206–212

What happens if an offset larger then the size of the buffer is provided? should that offset be wrapped or not?
What happens if a size larger than the size of the buffer is provided? should we only copy up to buffer size bytes or should we do multiple copies of the buffer to satisfy the request?

As I mentioned above, imo the ambiguity/complexity these arguments introduce is not worth the value add (which currently is none since we are always copying the whole buffer).

If we do stick with these args, we should make it very clear what happens in the cases I mentioned above and/or put restrictions on the ranges of these values (ie they must always be less than the buffer size)

lldb/source/Plugins/Trace/common/ThreadPostMortemTrace.h

47

why is this now optional?

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.h

169

176–177

do we need the threads explicitly or does traced_processes implicitly contain this info?

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTJSONStructs.cpp

53

if this is none, does this still create a key value pair?

88–90

nit: use what De Morgan taught us (;
Having to add a ! for each new addition to the predicate is very error prone and would be a pain to debug if you accidentally forgot to add the negation.

109–110

same comment as above related to De Morgan's law

131–133

same comment as above related to De Morgan's law

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTJSONStructs.h

32–42

If the intention here is for system wide tracing to not provide threads while single thread tracing does then should we change this like so?
(i know you're currently working on the thread detection so potentially this will be addressed then?)

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTSessionFileParser.cpp

31

take a reference to the underlying object directly?

33

what happens if system_path is invalid? or is it already guaranteed to exist at this point (ie did we already check this somewhere?)?

44–45

curious, what is the debugger able to provide when the uuid is provided versus when it isn't?

71

take a reference to the underlying object directly?

227

use make_shared instead?

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTSessionFileParser.h

55–57

docs?

64–69

docs?

90

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTSessionSaver.cpp

33–40

docs?

38

to better defend against if the size of data's element's changes?

65

is the string construction necessary?

93

nit: what's the difference between this and using the NormalizePath method you added? I know that method is private but could that potentially be made public or global so we can use that here?

131–132

same comment as above related to potentially using the ResolvePath method?

141

nit: we need to discuss this offline to ensure we are following the same structure as currently I have

cpus/
  <cpuId>/
    ipt.data
    context_switch.data

whereas this is a little different (ie using "cores" instead of "cpus" and not including the sub directory for each core id.

188

<directory> is the directory that the trace.json file will live at, correct?

[jj10306]

feeback-v3 - completed review

lldb/docs/use/intel_pt.rst

184–185

Consider adding a section on the perfTscConversion parameters while we're editing this file as I don't currently see that in this file. Also, it doesn't appear the "cores" section is here either

lldb/source/Target/Trace.cpp

30–32

do we need this struct or can we just use a string directly since the struct only has a single member?

134

135

why is this named thread_data, isn't this the size of the core's buffer?

325

lldb/unittests/Process/Linux/PerfTests.cpp

9

isn't this needed since readTsc() uses intel specific assembly instructions?

[wallace]

lldb/include/lldb/Target/Trace.h

520

great idea! I'll use ConstString instead of string. That will work. ConstString is like StringRef but uses a shared pool for storage.

538

+1

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

193–209

I think they are fine because in this case the collector is looking for who might own the data being fetched, and each object that implements TryGetBinaryData can return 3 possible outputs:

• None -> it doesn't have the data
• the sought value
• an error -> it should have the data but something went wrong

so this is fine.

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

183

After giving many thoughts to this, I agree with you. If we ever need to stream the data, we can implement it then, but it's not needed now.

191

+1

206–212

yep, i got rid of all of this

lldb/source/Plugins/Trace/common/ThreadPostMortemTrace.h

47

because now trace buffers are optional for threads. The trace buffer might be at the core level

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.h

169

+1

176–177

we don't really need, but it's useful because this way we don't need to cast ThreadSP to ThreadPostMortemTraceSP, which might break in some situations. So I'm making this constructor being harder to use to that it's only used by the bundle parser and not used by anyone else incorrectly

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTJSONStructs.cpp

53

yes, with null as value, but I'm changing it to

if (thread.trace_buffer)
  obj["traceBuffer"] = *thread.trace_buffer;

for simplicity of the output

88–90

i like this!

109–110

+1

131–133

+1

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTJSONStructs.h

32–42

as discussed offline, we'll keep the threads section because it will be useful for handling named threads

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTSessionFileParser.cpp

31

good idea

33

we are assuming it exists. But we actually really check it when we try to fetch its data.

44–45

if the UUID is provided and doesn't match the actual binary's UUID from the elf build section, then LLDB returns an error

71

+1

227

can't because the constructor is private and not visible to make_shared

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTSessionFileParser.h

55–57

+1

64–69

+1

90

+1

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTSessionSaver.cpp

33–40

+1

38

i made this simpler

if (!data.empty())
  out_fs.write(reinterpret_cast<const char *>(&data[0]), data.size());

65

i've changed it to

os << formatv("{0:2}", trace_session_json).str();.

we need to explicitly convert it to string somehow because std::ofstream doesn't understand formatv

93

i got rid of this, it was not needed

131–132

+1

141

as we discussed offline, the structure itself doesn't matter. LLDB can use a structure and dynolog a different one

188

yes

lldb/source/Target/Trace.cpp

30–32

the structure is useful using fromJSON, which gives nice error messages

134

+1

135

silly me

325

+1

lldb/unittests/Process/Linux/PerfTests.cpp

9

ahh good catch

[wallace]

This was improved in https://reviews.llvm.org/D127752

lldb/docs/lldb-gdb-remote.txt

 //    https://man7.org/linux/man-pages/man2/perf_event_open.2.html for more information about
 //    the calculation and the meaning of the values in the schema below.
 ///
 //    Schema for this field:
 //
 //    "tscPerfZeroConversion": {
 //      "timeMult": <decimal integer>,
 //      "timeShift": <decimal integer>,
-//      "timeSero": <decimal integer>,
+//      "timeZero": <decimal integer>,
 //    }
 //----------------------------------------------------------------------
 
 send packet: jLLDBTraceGetState:{"type":<type>}]
 read packet: {...object}/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
 // jLLDBTraceGetBinaryData

lldb/docs/use/intel_pt.rst

 and decode + symbolicate the trace using LLDB.
 For that, the command trace load is useful.
 In order to use trace load, you need to first create a JSON file with
 the definition of the trace session.
 For example
 
 ::
 
   {
-    "trace": {
-      "type": "intel-pt",
-      "pt_cpu": {
-        "vendor": "intel",
-        "family": 6,
-        "model": 79,
-        "stepping": 1
-      }
+    "cpuInfo": {
+      "vendor": "GenuineIntel",
     },
     "processes": [
       {
         "pid": 815455,
         "triple": "x86_64-*-linux",
         "threads": [
           {
             "tid": 815455,
-            "traceFile": "trace.file" # raw thread-specific trace from the AUX buffer
+            "traceBuffer": "trace.file" # raw thread-specific trace from the AUX buffer
           }
         ],
         "modules": [ # this are all the shared libraries + the main executable
           {
             "file": "a.out", # optional if it's the same as systemPath
             "systemPath": "a.out",
-            "loadAddress": "0x0000000000400000",
+            "loadAddress": 4194304,
           },
           {
             "file": "libfoo.so",
             "systemPath": "/usr/lib/libfoo.so",
             "loadAddress": "0x00007ffff7bd9000",
           },
           {
             "systemPath": "libbar.so",

 
 References
 ----------
 
 - Original RFC document_ for this feature.
 - Some details about how Meta is using Intel Processor Trace can be found in this blog_ post.
 
 .. _document: https://docs.google.com/document/d/1cOVTGp1sL_HBXjP9eB7qjVtDNr5xnuZvUUtv43G5eVI
-.. _blog: https://engineering.fb.com/2021/04/27/developer-tools/reverse-debugging/
+.. _blog: https://engineering.fb.com/2021/04/27/developer-tools/reverse-debugging/
 

lldb/include/lldb/Target/Trace.h

public:
 
   /// \return
   ///     The stop ID of the live process being traced, or an invalid stop ID
   ///     if the trace is in an error or invalid state.
   uint32_t GetStopID();
 
   using OnBinaryDataReadCallback =
       std::function<llvm::Error(llvm::ArrayRef<uint8_t> data)>;
+
   /// Fetch binary data associated with a thread, either live or postmortem, and
   /// pass it to the given callback. The reason of having a callback is to free
   /// the caller from having to manage the life cycle of the data and to hide
   /// the different data fetching procedures that exist for live and post mortem
   /// threads.
   ///
   /// The fetched data is not persisted after the callback is invoked.
   ///
public:
   ///     function.
   ///
   /// \return
   ///     An \a llvm::Error if the data couldn't be fetched, or the return value
   ///     of the callback, otherwise.
   llvm::Error OnThreadBinaryDataRead(lldb::tid_t tid, llvm::StringRef kind,
                                      OnBinaryDataReadCallback callback);
 
-  /// Get the current traced live process.
+  /// Fetch binary data associated with a core, either live or postmortem, and
+  /// pass it to the given callback. The reason of having a callback is to free
+  /// the caller from having to manage the life cycle of the data and to hide
+  /// the different data fetching procedures that exist for live and post mortem
+  /// cores.
+  ///
+  /// The fetched data is not persisted after the callback is invoked.
+  ///
+  /// \param[in] core_id
+  ///     The core who owns the data.
+  ///
+  /// \param[in] kind
+  ///     The kind of data to read.
+  ///
+  /// \param[in] callback
+  ///     The callback to be invoked once the data was successfully read. Its
+  ///     return value, which is an \a llvm::Error, is returned by this
+  ///     function.
   ///
   /// \return
-  ///     The current traced live process. If it's not a live process,
-  ///     return \a nullptr.
-  Process *GetLiveProcess();
+  ///     An \a llvm::Error if the data couldn't be fetched, or the return value
+  ///     of the callback, otherwise.
+  llvm::Error OnCoreBinaryDataRead(lldb::core_id_t core_id,
+                                   llvm::StringRef kind,
+                                   OnBinaryDataReadCallback callback);
+
+  /// \return
+  ///     All the currently traced processes.
+  std::vector<Process *> GetAllProcesses();
+
+  /// \return
+  ///     The list of cores being traced. Might be empty depending on the
+  ///     plugin.
+  llvm::ArrayRef<lldb::core_id_t> GetTracedCores();
 
 protected:
+  /// Get the currently traced live process.
+  ///
+  /// \return
+  ///     If it's not a live process, return \a nullptr.
+  Process *GetLiveProcess();
+
+  /// Get the currently traced postmortem processes.
+  ///
+  /// \return
+  ///     If it's not a live process session, return an empty list.
+  llvm::ArrayRef<Process *> GetPostMortemProcesses();
+
   /// Implementation of \a OnThreadBinaryDataRead() for live threads.
   llvm::Error OnLiveThreadBinaryDataRead(lldb::tid_t tid, llvm::StringRef kind,
                                          OnBinaryDataReadCallback callback);
 
+  /// Implementation of \a OnLiveBinaryDataRead() for live cores.
+  llvm::Error OnLiveCoreBinaryDataRead(lldb::core_id_t core,
+                                       llvm::StringRef kind,
+                                       OnBinaryDataReadCallback callback);
+
   /// Implementation of \a OnThreadBinaryDataRead() for post mortem threads.
   llvm::Error
   OnPostMortemThreadBinaryDataRead(lldb::tid_t tid, llvm::StringRef kind,
                                    OnBinaryDataReadCallback callback);
 
+  /// Implementation of \a OnCoreBinaryDataRead() for post mortem cores.
+  llvm::Error OnPostMortemCoreBinaryDataRead(lldb::core_id_t core_id,
+                                             llvm::StringRef kind,
+                                             OnBinaryDataReadCallback callback);
+
+  /// Helper method for reading a data file and passing its data to the given
+  /// callback.
+  llvm::Error OnDataFileRead(FileSpec file, OnBinaryDataReadCallback callback);
+
   /// Get the file path containing data of a postmortem thread given a data
   /// identifier.
   ///
   /// \param[in] tid
   ///     The thread whose data is requested.
   ///
   /// \param[in] kind
   ///     The kind of data requested.
   ///
   /// \return
   ///     The file spec containing the requested data, or an \a llvm::Error in
   ///     case of failures.
   llvm::Expected<FileSpec> GetPostMortemThreadDataFile(lldb::tid_t tid,
                                                        llvm::StringRef kind);
 
+  /// Get the file path containing data of a postmortem core given a data
+  /// identifier.
+  ///
+  /// \param[in] core_id
+  ///     The core whose data is requested.
+  ///
+  /// \param[in] kind
+  ///     The kind of data requested.
+  ///
+  /// \return
+  ///     The file spec containing the requested data, or an \a llvm::Error in
+  ///     case of failures.
+  llvm::Expected<FileSpec> GetPostMortemCoreDataFile(lldb::core_id_t core_id,
+                                                     llvm::StringRef kind);
+
   /// Associate a given thread with a data file using a data identifier.
   ///
   /// \param[in] tid
   ///     The thread associated with the data file.
   ///
   /// \param[in] kind
   ///     The kind of data being registered.
   ///
   /// \param[in] file_spec
   ///     The path of the data file.
   void SetPostMortemThreadDataFile(lldb::tid_t tid, llvm::StringRef kind,
                                    FileSpec file_spec);
 
+  /// Associate a given core with a data file using a data identifier.
+  ///
+  /// \param[in] core_id
+  ///     The core associated with the data file.
+  ///
+  /// \param[in] kind
+  ///     The kind of data being registered.
+  ///
+  /// \param[in] file_spec
+  ///     The path of the data file.
+  void SetPostMortemCoreDataFile(lldb::core_id_t core_id, llvm::StringRef kind,
+                                 FileSpec file_spec);
+
   /// Get binary data of a live thread given a data identifier.
   ///
   /// \param[in] tid
   ///     The thread whose data is requested.
   ///
   /// \param[in] kind
   ///     The kind of data requested.
   ///
   /// \return
   ///     A vector of bytes with the requested data, or an \a llvm::Error in
   ///     case of failures.
   llvm::Expected<std::vector<uint8_t>>
   GetLiveThreadBinaryData(lldb::tid_t tid, llvm::StringRef kind);
 
+  /// Get binary data of a live core given a data identifier.
+  ///
+  /// \param[in] core_id
+  ///     The core whose data is requested.
+  ///
+  /// \param[in] kind
+  ///     The kind of data requested.
+  ///
+  /// \return
+  ///     A vector of bytes with the requested data, or an \a llvm::Error in
+  ///     case of failures.
+  llvm::Expected<std::vector<uint8_t>>
+  GetLiveCoreBinaryData(lldb::core_id_t core_id, llvm::StringRef kind);
+
   /// Get binary data of the current process given a data identifier.
   ///
   /// \param[in] kind
   ///     The kind of data requested.
   ///
   /// \return
   ///     A vector of bytes with the requested data, or an \a llvm::Error in
   ///     case of failures.
   llvm::Expected<std::vector<uint8_t>>
   GetLiveProcessBinaryData(llvm::StringRef kind);
 
   /// Get the size of the data returned by \a GetLiveThreadBinaryData
   llvm::Optional<size_t> GetLiveThreadBinaryDataSize(lldb::tid_t tid,
                                                      llvm::StringRef kind);
 
+  /// Get the size of the data returned by \a GetLiveCoreBinaryData
+  llvm::Optional<size_t> GetLiveCoreBinaryDataSize(lldb::core_id_t core_id,
+                                                   llvm::StringRef kind);
+
   /// Get the size of the data returned by \a GetLiveProcessBinaryData
   llvm::Optional<size_t> GetLiveProcessBinaryDataSize(llvm::StringRef kind);
+
   /// Constructor for post mortem processes
-  Trace() = default;
+  Trace(llvm::ArrayRef<lldb::ProcessSP> postmortem_processes,
+        llvm::Optional<std::vector<lldb::core_id_t>> postmortem_cores);
 
   /// Constructor for a live process
   Trace(Process &live_process) : m_live_process(&live_process) {}
 
   /// Start tracing a live process or its threads.
   ///
   /// \param[in] request
   ///     JSON object with the information necessary to start tracing. In the
protected:
   ///   An error message if this operation failed, or \b nullptr otherwise.
   const char *RefreshLiveProcessState();
 
 private:
   uint32_t m_stop_id = LLDB_INVALID_STOP_ID;
   /// Process traced by this object if doing live tracing. Otherwise it's null.
   Process *m_live_process = nullptr;
 
+  /// Portmortem processes traced by this object if doing non-live tracing.
+  /// Otherwise it's empty.
+  std::vector<Process *> m_postmortem_processes;
+
   /// These data kinds are returned by lldb-server when fetching the state of
   /// the tracing session. The size in bytes can be used later for fetching the
   /// data in batches.
   /// \{
 
   /// tid -> data kind -> size
   llvm::DenseMap<lldb::tid_t, std::unordered_map<std::string, size_t>>
       m_live_thread_data;
 
+  /// core id -> data kind -> size
+  llvm::DenseMap<lldb::core_id_t, std::unordered_map<std::string, size_t>>
+      m_live_core_data;
   /// data kind -> size
   std::unordered_map<std::string, size_t> m_live_process_data;
   /// \}
 
+  /// The list of cores being traced. Might be \b None depending on the plug-in.
+  llvm::Optional<std::vector<lldb::core_id_t>> m_cores;
+
   /// Postmortem traces can specific additional data files, which are
   /// represented in this variable using a data kind identifier for each file.
+  /// \{
+
   /// tid -> data kind -> file
   llvm::DenseMap<lldb::tid_t, std::unordered_map<std::string, FileSpec>>
       m_postmortem_thread_data;
 
+  /// core id -> data kind -> file
+  llvm::DenseMap<lldb::core_id_t, std::unordered_map<std::string, FileSpec>>
+      m_postmortem_core_data;
+
+  /// \}
+
   llvm::Optional<std::string> m_live_refresh_error;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_TRACE_H

lldb/include/lldb/Utility/TraceGDBRemotePackets.h

bool fromJSON(const llvm::json::Value &value, TraceCoreState &packet,
               llvm::json::Path path);
 
 llvm::json::Value toJSON(const TraceCoreState &packet);
 
 struct TraceGetStateResponse {
   std::vector<TraceThreadState> traced_threads;
   std::vector<TraceBinaryData> process_binary_data;
   llvm::Optional<std::vector<TraceCoreState>> cores;
-  std::vector<std::string> warnings;
+  llvm::Optional<std::vector<std::string>> warnings;
+
+  void AddWarning(llvm::StringRef warning);
 };
 
 bool fromJSON(const llvm::json::Value &value, TraceGetStateResponse &packet,
               llvm::json::Path path);
 
 llvm::json::Value toJSON(const TraceGetStateResponse &packet);
 /// \}
 
 /// jLLDBTraceGetBinaryData gdb-remote packet
 /// \{
 struct TraceGetBinaryDataRequest {
   /// Tracing technology name, e.g. intel-pt, arm-coresight.
   std::string type;
   /// Identifier for the data.
   std::string kind;
   /// Optional tid if the data is related to a thread.
   llvm::Optional<lldb::tid_t> tid;
+  /// Optional core id if the data is related to a cpu core.
+  llvm::Optional<lldb::tid_t> core_id;
   /// Offset in bytes from where to start reading the data.
   uint64_t offset;
   /// Number of bytes to read.
   uint64_t size;
 };
 
 bool fromJSON(const llvm::json::Value &value,
               lldb_private::TraceGetBinaryDataRequest &packet,
               llvm::json::Path path);
 
 llvm::json::Value toJSON(const lldb_private::TraceGetBinaryDataRequest &packet);
 /// \}
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_TRACEGDBREMOTEPACKETS_H

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

m_thread_traces.ForEachThread(
                                         {{IntelPTDataKinds::kTraceBuffer,
                                           thread_trace.GetTraceBufferSize()}}});
       });
 
   if (Expected<LinuxPerfZeroTscConversion &> tsc_conversion =
           FetchPerfTscConversionParameters())
     state.tsc_perf_zero_conversion = *tsc_conversion;
   else
-    state.warnings.push_back(toString(tsc_conversion.takeError()));
+    state.AddWarning(toString(tsc_conversion.takeError()));
   return toJSON(state);
 }
 
 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 (request.kind == IntelPTDataKinds::kProcFsCpuInfo)
+    return GetProcfsCpuInfo();
 
-    if (m_process_trace_up && m_process_trace_up->TracesThread(*request.tid))
-      return m_process_trace_up->GetBinaryData(request);
+  if (m_process_trace_up) {
+    Expected<Optional<std::vector<uint8_t>>> data =
+        m_process_trace_up->TryGetBinaryData(request);
+    if (!data)
+      return data.takeError();
+    if (*data)
+      return **data;
+  }
 
-    if (Expected<IntelPTSingleBufferTrace &> trace =
-            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();
+  {
+    Expected<Optional<std::vector<uint8_t>>> data =
+        m_thread_traces.TryGetBinaryData(request);
+    if (!data)
+      return data.takeError();
+    if (*data)
+      return **data;
   }
-  return createStringError(inconvertibleErrorCode(),
-                           "Unsuported trace binary data kind: %s",
-                           request.kind.c_str());
+
+  return createStringError(
+      inconvertibleErrorCode(),
+      formatv("Can't fetch data kind {0} for core_id {1}, tid {2} and "
+              "\"process tracing\" mode {3}",
+              request.kind, request.core_id, request.tid,
+              m_process_trace_up ? "enabled" : "not enabled"));
 }
 
 bool IntelPTCollector::IsSupported() {
   if (Expected<uint32_t> intel_pt_type = GetIntelPTOSEventType()) {
     return true;
   } else {
     llvm::consumeError(intel_pt_type.takeError());
     return false;
   }
 }
 
 void IntelPTCollector::Clear() {
   m_process_trace_up.reset();
   m_thread_traces.Clear();
 }

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

public:
   TraceIntelPTGetStateResponse 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;
+  llvm::Expected<llvm::Optional<std::vector<uint8_t>>>
+  TryGetBinaryData(const TraceGetBinaryDataRequest &request) override;
 
 private:
   /// This assumes that all underlying perf_events for each core are part of the
   /// same perf event group.
   IntelPTMultiCoreTrace(
       llvm::DenseMap<lldb::core_id_t,
                      std::pair<IntelPTSingleBufferTrace, ContextSwitchTrace>>
           &&traces_per_core,

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

#else
   uint64_t data_buffer_numpages = data_buffer_size / getpagesize();
 
   LLDB_LOG(log, "Will create context switch trace buffer of size {0}",
            data_buffer_size);
 
   if (Expected<PerfEvent> perf_event = PerfEvent::Init(
           attr, /*pid=*/None, core_id,
           intelpt_core_trace.GetPerfEvent().GetFd(), /*flags=*/0)) {
-    if (Error mmap_err =
-            perf_event->MmapMetadataAndBuffers(data_buffer_numpages, 0)) {
+    if (Error mmap_err = perf_event->MmapMetadataAndBuffers(
+            data_buffer_numpages, 0, /*data_buffer_write=*/false)) {
       return std::move(mmap_err);
     }
     return perf_event;
   } else {
     return perf_event.takeError();
   }
 #endif
 }

 }
 
 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");
+Expected<Optional<std::vector<uint8_t>>>
+IntelPTMultiCoreTrace::TryGetBinaryData(
+    const TraceGetBinaryDataRequest &request) {
+  if (!request.core_id)
+    return None;
+  auto it = m_traces_per_core.find(*request.core_id);
+  if (it == m_traces_per_core.end())
+    return createStringError(
+        inconvertibleErrorCode(),
+        formatv("Core {0} is not being traced", *request.core_id));
+
+  if (request.kind == IntelPTDataKinds::kTraceBuffer)
+    return it->second.first.GetTraceBuffer(request.offset, request.size);
+  if (request.kind == IntelPTDataKinds::kPerfContextSwitchTrace)
+    return it->second.second.ReadFlushedOutDataCyclicBuffer(request.offset,
+                                                            request.size);
+  return None;
 }

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

public:
   bool TracesThread(lldb::tid_t tid) const override;
 
   llvm::Error TraceStart(lldb::tid_t tid) override;
 
   llvm::Error TraceStop(lldb::tid_t tid) override;
 
   TraceIntelPTGetStateResponse GetState() override;
 
-  llvm::Expected<std::vector<uint8_t>>
-  GetBinaryData(const TraceGetBinaryDataRequest &request) override;
+  llvm::Expected<llvm::Optional<std::vector<uint8_t>>>
+  TryGetBinaryData(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

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(
+Expected<llvm::Optional<std::vector<uint8_t>>>
+IntelPTPerThreadProcessTrace::TryGetBinaryData(
     const TraceGetBinaryDataRequest &request) {
-  if (Expected<IntelPTSingleBufferTrace &> trace =
-          m_thread_traces.GetTracedThread(*request.tid))
-    return trace->GetTraceBuffer(request.offset, request.size);
-  else
-    return trace.takeError();
+  return m_thread_traces.TryGetBinaryData(request);
 }
 
 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

public:
   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;
+  /// \return
+  ///   \b None if this instance doesn't support the requested data, an \a
+  ///   llvm::Error if this isntance supports it but fails at fetching it, and
+  ///   \b Error::success() otherwise.
+  virtual llvm::Expected<llvm::Optional<std::vector<uint8_t>>>
+  TryGetBinaryData(const TraceGetBinaryDataRequest &request) = 0;
 };
 
 using IntelPTProcessTraceUP = std::unique_ptr<IntelPTProcessTrace>;
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // liblldb_IntelPTProcessTrace_H_

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

if (!attr)
     return attr.takeError();
   attr->disabled = disabled;
 
   LLDB_LOG(log, "Will create trace buffer of size {0}",
            request.trace_buffer_size);
 
   if (Expected<PerfEvent> perf_event = PerfEvent::Init(*attr, tid, core_id)) {
     if (Error mmap_err = perf_event->MmapMetadataAndBuffers(
-            /*num_data_pages=*/0, aux_buffer_numpages)) {
+            /*num_data_pages=*/0, aux_buffer_numpages,
+            /*data_buffer_write=*/true)) {
       return std::move(mmap_err);
     }
     return IntelPTSingleBufferTrace(std::move(*perf_event));
   } else {
     return perf_event.takeError();
   }
 #endif
 }
 
 const PerfEvent &IntelPTSingleBufferTrace::GetPerfEvent() const {
   return m_perf_event;
 }

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

public:
   ///
   /// \return
   ///   An error if the given thread is not being traced or tracing couldn't be
   ///   stopped.
   llvm::Error TraceStop(lldb::tid_t tid);
 
   size_t GetTracedThreadsCount() const;
 
+  /// \copydoc IntelPTProcessTrace::TryGetBinaryData()
+  llvm::Expected<llvm::Optional<std::vector<uint8_t>>>
+  TryGetBinaryData(const TraceGetBinaryDataRequest &request);
+
 private:
   llvm::DenseMap<lldb::tid_t, IntelPTSingleBufferTrace> m_thread_traces;
   /// Total actual thread buffer size in bytes
   size_t m_total_buffer_size = 0;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // liblldb_IntelPTPerThreadTraceCollection_H_

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

 void IntelPTThreadTraceCollection::Clear() {
   m_thread_traces.clear();
   m_total_buffer_size = 0;
 }
 
 size_t IntelPTThreadTraceCollection::GetTracedThreadsCount() const {
   return m_thread_traces.size();
 }
+
+llvm::Expected<llvm::Optional<std::vector<uint8_t>>>
+IntelPTThreadTraceCollection::TryGetBinaryData(
+    const TraceGetBinaryDataRequest &request) {
+  if (!request.tid)
+    return None;
+  if (request.kind != IntelPTDataKinds::kTraceBuffer)
+    return None;
+
+  if (!TracesThread(*request.tid))
+    return None;
+
+  if (Expected<IntelPTSingleBufferTrace &> trace =
+          GetTracedThread(*request.tid))
+    return trace->GetTraceBuffer(request.offset, request.size);
+  else
+    return trace.takeError();
+}

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

 };
 
 using FileDescriptorUP =
     std::unique_ptr<long, resource_handle::FileDescriptorDeleter>;
 using MmapUP = std::unique_ptr<void, resource_handle::MmapDeleter>;
 
 } // namespace resource_handle
 
-/// Read data from a cyclic buffer
-///
-/// \param[in] [out] buf
-///     Destination buffer, the buffer will be truncated to written size.
-///
-/// \param[in] src
-///     Source buffer which must be a cyclic buffer.
-///
-/// \param[in] src_cyc_index
-///     The index pointer (start of the valid data in the cyclic
-///     buffer).
-///
-/// \param[in] offset
-///     The offset to begin reading the data in the cyclic buffer.
-void ReadCyclicBuffer(llvm::MutableArrayRef<uint8_t> &dst,
-                      llvm::ArrayRef<uint8_t> src, size_t src_cyc_index,
-                      size_t offset);
-
 /// Thin wrapper of the perf_event_open API.
 ///
 /// Exposes the metadata page and data and aux buffers of a perf event.
 /// Handles the management of the event's file descriptor and mmap'ed
 /// regions.
 class PerfEvent {
   enum class CollectionState {
     Enabled,
public:
   ///     A value of 0 is useful for "dummy" events that only want to access
   ///     the metadata, \a perf_event_mmap_page, or the aux buffer.
   ///
   /// \param[in] num_aux_pages
   ///     Number of pages in the aux buffer to mmap, must be a power of 2.
   ///     A value of 0 effectively is a no-op and no data is mmap'ed for this
   ///     buffer.
   ///
+  /// \param[in] data_buffer_write
+  ///     Whether to mmap the data buffer with WRITE permissions. This changes
+  ///     the behavior of how the kernel writes to the data buffer.
+  ///
   /// \return
   ///   \a llvm::Error::success if the mmap operations succeeded,
   ///   or an \a llvm::Error otherwise.
   llvm::Error MmapMetadataAndBuffers(size_t num_data_pages,
-                                     size_t num_aux_pages);
+                                     size_t num_aux_pages,
+                                     bool data_buffer_write);
 
   /// Get the file descriptor associated with the perf event.
   long GetFd() const;
 
   /// Get the metadata page from the data section's mmap buffer.
   ///
   /// The metadata page is always mmap'ed, even when \a num_data_pages is 0.
   ///
public:
   ///
   /// \return
   ///     A vector with the requested binary data. The vector will have the
   ///     size of the requested \a size. Non-available positions will be
   ///     filled with zeroes.
   llvm::Expected<std::vector<uint8_t>>
   ReadFlushedOutAuxCyclicBuffer(size_t offset, size_t size);
 
+  /// Read the data buffer managed by this perf event. To ensure that the
+  /// data is up-to-date and is not corrupted by read-write race conditions, the
+  /// underlying perf_event is paused during read, and later it's returned to
+  /// its initial state. The returned data will be linear, i.e. it will fix the
+  /// circular wrapping the might exist int he buffer.
+  ///
+  /// \param[in] offset
+  ///     Offset of the data to read.
+  ///
+  /// \param[in] size
+  ///     Number of bytes to read.
+  ///
+  /// \return
+  ///     A vector with the requested binary data. The vector will have the
+  ///     size of the requested \a size. Non-available positions will be
+  ///     filled with zeroes.
+  llvm::Expected<std::vector<uint8_t>>
+  ReadFlushedOutDataCyclicBuffer(size_t offset, size_t size);
+
   /// Use the ioctl API to disable the perf event and all the events in its
   /// group. This doesn't terminate the perf event.
   ///
   /// This is no-op if the perf event is already disabled.
   ///
   /// \return
   ///   An Error if the perf event couldn't be disabled.
   llvm::Error DisableWithIoctl();
llvm::Expected<resource_handle::MmapUP> DoMmap(void *addr, size_t length,
                                                  llvm::StringRef buffer_name);
 
   /// Mmap the data buffer of the perf event.
   ///
   /// \param[in] num_data_pages
   ///     Number of pages in the data buffer to mmap, must be a power of 2.
   ///     A value of 0 is useful for "dummy" events that only want to access
   ///     the metadata, \a perf_event_mmap_page, or the aux buffer.
-  llvm::Error MmapMetadataAndDataBuffer(size_t num_data_pages);
+  ///
+  /// \param[in] data_buffer_write
+  ///     Whether to mmap the data buffer with WRITE permissions. This changes
+  ///     the behavior of how the kernel writes to the data buffer.
+  llvm::Error MmapMetadataAndDataBuffer(size_t num_data_pages,
+                                        bool data_buffer_write);
 
   /// Mmap the aux buffer of the perf event.
   ///
   /// \param[in] num_aux_pages
   ///   Number of pages in the aux buffer to mmap, must be a power of 2.
   ///   A value of 0 effectively is a no-op and no data is mmap'ed for this
   ///   buffer.
   llvm::Error MmapAuxBuffer(size_t num_aux_pages);

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

 #include <sys/mman.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 
 using namespace lldb_private;
 using namespace process_linux;
 using namespace llvm;
 
-void lldb_private::process_linux::ReadCyclicBuffer(
-    llvm::MutableArrayRef<uint8_t> &dst, llvm::ArrayRef<uint8_t> src,
-    size_t src_cyc_index, size_t offset) {
-
-  Log *log = GetLog(POSIXLog::Trace);
-
-  if (dst.empty() || src.empty()) {
-    dst = dst.drop_back(dst.size());
-    return;
-  }
-
-  if (dst.data() == nullptr || src.data() == nullptr) {
-    dst = dst.drop_back(dst.size());
-    return;
-  }
-
-  if (src_cyc_index > src.size()) {
-    dst = dst.drop_back(dst.size());
-    return;
-  }
-
-  if (offset >= src.size()) {
-    LLDB_LOG(log, "Too Big offset ");
-    dst = dst.drop_back(dst.size());
-    return;
-  }
-
-  llvm::SmallVector<ArrayRef<uint8_t>, 2> parts = {
-      src.slice(src_cyc_index), src.take_front(src_cyc_index)};
-
-  if (offset > parts[0].size()) {
-    parts[1] = parts[1].slice(offset - parts[0].size());
-    parts[0] = parts[0].drop_back(parts[0].size());
-  } else if (offset == parts[0].size()) {
-    parts[0] = parts[0].drop_back(parts[0].size());
-  } else {
-    parts[0] = parts[0].slice(offset);
-  }
-  auto next = dst.begin();
-  auto bytes_left = dst.size();
-  for (auto part : parts) {
-    size_t chunk_size = std::min(part.size(), bytes_left);
-    next = std::copy_n(part.begin(), chunk_size, next);
-    bytes_left -= chunk_size;
-  }
-  dst = dst.drop_back(bytes_left);
-}
-
 Expected<LinuxPerfZeroTscConversion>
 lldb_private::process_linux::LoadPerfTscConversionParameters() {
   lldb::pid_t pid = getpid();
   perf_event_attr attr;
   memset(&attr, 0, sizeof(attr));
   attr.size = sizeof(attr);
   attr.type = PERF_TYPE_SOFTWARE;
   attr.config = PERF_COUNT_SW_DUMMY;
 
   Expected<PerfEvent> perf_event = PerfEvent::Init(attr, pid);
   if (!perf_event)
     return perf_event.takeError();
-  if (Error mmap_err = perf_event->MmapMetadataAndBuffers(/*num_data_pages*/ 0,
-                                                          /*num_aux_pages*/ 0))
+  if (Error mmap_err =
+          perf_event->MmapMetadataAndBuffers(/*num_data_pages=*/0,
+                                             /*num_aux_pages=*/0,
+                                             /*data_buffer_write=*/false))
     return std::move(mmap_err);
 
   perf_event_mmap_page &mmap_metada = perf_event->GetMetadataPage();
   if (mmap_metada.cap_user_time && mmap_metada.cap_user_time_zero) {
     return LinuxPerfZeroTscConversion{
         mmap_metada.time_mult, mmap_metada.time_shift, mmap_metada.time_zero};
   } else {
     auto err_cap =
if (mmap_result == MAP_FAILED) {
     std::string err_msg =
         llvm::formatv("perf event mmap allocation failed for {0}: {1}",
                       buffer_name, std::strerror(errno));
     return createStringError(inconvertibleErrorCode(), err_msg);
   }
   return resource_handle::MmapUP(mmap_result, length);
 }
 
-llvm::Error PerfEvent::MmapMetadataAndDataBuffer(size_t num_data_pages) {
+llvm::Error PerfEvent::MmapMetadataAndDataBuffer(size_t num_data_pages,
+                                                 bool data_buffer_write) {
   size_t mmap_size = (num_data_pages + 1) * getpagesize();
-  if (Expected<resource_handle::MmapUP> mmap_metadata_data =
-          DoMmap(nullptr, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, 0,
-                 "metadata and data buffer")) {
+  if (Expected<resource_handle::MmapUP> mmap_metadata_data = DoMmap(
+          nullptr, mmap_size, PROT_READ | (data_buffer_write ? PROT_WRITE : 0),
+          MAP_SHARED, 0, "metadata and data buffer")) {
     m_metadata_data_base = std::move(mmap_metadata_data.get());
     return Error::success();
   } else
     return mmap_metadata_data.takeError();
 }
 
 llvm::Error PerfEvent::MmapAuxBuffer(size_t num_aux_pages) {
   if (num_aux_pages == 0)
     return Error::success();
 
   perf_event_mmap_page &metadata_page = GetMetadataPage();
+
   metadata_page.aux_offset =
       metadata_page.data_offset + metadata_page.data_size;
   metadata_page.aux_size = num_aux_pages * getpagesize();
 
   if (Expected<resource_handle::MmapUP> mmap_aux =
           DoMmap(nullptr, metadata_page.aux_size, PROT_READ, MAP_SHARED,
                  metadata_page.aux_offset, "aux buffer")) {
     m_aux_base = std::move(mmap_aux.get());
     return Error::success();
   } else
     return mmap_aux.takeError();
 }
 
 llvm::Error PerfEvent::MmapMetadataAndBuffers(size_t num_data_pages,
-                                              size_t num_aux_pages) {
+                                              size_t num_aux_pages,
+                                              bool data_buffer_write) {
   if (num_data_pages != 0 && !isPowerOf2_64(num_data_pages))
     return llvm::createStringError(
         llvm::inconvertibleErrorCode(),
         llvm::formatv("Number of data pages must be a power of 2, got: {0}",
                       num_data_pages));
   if (num_aux_pages != 0 && !isPowerOf2_64(num_aux_pages))
     return llvm::createStringError(
         llvm::inconvertibleErrorCode(),
         llvm::formatv("Number of aux pages must be a power of 2, got: {0}",
                       num_aux_pages));
-  if (Error err = MmapMetadataAndDataBuffer(num_data_pages))
+  if (Error err = MmapMetadataAndDataBuffer(num_data_pages, data_buffer_write))
     return err;
   if (Error err = MmapAuxBuffer(num_aux_pages))
     return err;
   return Error::success();
 }
 
 long PerfEvent::GetFd() const { return *(m_fd.get()); }
 

 
 ArrayRef<uint8_t> PerfEvent::GetAuxBuffer() const {
   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
   return {reinterpret_cast<uint8_t *>(m_aux_base.get()),
            static_cast<size_t>(mmap_metadata.aux_size)};
 }
 
 Expected<std::vector<uint8_t>>
+PerfEvent::ReadFlushedOutDataCyclicBuffer(size_t offset, size_t size) {
+  CollectionState previous_state = m_collection_state;
+  if (Error err = DisableWithIoctl())
+    return std::move(err);
+
+  /**
+   * The data buffer and aux buffer have different implementations
+   * with respect to their definition of head pointer. In the case
+   * of Aux data buffer the head always wraps around the aux buffer
+   * and we don't need to care about it, whereas the data_head keeps
+   * increasing and needs to be wrapped by modulus operator
+   */
+  perf_event_mmap_page &mmap_metadata = GetMetadataPage();
+
+  ArrayRef<uint8_t> data = GetDataBuffer();
+  uint64_t data_head = mmap_metadata.data_head;
+  uint64_t data_size = mmap_metadata.data_size;
+  std::vector<uint8_t> output;
+  output.reserve(size);
+
+  if (data_head > data_size) {
+    uint64_t actual_data_head = data_head % data_size;
+    // The buffer has wrapped
+    for (uint64_t i = actual_data_head + offset;
+         i < data_size && output.size() < size; i++)
+      output.push_back(data[i]);
+
+    // We need to find the starting position for the left part if the offset was
+    // too big
+    uint64_t left_part_start = actual_data_head + offset >= data_size
+                                   ? actual_data_head + offset - data_size
+                                   : 0;
+    for (uint64_t i = left_part_start;
+         i < actual_data_head && output.size() < size; i++)
+      output.push_back(data[i]);
+  } else {
+    for (uint64_t i = offset; i < data_head && output.size() < size; i++)
+      output.push_back(data[i]);
+  }
+
+  if (previous_state == CollectionState::Enabled) {
+    if (Error err = EnableWithIoctl())
+      return std::move(err);
+  }
+
+  if (output.size() != size)
+    return createStringError(inconvertibleErrorCode(),
+                             formatv("Requested {0} bytes of perf_event data "
+                                     "buffer but only {1} are available",
+                                     size, output.size()));
+
+  return data;
+}
+
+Expected<std::vector<uint8_t>>
 PerfEvent::ReadFlushedOutAuxCyclicBuffer(size_t offset, size_t size) {
   CollectionState previous_state = m_collection_state;
   if (Error err = DisableWithIoctl())
     return std::move(err);
 
-  std::vector<uint8_t> data(size, 0);
   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
-  Log *log = GetLog(POSIXLog::Trace);
-  uint64_t head = mmap_metadata.aux_head;
 
-  LLDB_LOG(log, "Aux size -{0} , Head - {1}", mmap_metadata.aux_size, head);
+  ArrayRef<uint8_t> data = GetAuxBuffer();
+  uint64_t aux_head = mmap_metadata.aux_head;
+  uint64_t aux_size = mmap_metadata.aux_size;
+  std::vector<uint8_t> output;
+  output.reserve(size);
 
   /**
    * When configured as ring buffer, the aux buffer keeps wrapping around
    * the buffer and its not possible to detect how many times the buffer
    * wrapped. Initially the buffer is filled with zeros,as shown below
    * so in order to get complete buffer we first copy firstpartsize, followed
    * by any left over part from beginning to aux_head
    *
    * aux_offset [d,d,d,d,d,d,d,d,0,0,0,0,0,0,0,0,0,0,0] aux_size
    *                 aux_head->||<- firstpartsize  ->|
    *
    * */
 
-  MutableArrayRef<uint8_t> buffer(data);
-  ReadCyclicBuffer(buffer, GetAuxBuffer(), static_cast<size_t>(head), offset);
+  for (uint64_t i = aux_head + offset; i < aux_size && output.size() < size;
+       i++)
+    output.push_back(data[i]);
+
+  // We need to find the starting position for the left part if the offset was
+  // too big
+  uint64_t left_part_start =
+      aux_head + offset >= aux_size ? aux_head + offset - aux_size : 0;
+  for (uint64_t i = left_part_start; i < aux_head && output.size() < size; i++)
+    output.push_back(data[i]);
 
   if (previous_state == CollectionState::Enabled) {
     if (Error err = EnableWithIoctl())
       return std::move(err);
   }
 
+  if (output.size() != size)
+    return createStringError(inconvertibleErrorCode(),
+                             formatv("Requested {0} bytes of perf_event aux "
+                                     "buffer but only {1} are available",
+                                     size, output.size()));
+
   return data;
 }
 
 Error PerfEvent::DisableWithIoctl() {
   if (m_collection_state == CollectionState::Disabled)
     return Error::success();
 
   if (ioctl(*m_fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) < 0)
return createStringError(inconvertibleErrorCode(),
                              std::strerror(errno));
 
   m_collection_state = CollectionState::Enabled;
   return Error::success();
 }
 
 size_t PerfEvent::GetEffectiveDataBufferSize() const {
   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
-  if (mmap_metadata.data_head < mmap_metadata.data_size)
+  if (mmap_metadata.data_head <= mmap_metadata.data_size)
     return mmap_metadata.data_head;
   else
     return mmap_metadata.data_size; // The buffer has wrapped.
 }

lldb/source/Plugins/Trace/common/CMakeLists.txt

 add_lldb_library(lldbPluginTraceCommon
   ThreadPostMortemTrace.cpp
-  TraceJSONStructs.cpp
-  TraceSessionFileParser.cpp
-  TraceSessionSaver.cpp
 
   LINK_LIBS
     lldbCore
     lldbTarget
   )

lldb/source/Plugins/Trace/common/ThreadPostMortemTrace.h

public:
   ///
   /// \param[in] tid
   ///     The tid of this thread.
   ///
   /// \param[in] trace_file
   ///     The file that contains the list of instructions that were traced when
   ///     this thread was being executed.
   ThreadPostMortemTrace(Process &process, lldb::tid_t tid,
-                        const FileSpec &trace_file)
+                        const llvm::Optional<FileSpec> &trace_file)
       : Thread(process, tid), m_trace_file(trace_file) {}
 
   void RefreshStateAfterStop() override;
 
   lldb::RegisterContextSP GetRegisterContext() override;
 
   lldb::RegisterContextSP
   CreateRegisterContextForFrame(StackFrame *frame) override;
 
   /// \return
   ///   The trace file of this thread.
-  const FileSpec &GetTraceFile() const;
+  const llvm::Optional<FileSpec> &GetTraceFile() const;
 
 protected:
   bool CalculateStopInfo() override;
 
   lldb::RegisterContextSP m_thread_reg_ctx_sp;
 
 private:
-  FileSpec m_trace_file;
+  llvm::Optional<FileSpec> m_trace_file;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPOSTMORTEMTRACE_H

lldb/source/Plugins/Trace/common/ThreadPostMortemTrace.cpp

 #include <memory>
 
 #include "Plugins/Process/Utility/RegisterContextHistory.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 void ThreadPostMortemTrace::RefreshStateAfterStop() {}
 
 RegisterContextSP ThreadPostMortemTrace::GetRegisterContext() {
   if (!m_reg_context_sp)
     m_reg_context_sp = CreateRegisterContextForFrame(nullptr);
 
   return m_reg_context_sp;
 }
 
 RegisterContextSP
 ThreadPostMortemTrace::CreateRegisterContextForFrame(StackFrame *frame) {
   // Eventually this will calculate the register context based on the current
   // trace position.
   return std::make_shared<RegisterContextHistory>(
       *this, 0, GetProcess()->GetAddressByteSize(), LLDB_INVALID_ADDRESS);
 }
 
 bool ThreadPostMortemTrace::CalculateStopInfo() { return false; }
 
-const FileSpec &ThreadPostMortemTrace::GetTraceFile() const {
+const Optional<FileSpec> &ThreadPostMortemTrace::GetTraceFile() const {
   return m_trace_file;
 }

lldb/source/Plugins/Trace/common/TraceJSONStructs.h

-//===-- TraceJSONStruct.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 LLDB_TARGET_TRACEJSONSTRUCTS_H
-#define LLDB_TARGET_TRACEJSONSTRUCTS_H
-
-#include "lldb/lldb-types.h"
-#include "llvm/Support/JSON.h"
-
-namespace lldb_private {
-
-struct JSONAddress {
-  lldb::addr_t value;
-};
-
-struct JSONModule {
-  std::string system_path;
-  llvm::Optional<std::string> file;
-  JSONAddress load_address;
-  llvm::Optional<std::string> uuid;
-};
-
-struct JSONThread {
-  int64_t tid;
-  std::string trace_file;
-};
-
-struct JSONProcess {
-  int64_t pid;
-  std::string triple;
-  std::vector<JSONThread> threads;
-  std::vector<JSONModule> modules;
-};
-
-struct JSONTracePluginSettings {
-  std::string type;
-};
-
-struct JSONTraceSessionBase {
-  std::vector<JSONProcess> processes;
-};
-
-/// The trace plug-in implementation should provide its own TPluginSettings,
-/// which corresponds to the "trace" section of the schema.
-template <class TPluginSettings>
-struct JSONTraceSession : JSONTraceSessionBase {
-  TPluginSettings trace;
-};
-
-} // namespace lldb_private
-
-namespace llvm {
-namespace json {
-
-llvm::json::Value toJSON(const lldb_private::JSONModule &module);
-
-llvm::json::Value toJSON(const lldb_private::JSONThread &thread);
-
-llvm::json::Value toJSON(const lldb_private::JSONProcess &process);
-
-llvm::json::Value
-toJSON(const lldb_private::JSONTraceSessionBase &session_base);
-
-bool fromJSON(const Value &value, lldb_private::JSONAddress &address,
-              Path path);
-
-bool fromJSON(const Value &value, lldb_private::JSONModule &module, Path path);
-
-bool fromJSON(const Value &value, lldb_private::JSONThread &thread, Path path);
-
-bool fromJSON(const Value &value, lldb_private::JSONProcess &process,
-              Path path);
-
-bool fromJSON(const Value &value,
-              lldb_private::JSONTracePluginSettings &plugin_settings,
-              Path path);
-
-bool fromJSON(const Value &value, lldb_private::JSONTraceSessionBase &session,
-              Path path);
-
-template <class TPluginSettings>
-bool fromJSON(const Value &value,
-              lldb_private::JSONTraceSession<TPluginSettings> &session,
-              Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("trace", session.trace) &&
-         fromJSON(value, (lldb_private::JSONTraceSessionBase &)session, path);
-}
-
-} // namespace json
-} // namespace llvm
-
-#endif // LLDB_TARGET_TRACEJSONSTRUCTS_H

lldb/source/Plugins/Trace/common/TraceJSONStructs.cpp

-//===-- TraceSessionFileStructs.cpp ---------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===/
-
-#include "TraceJSONStructs.h"
-#include "ThreadPostMortemTrace.h"
-#include "lldb/Core/Debugger.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/Target.h"
-#include <sstream>
-
-using namespace lldb_private;
-namespace llvm {
-namespace json {
-
-llvm::json::Value toJSON(const JSONModule &module) {
-  llvm::json::Object json_module;
-  json_module["systemPath"] = module.system_path;
-  if (module.file)
-    json_module["file"] = *module.file;
-  std::ostringstream oss;
-  oss << "0x" << std::hex << module.load_address.value;
-  json_module["loadAddress"] = oss.str();
-  if (module.uuid)
-    json_module["uuid"] = *module.uuid;
-  return std::move(json_module);
-}
-
-llvm::json::Value toJSON(const JSONThread &thread) {
-  return Value(Object{{"tid", thread.tid}, {"traceFile", thread.trace_file}});
-}
-
-llvm::json::Value toJSON(const JSONProcess &process) {
-  llvm::json::Object json_process;
-  json_process["pid"] = process.pid;
-  json_process["triple"] = process.triple;
-
-  llvm::json::Array threads_arr;
-  for (JSONThread e : process.threads)
-    threads_arr.push_back(toJSON(e));
-
-  json_process["threads"] = llvm::json::Value(std::move(threads_arr));
-
-  llvm::json::Array modules_arr;
-  for (JSONModule e : process.modules)
-    modules_arr.push_back(toJSON(e));
-
-  json_process["modules"] = llvm::json::Value(std::move(modules_arr));
-
-  return std::move(json_process);
-}
-
-llvm::json::Value toJSON(const JSONTraceSessionBase &session) {
-  llvm::json::Array arr;
-  for (JSONProcess e : session.processes)
-    arr.push_back(toJSON(e));
-
-  return std::move(arr);
-}
-
-bool fromJSON(const Value &value, JSONAddress &address, Path path) {
-  Optional<StringRef> s = value.getAsString();
-  if (s.hasValue() && !s->getAsInteger(0, address.value))
-    return true;
-
-  path.report("expected numeric string");
-  return false;
-}
-
-bool fromJSON(const Value &value, JSONModule &module, Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("systemPath", module.system_path) &&
-         o.map("file", module.file) &&
-         o.map("loadAddress", module.load_address) &&
-         o.map("uuid", module.uuid);
-}
-
-bool fromJSON(const Value &value, JSONThread &thread, Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("tid", thread.tid) && o.map("traceFile", thread.trace_file);
-}
-
-bool fromJSON(const Value &value, JSONProcess &process, Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("pid", process.pid) && o.map("triple", process.triple) &&
-         o.map("threads", process.threads) && o.map("modules", process.modules);
-}
-
-bool fromJSON(const Value &value, JSONTracePluginSettings &plugin_settings,
-              Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("type", plugin_settings.type);
-}
-
-bool fromJSON(const Value &value, JSONTraceSessionBase &session, Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("processes", session.processes);
-}
-
-} // namespace json
-} // namespace llvm

lldb/source/Plugins/Trace/common/TraceSessionFileParser.h

-//===-- TraceSessionFileParser.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 LLDB_TARGET_TRACESESSIONPARSER_H
-#define LLDB_TARGET_TRACESESSIONPARSER_H
-
-#include "ThreadPostMortemTrace.h"
-#include "TraceJSONStructs.h"
-
-namespace lldb_private {
-
-/// \class TraceSessionFileParser TraceSessionFileParser.h
-///
-/// Base class for parsing the common information of JSON trace session files.
-/// Contains the basic C++ structs that represent the JSON data, which include
-/// \a JSONTraceSession as the root object.
-///
-/// See \a Trace::FindPlugin for more information regarding these JSON files.
-class TraceSessionFileParser {
-public:
-
-  /// Helper struct holding the objects created when parsing a process
-  struct ParsedProcess {
-    lldb::TargetSP target_sp;
-    std::vector<lldb::ThreadPostMortemTraceSP> threads;
-  };
-
-  TraceSessionFileParser(Debugger &debugger, llvm::StringRef session_file_dir,
-                         llvm::StringRef schema)
-      : m_debugger(debugger), m_session_file_dir(session_file_dir),
-        m_schema(schema) {}
-
-  /// Build the full schema for a Trace plug-in.
-  ///
-  /// \param[in] plugin_schema
-  ///   The subschema that corresponds to the "trace" section of the schema.
-  ///
-  /// \return
-  ///   The full schema containing the common attributes and the plug-in
-  ///   specific attributes.
-  static std::string BuildSchema(llvm::StringRef plugin_schema);
-
-  /// Parse the fields common to all trace session schemas.
-  ///
-  /// \param[in] session
-  ///     The session json objects already deserialized.
-  ///
-  /// \return
-  ///     A list of \a ParsedProcess containing all threads and targets created
-  ///     during the parsing, or an error in case of failures. In case of
-  ///     errors, no side effects are produced.
-  llvm::Expected<std::vector<ParsedProcess>>
-  ParseCommonSessionFile(const JSONTraceSessionBase &session);
-
-protected:
-  /// Resolve non-absolute paths relative to the session file folder. It
-  /// modifies the given file_spec.
-  void NormalizePath(lldb_private::FileSpec &file_spec);
-
-  lldb::ThreadPostMortemTraceSP ParseThread(lldb::ProcessSP &process_sp,
-                                            const JSONThread &thread);
-
-  llvm::Expected<ParsedProcess> ParseProcess(const JSONProcess &process);
-
-  llvm::Error ParseModule(lldb::TargetSP &target_sp, const JSONModule &module);
-
-  /// Create a user-friendly error message upon a JSON-parsing failure using the
-  /// \a json::ObjectMapper functionality.
-  ///
-  /// \param[in] root
-  ///   The \a llvm::json::Path::Root used to parse the JSON \a value.
-  ///
-  /// \param[in] value
-  ///   The json value that failed to parse.
-  ///
-  /// \return
-  ///   An \a llvm::Error containing the user-friendly error message.
-  llvm::Error CreateJSONError(llvm::json::Path::Root &root,
-                              const llvm::json::Value &value);
-
-  Debugger &m_debugger;
-  std::string m_session_file_dir;
-  llvm::StringRef m_schema;
-};
-} // namespace lldb_private
-
-
-#endif // LLDB_TARGET_TRACESESSIONPARSER_H

lldb/source/Plugins/Trace/common/TraceSessionFileParser.cpp

-//===-- TraceSessionFileParser.cpp ---------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===/
-
-#include "TraceSessionFileParser.h"
-#include "ThreadPostMortemTrace.h"
-
-#include <sstream>
-
-#include "lldb/Core/Debugger.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/Target.h"
-
-using namespace lldb;
-using namespace lldb_private;
-using namespace llvm;
-
-void TraceSessionFileParser::NormalizePath(lldb_private::FileSpec &file_spec) {
-  if (file_spec.IsRelative())
-    file_spec.PrependPathComponent(m_session_file_dir);
-}
-
-Error TraceSessionFileParser::ParseModule(lldb::TargetSP &target_sp,
-                                          const JSONModule &module) {
-  FileSpec system_file_spec(module.system_path);
-  NormalizePath(system_file_spec);
-
-  FileSpec local_file_spec(module.file.hasValue() ? *module.file
-                                                  : module.system_path);
-  NormalizePath(local_file_spec);
-
-  ModuleSpec module_spec;
-  module_spec.GetFileSpec() = local_file_spec;
-  module_spec.GetPlatformFileSpec() = system_file_spec;
-
-  if (module.uuid.hasValue())
-    module_spec.GetUUID().SetFromStringRef(*module.uuid);
-
-  Status error;
-  ModuleSP module_sp =
-      target_sp->GetOrCreateModule(module_spec, /*notify*/ false, &error);
-
-  if (error.Fail())
-    return error.ToError();
-
-  bool load_addr_changed = false;
-  module_sp->SetLoadAddress(*target_sp, module.load_address.value, false,
-                            load_addr_changed);
-  return llvm::Error::success();
-}
-
-Error TraceSessionFileParser::CreateJSONError(json::Path::Root &root,
-                                              const json::Value &value) {
-  std::string err;
-  raw_string_ostream os(err);
-  root.printErrorContext(value, os);
-  return createStringError(
-      std::errc::invalid_argument, "%s\n\nContext:\n%s\n\nSchema:\n%s",
-      toString(root.getError()).c_str(), os.str().c_str(), m_schema.data());
-}
-
-std::string TraceSessionFileParser::BuildSchema(StringRef plugin_schema) {
-  std::ostringstream schema_builder;
-  schema_builder << "{\n  \"trace\": ";
-  schema_builder << plugin_schema.data() << ",";
-  schema_builder << R"(
-  "processes": [
-    {
-      "pid": integer,
-      "triple": string, // llvm-triple
-      "threads": [
-        {
-          "tid": integer,
-          "traceFile": string
-        }
-      ],
-      "modules": [
-        {
-          "systemPath": string, // original path of the module at runtime
-          "file"?: string, // copy of the file if not available at "systemPath"
-          "loadAddress": string, // string address in hex or decimal form
-          "uuid"?: string,
-        }
-      ]
-    }
-  ]
-  // Notes:
-  // All paths are either absolute or relative to the session file.
-}
-)";
-  return schema_builder.str();
-}
-
-ThreadPostMortemTraceSP
-TraceSessionFileParser::ParseThread(ProcessSP &process_sp,
-                                    const JSONThread &thread) {
-  lldb::tid_t tid = static_cast<lldb::tid_t>(thread.tid);
-
-  FileSpec trace_file(thread.trace_file);
-  NormalizePath(trace_file);
-
-  ThreadPostMortemTraceSP thread_sp =
-      std::make_shared<ThreadPostMortemTrace>(*process_sp, tid, trace_file);
-  process_sp->GetThreadList().AddThread(thread_sp);
-  return thread_sp;
-}
-
-Expected<TraceSessionFileParser::ParsedProcess>
-TraceSessionFileParser::ParseProcess(const JSONProcess &process) {
-  TargetSP target_sp;
-  Status error = m_debugger.GetTargetList().CreateTarget(
-      m_debugger, /*user_exe_path*/ StringRef(), process.triple,
-      eLoadDependentsNo,
-      /*platform_options*/ nullptr, target_sp);
-
-  if (!target_sp)
-    return error.ToError();
-
-  ParsedProcess parsed_process;
-  parsed_process.target_sp = target_sp;
-
-  ProcessSP process_sp = target_sp->CreateProcess(
-      /*listener*/ nullptr, "trace",
-      /*crash_file*/ nullptr,
-      /*can_connect*/ false);
-
-  process_sp->SetID(static_cast<lldb::pid_t>(process.pid));
-
-  for (const JSONThread &thread : process.threads)
-    parsed_process.threads.push_back(ParseThread(process_sp, thread));
-
-  for (const JSONModule &module : process.modules)
-    if (Error err = ParseModule(target_sp, module))
-      return std::move(err);
-
-  if (!process.threads.empty())
-    process_sp->GetThreadList().SetSelectedThreadByIndexID(0);
-
-  // We invoke DidAttach to create a correct stopped state for the process and
-  // its threads.
-  ArchSpec process_arch;
-  process_sp->DidAttach(process_arch);
-
-  return parsed_process;
-}
-
-Expected<std::vector<TraceSessionFileParser::ParsedProcess>>
-TraceSessionFileParser::ParseCommonSessionFile(
-    const JSONTraceSessionBase &session) {
-  std::vector<ParsedProcess> parsed_processes;
-
-  auto onError = [&]() {
-    // Delete all targets that were created so far in case of failures
-    for (ParsedProcess &parsed_process : parsed_processes)
-      m_debugger.GetTargetList().DeleteTarget(parsed_process.target_sp);
-  };
-
-  for (const JSONProcess &process : session.processes) {
-    if (Expected<ParsedProcess> parsed_process = ParseProcess(process))
-      parsed_processes.push_back(std::move(*parsed_process));
-    else {
-      onError();
-      return parsed_process.takeError();
-    }
-  }
-  return parsed_processes;
-}

lldb/source/Plugins/Trace/common/TraceSessionSaver.h

-//===-- SessionSaver.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 LLDB_TARGET_TRACESESSIONSAVER_H
-#define LLDB_TARGET_TRACESESSIONSAVER_H
-
-#include "TraceJSONStructs.h"
-
-namespace lldb_private {
-
-class TraceSessionSaver {
-
-public:
-  /// Save the trace session description JSON object inside the given directory
-  /// as a file named \a trace.json.
-  ///
-  /// \param[in] trace_session_description
-  ///     The trace's session, as JSON Object.
-  ///
-  /// \param[in] directory
-  ///     The directory where the JSON file will be saved.
-  ///
-  /// \return
-  ///     \a llvm::success if the operation was successful, or an \a llvm::Error
-  ///     otherwise.
-  static llvm::Error
-  WriteSessionToFile(const llvm::json::Value &trace_session_description,
-                     FileSpec directory);
-
-  /// Build the processes section of the trace session description file. Besides
-  /// returning the processes information, this method saves to disk all modules
-  /// and raw traces corresponding to the traced threads of the given process.
-  ///
-  /// \param[in] live_process
-  ///     The process being traced.
-  ///
-  /// \param[in] raw_thread_trace_data_kind
-  ///     Identifier for the data kind of the raw trace for each thread.
-  ///
-  /// \param[in] directory
-  ///     The directory where files will be saved when building the processes
-  ///     section.
-  ///
-  /// \return
-  ///     The processes section or \a llvm::Error in case of failures.
-  static llvm::Expected<JSONTraceSessionBase>
-  BuildProcessesSection(Process &live_process,
-                        llvm::StringRef raw_thread_trace_data_kind,
-                        FileSpec directory);
-
-  /// Build the threads sub-section of the trace session description file.
-  /// For each traced thread, its raw trace is also written to the file
-  /// \a thread_id_.trace inside of the given directory.
-  ///
-  /// \param[in] live_process
-  ///     The process being traced.
-  ///
-  /// \param[in] raw_thread_trace_data_kind
-  ///     Identifier for the data kind of the raw trace for each thread.
-  ///
-  /// \param[in] directory
-  ///     The directory where files will be saved when building the threads
-  ///     section.
-  ///
-  /// \return
-  ///     The threads section or \a llvm::Error in case of failures.
-  static llvm::Expected<std::vector<JSONThread>>
-  BuildThreadsSection(Process &live_process,
-                      llvm::StringRef raw_thread_trace_data_kind,
-                      FileSpec directory);
-
-  /// Build modules sub-section of the trace's session. The original modules
-  /// will be copied over to the \a <directory/modules> folder. Invalid modules
-  /// are skipped.
-  /// Copying the modules has the benefit of making these trace session
-  /// directories self-contained, as the raw traces and modules are part of the
-  /// output directory and can be sent to another machine, where lldb can load
-  /// them and replicate exactly the same trace session.
-  ///
-  /// \param[in] live_process
-  ///     The process being traced.
-  ///
-  /// \param[in] directory
-  ///     The directory where the modules files will be saved when building
-  ///     the modules section.
-  ///     Example: If a module \a libbar.so exists in the path
-  ///     \a /usr/lib/foo/libbar.so, then it will be copied to
-  ///     \a <directory>/modules/usr/lib/foo/libbar.so.
-  ///
-  /// \return
-  ///     The modules section or \a llvm::Error in case of failures.
-  static llvm::Expected<std::vector<JSONModule>>
-  BuildModulesSection(Process &live_process, FileSpec directory);
-};
-} // namespace lldb_private
-
-#endif // LLDB_TARGET_TRACESESSIONSAVER_H

lldb/source/Plugins/Trace/common/TraceSessionSaver.cpp

-//===-- TraceSessionSaver.cpp ---------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "TraceSessionSaver.h"
-
-#include "lldb/Core/Module.h"
-#include "lldb/Core/Value.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/SectionLoadList.h"
-#include "lldb/Target/Target.h"
-#include "lldb/lldb-types.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/JSON.h"
-
-#include <fstream>
-
-using namespace lldb;
-using namespace lldb_private;
-using namespace llvm;
-
-llvm::Error TraceSessionSaver::WriteSessionToFile(
-    const llvm::json::Value &trace_session_description, FileSpec directory) {
-
-  FileSpec trace_path = directory;
-  trace_path.AppendPathComponent("trace.json");
-  std::ofstream os(trace_path.GetPath());
-  os << std::string(formatv("{0:2}", trace_session_description));
-  os.close();
-  if (!os)
-    return createStringError(inconvertibleErrorCode(),
-                             formatv("couldn't write to the file {0}",
-                                     trace_path.GetPath().c_str()));
-  return Error::success();
-}
-
-llvm::Expected<JSONTraceSessionBase> TraceSessionSaver::BuildProcessesSection(
-    Process &live_process, llvm::StringRef raw_thread_trace_data_kind,
-    FileSpec directory) {
-
-  JSONTraceSessionBase json_session_description;
-  Expected<std::vector<JSONThread>> json_threads =
-      BuildThreadsSection(live_process, raw_thread_trace_data_kind, directory);
-  if (!json_threads)
-    return json_threads.takeError();
-
-  Expected<std::vector<JSONModule>> json_modules =
-      BuildModulesSection(live_process, directory);
-  if (!json_modules)
-    return json_modules.takeError();
-
-  json_session_description.processes.push_back(JSONProcess{
-      static_cast<int64_t>(live_process.GetID()),
-      live_process.GetTarget().GetArchitecture().GetTriple().getTriple(),
-      json_threads.get(), json_modules.get()});
-  return json_session_description;
-}
-
-llvm::Expected<std::vector<JSONThread>> TraceSessionSaver::BuildThreadsSection(
-    Process &live_process, llvm::StringRef raw_thread_trace_data_kind,
-    FileSpec directory) {
-  std::vector<JSONThread> json_threads;
-  for (ThreadSP thread_sp : live_process.Threads()) {
-    TraceSP trace_sp = live_process.GetTarget().GetTrace();
-    lldb::tid_t tid = thread_sp->GetID();
-    if (!trace_sp->IsTraced(tid))
-      continue;
-
-    // resolve the directory just in case
-    FileSystem::Instance().Resolve(directory);
-    FileSpec raw_trace_path = directory;
-    raw_trace_path.AppendPathComponent(std::to_string(tid) + ".trace");
-    json_threads.push_back(JSONThread{static_cast<int64_t>(tid),
-                                      raw_trace_path.GetPath().c_str()});
-
-    llvm::Error err =
-        live_process.GetTarget().GetTrace()->OnThreadBinaryDataRead(
-            tid, raw_thread_trace_data_kind,
-            [&](llvm::ArrayRef<uint8_t> data) -> llvm::Error {
-              std::basic_fstream<char> raw_trace_fs =
-                  std::fstream(raw_trace_path.GetPath().c_str(),
-                               std::ios::out | std::ios::binary);
-              raw_trace_fs.write(reinterpret_cast<const char *>(&data[0]),
-                                 data.size() * sizeof(uint8_t));
-              raw_trace_fs.close();
-              if (!raw_trace_fs)
-                return createStringError(
-                    inconvertibleErrorCode(),
-                    formatv("couldn't write to the file {0}",
-                            raw_trace_path.GetPath().c_str()));
-              return Error::success();
-            });
-    if (err)
-      return std::move(err);
-  }
-  return json_threads;
-}
-
-llvm::Expected<std::vector<JSONModule>>
-TraceSessionSaver::BuildModulesSection(Process &live_process,
-                                       FileSpec directory) {
-  std::vector<JSONModule> json_modules;
-  ModuleList module_list = live_process.GetTarget().GetImages();
-  for (size_t i = 0; i < module_list.GetSize(); ++i) {
-    ModuleSP module_sp(module_list.GetModuleAtIndex(i));
-    if (!module_sp)
-      continue;
-    std::string system_path = module_sp->GetPlatformFileSpec().GetPath();
-    // TODO: support memory-only libraries like [vdso]
-    if (!module_sp->GetFileSpec().IsAbsolute())
-      continue;
-
-    std::string file = module_sp->GetFileSpec().GetPath();
-    ObjectFile *objfile = module_sp->GetObjectFile();
-    if (objfile == nullptr)
-      continue;
-
-    lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
-    Address base_addr(objfile->GetBaseAddress());
-    if (base_addr.IsValid() &&
-        !live_process.GetTarget().GetSectionLoadList().IsEmpty())
-      load_addr = base_addr.GetLoadAddress(&live_process.GetTarget());
-
-    if (load_addr == LLDB_INVALID_ADDRESS)
-      continue;
-
-    FileSystem::Instance().Resolve(directory);
-    FileSpec path_to_copy_module = directory;
-    path_to_copy_module.AppendPathComponent("modules");
-    path_to_copy_module.AppendPathComponent(system_path);
-    sys::fs::create_directories(path_to_copy_module.GetDirectory().AsCString());
-
-    if (std::error_code ec = llvm::sys::fs::copy_file(
-            system_path, path_to_copy_module.GetPath()))
-      return createStringError(
-          inconvertibleErrorCode(),
-          formatv("couldn't write to the file. {0}", ec.message()));
-
-    json_modules.push_back(
-        JSONModule{system_path, path_to_copy_module.GetPath(),
-                   JSONAddress{load_addr}, module_sp->GetUUID().GetAsString()});
-  }
-  return json_modules;
-}

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.h

public:
   llvm::Error Start(llvm::ArrayRef<lldb::tid_t> tids,
                     StructuredData::ObjectSP configuration =
                         StructuredData::ObjectSP()) override;
 
   /// See \a Trace::OnThreadBinaryDataRead().
   llvm::Error OnThreadBufferRead(lldb::tid_t tid,
                                  OnBinaryDataReadCallback callback);
 
+  /// Get or fetch the cpu information from, for example, /proc/cpuinfo.
   llvm::Expected<pt_cpu> GetCPUInfo();
 
+  /// Get or fetch the values used to convert to and from TSCs and nanos.
+  llvm::Optional<LinuxPerfZeroTscConversion> GetPerfZeroTscConversion();
 
   /// \return
   ///     The timer object for this trace.
   TaskTimer &GetTimer();
 
 private:
   friend class TraceIntelPTSessionFileParser;
 
   llvm::Expected<pt_cpu> GetCPUInfoForLiveProcess();
 
+  /// Postmortem trace constructor
+  ///
+  /// \param[in] session
+  ///     The definition file for the postmortem session.
+  ///
+  /// \param[in] traces_proceses
+  ///     The processes traced in the live session.
+  ///
   /// \param[in] trace_threads
-  ///     ThreadTrace instances, which are not live-processes and whose trace
-  ///     files are fixed.
-  TraceIntelPT(
-      const pt_cpu &cpu_info,
-      const std::vector<lldb::ThreadPostMortemTraceSP> &traced_threads);
+  ///     The threads traced in the live session. They must belong to the
+  ///     processes mentioned above.
+  TraceIntelPT(JSONTraceSession &session,
+               llvm::ArrayRef<lldb::ProcessSP> traced_processes,
+               llvm::ArrayRef<lldb::ThreadPostMortemTraceSP> traced_threads);
 
   /// Constructor for live processes
   TraceIntelPT(Process &live_process)
       : Trace(live_process), m_thread_decoders(){};
 
   /// Decode the trace of the given thread that, i.e. recontruct the traced
   /// instructions.
   ///

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

 }
 
 Expected<TraceSP> TraceIntelPT::CreateInstanceForLiveProcess(Process &process) {
   TraceSP instance(new TraceIntelPT(process));
   process.GetTarget().SetTrace(instance);
   return instance;
 }
 
-TraceIntelPT::TraceIntelPT(
-    const pt_cpu &cpu_info,
-    const std::vector<ThreadPostMortemTraceSP> &traced_threads)
-    : m_cpu_info(cpu_info) {
+TraceIntelPT::TraceIntelPT(JSONTraceSession &session,
+                           ArrayRef<ProcessSP> traced_processes,
+                           ArrayRef<ThreadPostMortemTraceSP> traced_threads)
+    : Trace(traced_processes, session.GetCoreIds()),
+      m_cpu_info(session.cpu_info),
+      m_tsc_conversion(session.tsc_perf_zero_conversion) {
   for (const ThreadPostMortemTraceSP &thread : traced_threads) {
     m_thread_decoders.emplace(thread->GetID(),
                               std::make_unique<ThreadDecoder>(thread, *this));
-    SetPostMortemThreadDataFile(thread->GetID(), IntelPTDataKinds::kTraceBuffer,
-                                thread->GetTraceFile());
+    if (const Optional<FileSpec> &trace_file = thread->GetTraceFile()) {
+      SetPostMortemThreadDataFile(thread->GetID(),
+                                  IntelPTDataKinds::kTraceBuffer, *trace_file);
+    }
+  }
+  if (session.cores) {
+    for (const JSONCore &core : *session.cores) {
+      SetPostMortemCoreDataFile(core.core_id, IntelPTDataKinds::kTraceBuffer,
+                                FileSpec(core.trace_buffer));
+      SetPostMortemCoreDataFile(core.core_id,
+                                IntelPTDataKinds::kPerfContextSwitchTrace,
+                                FileSpec(core.context_switch_trace));
+    }
   }
 }
 
 DecodedThreadSP TraceIntelPT::Decode(Thread &thread) {
   if (const char *error = RefreshLiveProcessState())
     return std::make_shared<DecodedThread>(
         thread.shared_from_this(),
         createStringError(inconvertibleErrorCode(), error));
if (!m_cpu_info) {
     if (llvm::Expected<pt_cpu> cpu_info = GetCPUInfoForLiveProcess())
       m_cpu_info = *cpu_info;
     else
       return cpu_info.takeError();
   }
   return *m_cpu_info;
 }
 
+llvm::Optional<LinuxPerfZeroTscConversion>
+TraceIntelPT::GetPerfZeroTscConversion() {
+  RefreshLiveProcessState();
+  return m_tsc_conversion;
+}
+
 Error TraceIntelPT::DoRefreshLiveProcessState(TraceGetStateResponse state,
                                               StringRef json_response) {
   m_thread_decoders.clear();
 
   for (const TraceThreadState &thread_state : state.traced_threads) {
     ThreadSP thread_sp =
         GetLiveProcess()->GetThreadList().FindThreadByID(thread_state.tid);
     m_thread_decoders.emplace(

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTJSONStructs.h

 //===-- TraceIntelPTJSONStructs.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 LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTJSONSTRUCTS_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTJSONSTRUCTS_H
 
-#include "../common/TraceJSONStructs.h"
+#include "lldb/lldb-types.h"
+
+#include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/JSON.h"
+
 #include <intel-pt.h>
+#include <vector>
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
-struct JSONTraceIntelPTCPUInfo {
-  JSONTraceIntelPTCPUInfo() = default;
+struct JSONModule {
+  std::string system_path;
+  llvm::Optional<std::string> file;
+  uint64_t load_address;
+  llvm::Optional<std::string> uuid;
+};
 
-  JSONTraceIntelPTCPUInfo(pt_cpu cpu_info) {
-    family = static_cast<int64_t>(cpu_info.family);
-    model = static_cast<int64_t>(cpu_info.model);
-    stepping = static_cast<int64_t>(cpu_info.stepping);
-    vendor = cpu_info.vendor == pcv_intel ? "intel" : "Unknown";
-  }
-
-  int64_t family;
-  int64_t model;
-  int64_t stepping;
-  std::string vendor;
+struct JSONThread {
+  int64_t tid;
+  llvm::Optional<std::string> trace_buffer;
 };
 
-struct JSONTraceIntelPTTrace {
-  std::string type;
-  JSONTraceIntelPTCPUInfo cpuInfo;
+struct JSONProcess {
+  int64_t pid;
+  std::string triple;
+  std::vector<JSONThread> threads;
+  std::vector<JSONModule> modules;
 };
 
-struct JSONTraceIntelPTSession {
-  JSONTraceIntelPTTrace ipt_trace;
-  JSONTraceSessionBase session_base;
+struct JSONCore {
+  lldb::core_id_t core_id;
+  std::string trace_buffer;
+  std::string context_switch_trace;
 };
 
-struct JSONTraceIntelPTSettings : JSONTracePluginSettings {
-  JSONTraceIntelPTCPUInfo cpuInfo;
+struct JSONTraceSession {
+  std::string type;
+  pt_cpu cpu_info;
+  std::vector<JSONProcess> processes;
+  llvm::Optional<std::vector<JSONCore>> cores;
+  llvm::Optional<LinuxPerfZeroTscConversion> tsc_perf_zero_conversion;
+
+  llvm::Optional<std::vector<lldb::core_id_t>> GetCoreIds();
 };
 
-} // namespace trace_intel_pt
-} // namespace lldb_private
+llvm::json::Value toJSON(const JSONModule &module);
+
+llvm::json::Value toJSON(const JSONThread &thread);
 
-namespace llvm {
-namespace json {
+llvm::json::Value toJSON(const JSONProcess &process);
 
-bool fromJSON(
-    const Value &value,
-    lldb_private::trace_intel_pt::JSONTraceIntelPTSettings &plugin_settings,
-    Path path);
+llvm::json::Value toJSON(const JSONCore &core);
 
-bool fromJSON(const llvm::json::Value &value,
-              lldb_private::trace_intel_pt::JSONTraceIntelPTCPUInfo &packet,
+llvm::json::Value toJSON(const pt_cpu &cpu_info);
+
+llvm::json::Value toJSON(const JSONTraceSession &session);
+
+bool fromJSON(const llvm::json::Value &value, JSONModule &module,
               llvm::json::Path path);
 
-llvm::json::Value
-toJSON(const lldb_private::trace_intel_pt::JSONTraceIntelPTCPUInfo &cpu_info);
+bool fromJSON(const llvm::json::Value &value, JSONThread &thread,
+              llvm::json::Path path);
+
+bool fromJSON(const llvm::json::Value &value, JSONProcess &process,
+              llvm::json::Path path);
 
-llvm::json::Value
-toJSON(const lldb_private::trace_intel_pt::JSONTraceIntelPTTrace &trace);
+bool fromJSON(const llvm::json::Value &value, JSONCore &core,
+              llvm::json::Path path);
 
-llvm::json::Value
-toJSON(const lldb_private::trace_intel_pt::JSONTraceIntelPTSession &session);
+bool fromJSON(const llvm::json::Value &value, pt_cpu &cpu_info,
+              llvm::json::Path path);
 
-} // namespace json
-} // namespace llvm
+bool fromJSON(const llvm::json::Value &value, JSONTraceSession &session,
+              llvm::json::Path path);
+} // namespace trace_intel_pt
+} // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTJSONSTRUCTS_H

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTJSONStructs.cpp

 
 #include "llvm/Support/JSON.h"
 #include <string>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
+using namespace llvm::json;
 
-namespace llvm {
-namespace json {
+namespace lldb_private {
+namespace trace_intel_pt {
 
-bool fromJSON(const Value &value, JSONTraceIntelPTSettings &plugin_settings,
-              Path path) {
+Optional<std::vector<lldb::core_id_t>> JSONTraceSession::GetCoreIds() {
+  if (!cores)
+    return None;
+  std::vector<lldb::core_id_t> core_ids;
+  for (const JSONCore &core : *cores)
+    core_ids.push_back(core.core_id);
+  return core_ids;
+}
+
+json::Value toJSON(const JSONModule &module) {
+  json::Object json_module;
+  json_module["systemPath"] = module.system_path;
+  if (module.file)
+    json_module["file"] = *module.file;
+  json_module["loadAddress"] = module.load_address;
+  if (module.uuid)
+    json_module["uuid"] = *module.uuid;
+  return std::move(json_module);
+}
+
+bool fromJSON(const json::Value &value, JSONModule &module, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("systemPath", module.system_path) &&
+         o.map("file", module.file) &&
+         o.map("loadAddress", module.load_address) &&
+         o.map("uuid", module.uuid);
+}
+
+json::Value toJSON(const JSONThread &thread) {
+  return json::Object{{"tid", thread.tid},
+                      {"traceBuffer", thread.trace_buffer}};
+}
+
+bool fromJSON(const json::Value &value, JSONThread &thread, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("tid", thread.tid) &&
+         o.map("traceBuffer", thread.trace_buffer);
+}
+
+json::Value toJSON(const JSONProcess &process) {
+  return Object{
+      {"pid", process.pid},
+      {"triple", process.triple},
+      {"threads", process.threads},
+      {"modules", process.modules},
+  };
+}
+
+bool fromJSON(const json::Value &value, JSONProcess &process, Path path) {
   ObjectMapper o(value, path);
-  return o && o.map("cpuInfo", plugin_settings.cpuInfo) &&
-         fromJSON(value, (JSONTracePluginSettings &)plugin_settings, path);
+  return o && o.map("pid", process.pid) && o.map("triple", process.triple) &&
+         o.map("threads", process.threads) && o.map("modules", process.modules);
+}
+
+json::Value toJSON(const JSONCore &core) {
+  return Object{
+      {"coreId", core.core_id},
+      {"traceBuffer", core.trace_buffer},
+      {"contextSwitchTrace", core.context_switch_trace},
+  };
 }
 
-bool fromJSON(const json::Value &value, JSONTraceIntelPTCPUInfo &cpu_info,
-              Path path) {
+bool fromJSON(const json::Value &value, JSONCore &core, Path path) {
   ObjectMapper o(value, path);
-  return o && o.map("vendor", cpu_info.vendor) &&
-         o.map("family", cpu_info.family) && o.map("model", cpu_info.model) &&
-         o.map("stepping", cpu_info.stepping);
+  uint64_t core_id;
+  if (!o || !o.map("coreId", core_id) ||
+      !o.map("traceBuffer", core.trace_buffer) ||
+      !o.map("contextSwitchTrace", core.context_switch_trace))
+    return false;
+  core.core_id = core_id;
+  return true;
 }
 
-Value toJSON(const JSONTraceIntelPTCPUInfo &cpu_info) {
-  return Value(Object{{"family", cpu_info.family},
-                      {"model", cpu_info.model},
-                      {"stepping", cpu_info.stepping},
-                      {"vendor", cpu_info.vendor}});
+json::Value toJSON(const pt_cpu &cpu_info) {
+  return Object{
+      {"vendor", cpu_info.vendor == pcv_intel ? "GenuineIntel" : "Unknown"},
+      {"family", cpu_info.family},
+  };
 }
 
-llvm::json::Value toJSON(const JSONTraceIntelPTTrace &trace) {
-  llvm::json::Object json_trace;
-  json_trace["type"] = trace.type;
-  json_trace["cpuInfo"] = toJSON(trace.cpuInfo);
-  return std::move(json_trace);
+bool fromJSON(const json::Value &value, pt_cpu &cpu_info, Path path) {
+  ObjectMapper o(value, path);
+  std::string vendor;
+  uint64_t family, model, stepping;
+  if (!o || !o.map("vendor", vendor) || !o.map("family", family) ||
+      !o.map("model", model) || !o.map("stepping", stepping))
+    return false;
+  cpu_info.vendor = vendor == "GenuineIntel" ? pcv_intel : pcv_unknown;
+  cpu_info.family = family;
+  cpu_info.model = model;
+  cpu_info.stepping = stepping;
+  return true;
 }
 
-llvm::json::Value toJSON(const JSONTraceIntelPTSession &session) {
-  llvm::json::Object json_session;
-  json_session["trace"] = toJSON(session.ipt_trace);
-  json_session["processes"] = toJSON(session.session_base);
-  return std::move(json_session);
+json::Value toJSON(const JSONTraceSession &session) {
+  return Object{{"type", session.type},
+                {"processes", session.processes},
+                // We have to do this because the compiler fails at doing it
+                // automatically because pt_cpu is not in a namespace
+                {"cpuInfo", toJSON(session.cpu_info)},
+                {"cores", session.cores},
+                {"tscPerfZeroConversion", session.tsc_perf_zero_conversion}};
+}
+
+bool fromJSON(const json::Value &value, JSONTraceSession &session, Path path) {
+  ObjectMapper o(value, path);
+  if (!o || !o.map("processes", session.processes) ||
+      !o.map("type", session.type) || !o.map("cores", session.cores) ||
+      !o.map("tscPerfZeroConversion", session.tsc_perf_zero_conversion))
+    return false;
+  // We have to do this because the compiler fails at doing it automatically
+  // because pt_cpu is not in a namespace
+  if (!fromJSON(*value.getAsObject()->get("cpuInfo"), session.cpu_info,
+                path.field("cpuInfo")))
+    return false;
+  return true;
 }
 
-} // namespace json
-} // namespace llvm
+} // namespace trace_intel_pt
+} // namespace lldb_private

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTSessionFileParser.h

 //===-- TraceIntelPTSessionFileParser.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 LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONFILEPARSER_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONFILEPARSER_H
 
-#include "../common/TraceSessionFileParser.h"
+#include "../common/ThreadPostMortemTrace.h"
 #include "TraceIntelPTJSONStructs.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
 class TraceIntelPT;
 
-class TraceIntelPTSessionFileParser : public TraceSessionFileParser {
+class TraceIntelPTSessionFileParser {
 public:
+  /// Helper struct holding the objects created when parsing a process
+  struct ParsedProcess {
+    lldb::TargetSP target_sp;
+    std::vector<lldb::ThreadPostMortemTraceSP> threads;
+  };
 
-  /// See \a TraceSessionFileParser::TraceSessionFileParser for the description
-  /// of these fields.
+  /// \param[in] debugger
+  ///   The debugger that will own the targets to create.
+  ///
+  /// \param[in] trace_session_file
+  ///   The contents of the main trace session definition file that follows the
+  ///   schema of the intel pt trace plug-in.
+  ///
+  /// \param[in] session_file_dir
+  ///   The folder where the trace session file is located.
   TraceIntelPTSessionFileParser(Debugger &debugger,
                                 const llvm::json::Value &trace_session_file,
                                 llvm::StringRef session_file_dir)
-      : TraceSessionFileParser(debugger, session_file_dir, GetSchema()),
-        m_trace_session_file(trace_session_file) {}
+      : m_debugger(debugger), m_trace_session_file(trace_session_file),
+        m_session_file_dir(session_file_dir) {}
 
   /// \return
   ///   The JSON schema for the session data.
   static llvm::StringRef GetSchema();
 
   /// Parse the structured data trace session and create the corresponding \a
   /// Target objects. In case of an error, no targets are created.
   ///
   /// \return
   ///   A \a lldb::TraceSP instance with the trace session data. In case of
   ///   errors, return a null pointer.
   llvm::Expected<lldb::TraceSP> Parse();
 
   lldb::TraceSP
-  CreateTraceIntelPTInstance(const pt_cpu &cpu_info,
+  CreateTraceIntelPTInstance(JSONTraceSession &session,
                              std::vector<ParsedProcess> &parsed_processes);
 
 private:
-  static pt_cpu ParsePTCPU(const JSONTraceIntelPTCPUInfo &cpu_info);
+  /// Resolve non-absolute paths relative to the session file folder. It
+  /// modifies the given file_spec.
+  void NormalizePath(lldb_private::FileSpec &file_spec);
+
+  lldb::ThreadPostMortemTraceSP ParseThread(lldb::ProcessSP &process_sp,
+                                            const JSONThread &thread);
+
+  llvm::Expected<ParsedProcess> ParseProcess(const JSONProcess &process);
+
+  llvm::Error ParseModule(lldb::TargetSP &target_sp, const JSONModule &module);
+
+  /// Create a user-friendly error message upon a JSON-parsing failure using the
+  /// \a json::ObjectMapper functionality.
+  ///
+  /// \param[in] root
+  ///   The \a llvm::json::Path::Root used to parse the JSON \a value.
+  ///
+  /// \param[in] value
+  ///   The json value that failed to parse.
+  ///
+  /// \return
+  ///   An \a llvm::Error containing the user-friendly error message.
+  llvm::Error CreateJSONError(llvm::json::Path::Root &root,
+                              const llvm::json::Value &value);
+
+  llvm::Expected<std::vector<ParsedProcess>>
+  ParseSessionFile(const JSONTraceSession &session);
 
+  Debugger &m_debugger;
   const llvm::json::Value &m_trace_session_file;
+  std::string m_session_file_dir;
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONFILEPARSER_H

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTSessionFileParser.cpp

 //===-- TraceIntelPTSessionFileParser.cpp ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "TraceIntelPTSessionFileParser.h"
 
 #include "../common/ThreadPostMortemTrace.h"
 #include "TraceIntelPT.h"
+#include "TraceIntelPTJSONStructs.h"
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
+void TraceIntelPTSessionFileParser::NormalizePath(
+    lldb_private::FileSpec &file_spec) {
+  if (file_spec.IsRelative())
+    file_spec.PrependPathComponent(m_session_file_dir);
+}
+
+Error TraceIntelPTSessionFileParser::ParseModule(lldb::TargetSP &target_sp,
+                                                 const JSONModule &module) {
+  FileSpec system_file_spec(module.system_path);
+  NormalizePath(system_file_spec);
+
+  FileSpec local_file_spec(module.file.hasValue() ? *module.file
+                                                  : module.system_path);
+  NormalizePath(local_file_spec);
+
+  ModuleSpec module_spec;
+  module_spec.GetFileSpec() = local_file_spec;
+  module_spec.GetPlatformFileSpec() = system_file_spec;
+
+  if (module.uuid.hasValue())
+    module_spec.GetUUID().SetFromStringRef(*module.uuid);
+
+  Status error;
+  ModuleSP module_sp =
+      target_sp->GetOrCreateModule(module_spec, /*notify*/ false, &error);
+
+  if (error.Fail())
+    return error.ToError();
+
+  bool load_addr_changed = false;
+  module_sp->SetLoadAddress(*target_sp, module.load_address, false,
+                            load_addr_changed);
+  return llvm::Error::success();
+}
+
+Error TraceIntelPTSessionFileParser::CreateJSONError(json::Path::Root &root,
+                                                     const json::Value &value) {
+  std::string err;
+  raw_string_ostream os(err);
+  root.printErrorContext(value, os);
+  return createStringError(
+      std::errc::invalid_argument, "%s\n\nContext:\n%s\n\nSchema:\n%s",
+      toString(root.getError()).c_str(), os.str().c_str(), GetSchema().data());
+}
+
+ThreadPostMortemTraceSP
+TraceIntelPTSessionFileParser::ParseThread(ProcessSP &process_sp,
+                                           const JSONThread &thread) {
+  lldb::tid_t tid = static_cast<lldb::tid_t>(thread.tid);
+
+  Optional<FileSpec> trace_file;
+  if (thread.trace_buffer) {
+    trace_file.emplace(*thread.trace_buffer);
+    NormalizePath(*trace_file);
+  }
+
+  ThreadPostMortemTraceSP thread_sp =
+      std::make_shared<ThreadPostMortemTrace>(*process_sp, tid, trace_file);
+  process_sp->GetThreadList().AddThread(thread_sp);
+  return thread_sp;
+}
+
+Expected<TraceIntelPTSessionFileParser::ParsedProcess>
+TraceIntelPTSessionFileParser::ParseProcess(const JSONProcess &process) {
+  TargetSP target_sp;
+  Status error = m_debugger.GetTargetList().CreateTarget(
+      m_debugger, /*user_exe_path*/ StringRef(), process.triple,
+      eLoadDependentsNo,
+      /*platform_options*/ nullptr, target_sp);
+
+  if (!target_sp)
+    return error.ToError();
+
+  ParsedProcess parsed_process;
+  parsed_process.target_sp = target_sp;
+
+  ProcessSP process_sp = target_sp->CreateProcess(
+      /*listener*/ nullptr, "trace",
+      /*crash_file*/ nullptr,
+      /*can_connect*/ false);
+
+  process_sp->SetID(static_cast<lldb::pid_t>(process.pid));
+
+  for (const JSONThread &thread : process.threads)
+    parsed_process.threads.push_back(ParseThread(process_sp, thread));
+
+  for (const JSONModule &module : process.modules)
+    if (Error err = ParseModule(target_sp, module))
+      return std::move(err);
+
+  if (!process.threads.empty())
+    process_sp->GetThreadList().SetSelectedThreadByIndexID(0);
+
+  // We invoke DidAttach to create a correct stopped state for the process and
+  // its threads.
+  ArchSpec process_arch;
+  process_sp->DidAttach(process_arch);
+
+  return parsed_process;
+}
+
+Expected<std::vector<TraceIntelPTSessionFileParser::ParsedProcess>>
+TraceIntelPTSessionFileParser::ParseSessionFile(
+    const JSONTraceSession &session) {
+  std::vector<ParsedProcess> parsed_processes;
+
+  auto HandleError = [&](Error &&err) {
+    // Delete all targets that were created so far in case of failures
+    for (ParsedProcess &parsed_process : parsed_processes)
+      m_debugger.GetTargetList().DeleteTarget(parsed_process.target_sp);
+    return std::move(err);
+  };
+
+  for (const JSONProcess &process : session.processes) {
+    if (Expected<ParsedProcess> parsed_process = ParseProcess(process))
+      parsed_processes.push_back(std::move(*parsed_process));
+    else
+      return HandleError(parsed_process.takeError());
+  }
+  return parsed_processes;
+}
+
 StringRef TraceIntelPTSessionFileParser::GetSchema() {
   static std::string schema;
   if (schema.empty()) {
-    schema = TraceSessionFileParser::BuildSchema(R"({
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel" | "unknown",
-      "family": integer,
-      "model": integer,
-      "stepping": integer
-    }
-  })");
-  }
-  return schema;
+    schema = R"({
+    // CPU information gotten from, for example, /proc/cpuinfo.
+
+    "vendor": "GenuineIntel" | "unknown",
+  },
+  "processes": [
+    {
+      "pid": integer,
+      "triple": string,
+          // clang/llvm target triple.
+      "threads": [
+        {
+          "tid": integer,
+          "traceBuffer"?: string
+              // Path to the raw Intel PT buffer file for this thread.
+        }
+      ],
+      "modules": [
+        {
+          "systemPath": string,
+              // Original path of the module at runtime.
+          "file"?: string,
+              // Path to a copy of the file if not available at "systemPath".
+          "loadAddress": integer,
+              // Lowest address of the sections of the module loaded on memory.
+          "uuid"?: string,
+              // Build UUID for the file for sanity checks.
+        }
+      ]
+    }
+  ],
+  "cores"?: [
+    {
+      "coreId": integer,
+          // Id of this CPU core.
+      "traceBuffer": string,
+          // Path to the raw Intel PT buffer for this core.
+      "contextSwitchTrace": string,
+          // Path to the raw perf_event_open context switch trace file for this core.
+    }
+  ],
+  "tscPerfZeroConversion"?: {
+    // Values used to convert between TSCs and nanoseconds. See the time_zero
+    // section in https://man7.org/linux/man-pages/man2/perf_event_open.2.html
+    // for for information.
+
+    "timeMult": integer,
+    "timeShift": integer,
+    "timeZero": integer,
 }
 
-pt_cpu TraceIntelPTSessionFileParser::ParsePTCPU(
-    const JSONTraceIntelPTCPUInfo &cpu_info) {
-  return {cpu_info.vendor.compare("intel") == 0 ? pcv_intel : pcv_unknown,
-          static_cast<uint16_t>(cpu_info.family),
-          static_cast<uint8_t>(cpu_info.model),
-          static_cast<uint8_t>(cpu_info.stepping)};
+Notes:
+
+- All paths are either absolute or relative to folder containing the session file.
+- "cores" is provided if and only if processes[].threads[].traceBuffer is not provided.
+- "tscPerfZeroConversion" must be provided if "cores" is provided.
+ })";
+  }
+  return schema;
 }
 
 TraceSP TraceIntelPTSessionFileParser::CreateTraceIntelPTInstance(
-    const pt_cpu &cpu_info, std::vector<ParsedProcess> &parsed_processes) {
+    JSONTraceSession &session, std::vector<ParsedProcess> &parsed_processes) {
   std::vector<ThreadPostMortemTraceSP> threads;
-  for (const ParsedProcess &parsed_process : parsed_processes)
+  std::vector<ProcessSP> processes;
+  for (const ParsedProcess &parsed_process : parsed_processes) {
+    processes.push_back(parsed_process.target_sp->GetProcessSP());
     threads.insert(threads.end(), parsed_process.threads.begin(),
                    parsed_process.threads.end());
+  }
 
-  TraceSP trace_instance(new TraceIntelPT(cpu_info, threads));
+  TraceSP trace_instance(new TraceIntelPT(session, processes, threads));
   for (const ParsedProcess &parsed_process : parsed_processes)
     parsed_process.target_sp->SetTrace(trace_instance);
 
   return trace_instance;
 }
 
 Expected<TraceSP> TraceIntelPTSessionFileParser::Parse() {
   json::Path::Root root("traceSession");
-  JSONTraceSession<JSONTraceIntelPTSettings> session;
-  if (!json::fromJSON(m_trace_session_file, session, root))
+  JSONTraceSession session;
+  if (!fromJSON(m_trace_session_file, session, root))
     return CreateJSONError(root, m_trace_session_file);
 
   if (Expected<std::vector<ParsedProcess>> parsed_processes =
-          ParseCommonSessionFile(session))
-    return CreateTraceIntelPTInstance(ParsePTCPU(session.trace.cpuInfo),
-                                      *parsed_processes);
+          ParseSessionFile(session))
+    return CreateTraceIntelPTInstance(session, *parsed_processes);
   else
     return parsed_processes.takeError();
 }

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTSessionSaver.h

 //===-- TraceIntelPTSessionSaver.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 LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONSAVER_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONSAVER_H
 
 #include "TraceIntelPT.h"
 
-#include "../common/TraceJSONStructs.h"
+#include "TraceIntelPTJSONStructs.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
-class TraceIntelPT;
-
 class TraceIntelPTSessionSaver {
-
 public:
   /// Save the Intel PT trace of a live process to the specified directory,
   /// which will be created if needed. This will also create a file
   /// \a <directory>/trace.json with the main properties of the trace
   /// session, along with others files which contain the actual trace data.
   /// The trace.json file can be used later as input for the "trace load"
   /// command to load the trace in LLDB.
   ///
   /// \param[in] trace_ipt
   ///     The Intel PT trace to be saved to disk.
   ///
   /// \param[in] directory
   ///     The directory where the trace files will be saved.
   ///
   /// \return
   ///     \a llvm::success if the operation was successful, or an \a llvm::Error
   ///     otherwise.
   llvm::Error SaveToDisk(TraceIntelPT &trace_ipt, FileSpec directory);
-
-private:
-  /// Build trace section of the intel-pt trace session description file.
-  ///
-  /// \param[in] trace_ipt
-  ///     The Intel PT trace.
-  ///
-  /// \return
-  ///     The trace section  an \a llvm::Error in case of failures.
-  llvm::Expected<JSONTraceIntelPTTrace>
-  BuildTraceSection(TraceIntelPT &trace_ipt);
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONSAVER_H

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTSessionSaver.cpp

 //===-- TraceIntelPTSessionSaver.cpp --------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "TraceIntelPTSessionSaver.h"
-#include "../common/TraceSessionSaver.h"
 #include "TraceIntelPT.h"
 #include "TraceIntelPTJSONStructs.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/None.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/JSON.h"
 
 #include <fstream>
 #include <iostream>
 #include <sstream>
 #include <string>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
-llvm::Error TraceIntelPTSessionSaver::SaveToDisk(TraceIntelPT &trace_ipt,
-                                                 FileSpec directory) {
-  Process *live_process = trace_ipt.GetLiveProcess();
-  if (live_process == nullptr)
+static llvm::Error WriteBytesToDisk(FileSpec &output_file,
+                                    ArrayRef<uint8_t> data) {
+  std::basic_fstream<char> out_fs = std::fstream(
+      output_file.GetPath().c_str(), std::ios::out | std::ios::binary);
+  out_fs.write(reinterpret_cast<const char *>(&data[0]),
+               data.size() * sizeof(uint8_t));
+  out_fs.close();
+  if (!out_fs)
     return createStringError(inconvertibleErrorCode(),
-                             "Saving a trace requires a live process.");
+                             formatv("couldn't write to the file {0}",
+                                     output_file.GetPath().c_str()));
+  return Error::success();
+}
 
-  if (std::error_code ec =
-          sys::fs::create_directories(directory.GetPath().c_str()))
-    return llvm::errorCodeToError(ec);
+/// Save the trace session description JSON object inside the given directory
+/// as a file named \a trace.json.
+///
+/// \param[in] trace_session_json
+///     The trace's session, as JSON Object.
+///
+/// \param[in] directory
+///     The directory where the JSON file will be saved.
+///
+/// \return
+///     \a llvm::Success if the operation was successful, or an \a llvm::Error
+///     otherwise.
+static llvm::Error
+WriteSessionToFile(const llvm::json::Value &trace_session_json,
+                   const FileSpec &directory) {
+  FileSpec trace_path = directory;
+  trace_path.AppendPathComponent("trace.json");
+  std::ofstream os(trace_path.GetPath());
+  os << std::string(formatv("{0:2}", trace_session_json));
+  os.close();
+  if (!os)
+    return createStringError(inconvertibleErrorCode(),
+                             formatv("couldn't write to the file {0}",
+                                     trace_path.GetPath().c_str()));
+  return Error::success();
+}
 
-  llvm::Expected<JSONTraceIntelPTTrace> json_intel_pt_trace =
-      BuildTraceSection(trace_ipt);
-  if (!json_intel_pt_trace)
-    return json_intel_pt_trace.takeError();
+/// Build the threads sub-section of the trace session description file.
+/// Any associated binary files are created inside the given directory.
+///
+/// \param[in] process
+///     The process being traced.
+///
+/// \param[in] directory
+///     The directory where files will be saved when building the threads
+///     section.
+///
+/// \return
+///     The threads section or \a llvm::Error in case of failures.
+static llvm::Expected<std::vector<JSONThread>>
+BuildThreadsSection(Process &process, FileSpec directory) {
+  std::vector<JSONThread> json_threads;
+  TraceSP trace_sp = process.GetTarget().GetTrace();
+
+  FileSpec threads_dir = directory;
+  threads_dir.AppendPathComponent("threads");
+  FileSystem::Instance().Resolve(threads_dir);
+  sys::fs::create_directories(threads_dir.GetCString());
+
+  for (ThreadSP thread_sp : process.Threads()) {
+    lldb::tid_t tid = thread_sp->GetID();
+    if (!trace_sp->IsTraced(tid))
+      continue;
+
+    JSONThread json_thread;
+    json_thread.tid = tid;
+
+    if (trace_sp->GetTracedCores().empty()) {
+      FileSpec output_file = threads_dir;
+      output_file.AppendPathComponent(std::to_string(tid) + ".intelpt_trace");
+      json_thread.trace_buffer = output_file.GetPath();
+
+      llvm::Error err = process.GetTarget().GetTrace()->OnThreadBinaryDataRead(
+          tid, IntelPTDataKinds::kTraceBuffer,
+          [&](llvm::ArrayRef<uint8_t> data) -> llvm::Error {
+            return WriteBytesToDisk(output_file, data);
+          });
+      if (err)
+        return std::move(err);
+    }
+
+    json_threads.push_back(std::move(json_thread));
+  }
+  return json_threads;
+}
 
-  llvm::Expected<JSONTraceSessionBase> json_session_description =
-      TraceSessionSaver::BuildProcessesSection(
-          *live_process, IntelPTDataKinds::kTraceBuffer, directory);
+static llvm::Expected<llvm::Optional<std::vector<JSONCore>>>
+BuildCoresSection(TraceIntelPT &trace_ipt, FileSpec directory) {
+  if (trace_ipt.GetTracedCores().empty())
+    return None;
+
+  std::vector<JSONCore> json_cores;
+  FileSpec cores_dir = directory;
+  cores_dir.AppendPathComponent("cores");
+  FileSystem::Instance().Resolve(cores_dir);
+  sys::fs::create_directories(cores_dir.GetCString());
+
+  for (lldb::core_id_t core_id : trace_ipt.GetTracedCores()) {
+    JSONCore json_core;
+    json_core.core_id = core_id;
+
+    {
+      FileSpec output_trace = cores_dir;
+      output_trace.AppendPathComponent(std::to_string(core_id) +
+                                       ".intelpt_trace");
+      json_core.trace_buffer = output_trace.GetPath();
+
+      llvm::Error err = trace_ipt.OnCoreBinaryDataRead(
+          core_id, IntelPTDataKinds::kTraceBuffer,
+          [&](llvm::ArrayRef<uint8_t> data) -> llvm::Error {
+            return WriteBytesToDisk(output_trace, data);
+          });
+      if (err)
+        return std::move(err);
+    }
+
+    {
+      FileSpec output_context_switch_trace = cores_dir;
+      output_context_switch_trace.AppendPathComponent(
+          std::to_string(core_id) + ".perf_context_switch_trace");
+      json_core.context_switch_trace = output_context_switch_trace.GetPath();
+
+      llvm::Error err = trace_ipt.OnCoreBinaryDataRead(
+          core_id, IntelPTDataKinds::kPerfContextSwitchTrace,
+          [&](llvm::ArrayRef<uint8_t> data) -> llvm::Error {
+            return WriteBytesToDisk(output_context_switch_trace, data);
+          });
+      if (err)
+        return std::move(err);
+    }
+    json_cores.push_back(std::move(json_core));
+  }
+  return json_cores;
+}
 
-  if (!json_session_description)
-    return json_session_description.takeError();
+/// Build modules sub-section of the trace's session. The original modules
+/// will be copied over to the \a <directory/modules> folder. Invalid modules
+/// are skipped.
+/// Copying the modules has the benefit of making these trace session
+/// directories self-contained, as the raw traces and modules are part of the
+/// output directory and can be sent to another machine, where lldb can load
+/// them and replicate exactly the same trace session.
+///
+/// \param[in] process
+///     The process being traced.
+///
+/// \param[in] directory
+///     The directory where the modules files will be saved when building
+///     the modules section.
+///     Example: If a module \a libbar.so exists in the path
+///     \a /usr/lib/foo/libbar.so, then it will be copied to
+///     \a <directory>/modules/usr/lib/foo/libbar.so.
+///
+/// \return
+///     The modules section or \a llvm::Error in case of failures.
+static llvm::Expected<std::vector<JSONModule>>
+BuildModulesSection(Process &process, FileSpec directory) {
+  std::vector<JSONModule> json_modules;
+  ModuleList module_list = process.GetTarget().GetImages();
+  for (size_t i = 0; i < module_list.GetSize(); ++i) {
+    ModuleSP module_sp(module_list.GetModuleAtIndex(i));
+    if (!module_sp)
+      continue;
+    std::string system_path = module_sp->GetPlatformFileSpec().GetPath();
+    // TODO: support memory-only libraries like [vdso]
+    if (!module_sp->GetFileSpec().IsAbsolute())
+      continue;
+
+    std::string file = module_sp->GetFileSpec().GetPath();
+    ObjectFile *objfile = module_sp->GetObjectFile();
+    if (objfile == nullptr)
+      continue;
+
+    lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
+    Address base_addr(objfile->GetBaseAddress());
+    if (base_addr.IsValid() &&
+        !process.GetTarget().GetSectionLoadList().IsEmpty())
+      load_addr = base_addr.GetLoadAddress(&process.GetTarget());
+
+    if (load_addr == LLDB_INVALID_ADDRESS)
+      continue;
+
+    FileSystem::Instance().Resolve(directory);
+    FileSpec path_to_copy_module = directory;
+    path_to_copy_module.AppendPathComponent("modules");
+    path_to_copy_module.AppendPathComponent(system_path);
+    sys::fs::create_directories(path_to_copy_module.GetDirectory().AsCString());
+
+    if (std::error_code ec = llvm::sys::fs::copy_file(
+            system_path, path_to_copy_module.GetPath()))
+      return createStringError(
+          inconvertibleErrorCode(),
+          formatv("couldn't write to the file. {0}", ec.message()));
+
+    json_modules.push_back(JSONModule{system_path,
+                                      path_to_copy_module.GetPath(), load_addr,
+                                      module_sp->GetUUID().GetAsString()});
+  }
+  return json_modules;
+}
 
-  JSONTraceIntelPTSession json_intel_pt_session{json_intel_pt_trace.get(),
-                                                json_session_description.get()};
+/// Build the processes section of the trace session description file. Besides
+/// returning the processes information, this method saves to disk all modules
+/// and raw traces corresponding to the traced threads of the given process.
+///
+/// \param[in] process
+///     The process being traced.
+///
+/// \param[in] directory
+///     The directory where files will be saved when building the processes
+///     section.
+///
+/// \return
+///     The processes section or \a llvm::Error in case of failures.
+static llvm::Expected<JSONProcess>
+BuildProcessSection(Process &process, const FileSpec &directory) {
+  Expected<std::vector<JSONThread>> json_threads =
+      BuildThreadsSection(process, directory);
+  if (!json_threads)
+    return json_threads.takeError();
+
+  Expected<std::vector<JSONModule>> json_modules =
+      BuildModulesSection(process, directory);
+  if (!json_modules)
+    return json_modules.takeError();
+
+  return JSONProcess{
+      static_cast<int64_t>(process.GetID()),
+      process.GetTarget().GetArchitecture().GetTriple().getTriple(),
+      json_threads.get(), json_modules.get()};
+}
 
-  return TraceSessionSaver::WriteSessionToFile(
-      llvm::json::toJSON(json_intel_pt_session), directory);
+/// See BuildProcessSection()
+static llvm::Expected<std::vector<JSONProcess>>
+BuildProcessesSection(TraceIntelPT &trace_ipt, const FileSpec &directory) {
+  std::vector<JSONProcess> processes;
+  for (Process *process : trace_ipt.GetAllProcesses()) {
+    if (llvm::Expected<JSONProcess> json_process =
+            BuildProcessSection(*process, directory))
+      processes.push_back(std::move(*json_process));
+    else
+      return json_process.takeError();
+  }
+  return processes;
 }
 
-llvm::Expected<JSONTraceIntelPTTrace>
-TraceIntelPTSessionSaver::BuildTraceSection(TraceIntelPT &trace_ipt) {
-  llvm::Expected<pt_cpu> cpu_info = trace_ipt.GetCPUInfo();
+Error TraceIntelPTSessionSaver::SaveToDisk(TraceIntelPT &trace_ipt,
+                                           FileSpec directory) {
+  if (std::error_code ec =
+          sys::fs::create_directories(directory.GetPath().c_str()))
+    return llvm::errorCodeToError(ec);
+
+  Expected<pt_cpu> cpu_info = trace_ipt.GetCPUInfo();
   if (!cpu_info)
     return cpu_info.takeError();
 
-  return JSONTraceIntelPTTrace{"intel-pt",
-                               JSONTraceIntelPTCPUInfo(cpu_info.get())};
+  Expected<std::vector<JSONProcess>> json_processes =
+      BuildProcessesSection(trace_ipt, directory);
+
+  if (!json_processes)
+    return json_processes.takeError();
+
+  Expected<Optional<std::vector<JSONCore>>> json_cores =
+      BuildCoresSection(trace_ipt, directory);
+  if (!json_cores)
+    return json_cores.takeError();
+
+  JSONTraceSession json_intel_pt_session{"intel-pt", *cpu_info, *json_processes,
+                                         *json_cores,
+                                         trace_ipt.GetPerfZeroTscConversion()};
+
+  return WriteSessionToFile(toJSON(json_intel_pt_session), directory);
 }

lldb/source/Target/Trace.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm;
 
 // Helper structs used to extract the type of a trace session json without
 // having to parse the entire object.
 
-struct JSONSimplePluginSettings {
-  std::string type;
-};
-
 struct JSONSimpleTraceSession {
-  JSONSimplePluginSettings trace;
+  std::string type;
 };
 
 namespace llvm {
 namespace json {
 
-bool fromJSON(const Value &value, JSONSimplePluginSettings &plugin_settings,
-              Path path) {
-  json::ObjectMapper o(value, path);
-  return o && o.map("type", plugin_settings.type);
-}
-
 bool fromJSON(const Value &value, JSONSimpleTraceSession &session, Path path) {
   json::ObjectMapper o(value, path);
-  return o && o.map("trace", session.trace);
+  return o && o.map("type", session.type);
 }
 
 } // namespace json
 } // namespace llvm
 
 static Error createInvalidPlugInError(StringRef plugin_name) {
   return createStringError(
       std::errc::invalid_argument,
       "no trace plug-in matches the specified type: \"%s\"",
       plugin_name.data());
 }
 
 Expected<lldb::TraceSP>
 Trace::FindPluginForPostMortemProcess(Debugger &debugger,
                                       const json::Value &trace_session_file,
                                       StringRef session_file_dir) {
   JSONSimpleTraceSession json_session;
   json::Path::Root root("traceSession");
   if (!json::fromJSON(trace_session_file, json_session, root))
     return root.getError();
 
   if (auto create_callback =
-          PluginManager::GetTraceCreateCallback(json_session.trace.type))
+          PluginManager::GetTraceCreateCallback(json_session.type))
     return create_callback(trace_session_file, session_file_dir, debugger);
 
-  return createInvalidPlugInError(json_session.trace.type);
+  return createInvalidPlugInError(json_session.type);
 }
 
 Expected<lldb::TraceSP> Trace::FindPluginForLiveProcess(llvm::StringRef name,
                                                         Process &process) {
   if (!process.IsLiveDebugSession())
     return createStringError(inconvertibleErrorCode(),
                              "Can't trace non-live processes");
 
if (it == m_live_thread_data.end())
     return None;
   std::unordered_map<std::string, size_t> &single_thread_data = it->second;
   auto single_thread_data_it = single_thread_data.find(kind.str());
   if (single_thread_data_it == single_thread_data.end())
     return None;
   return single_thread_data_it->second;
 }
 
+Optional<size_t> Trace::GetLiveCoreBinaryDataSize(lldb::core_id_t core_id,
+                                                  llvm::StringRef kind) {
+  auto it = m_live_core_data.find(core_id);
+  if (it == m_live_core_data.end())
+    return None;
+  std::unordered_map<std::string, size_t> &single_core_data = it->second;
+  auto single_thread_data_it = single_core_data.find(kind.str());
+  if (single_thread_data_it == single_core_data.end())
+    return None;
+  return single_thread_data_it->second;
+}
+
 Optional<size_t> Trace::GetLiveProcessBinaryDataSize(llvm::StringRef kind) {
   auto data_it = m_live_process_data.find(kind.str());
   if (data_it == m_live_process_data.end())
     return None;
   return data_it->second;
 }
 
 Expected<std::vector<uint8_t>>
 Trace::GetLiveThreadBinaryData(lldb::tid_t tid, llvm::StringRef kind) {
   if (!m_live_process)
     return createStringError(inconvertibleErrorCode(),
                              "Tracing requires a live process.");
   llvm::Optional<size_t> size = GetLiveThreadBinaryDataSize(tid, kind);
   if (!size)
     return createStringError(
         inconvertibleErrorCode(),
         "Tracing data \"%s\" is not available for thread %" PRIu64 ".",
         kind.data(), tid);
 
-  TraceGetBinaryDataRequest request{GetPluginName().str(), kind.str(), tid, 0,
-                                    *size};
+  TraceGetBinaryDataRequest request{GetPluginName().str(), kind.str(),   tid,
+                                    /*core_id=*/None,      /*offset=*/0, *size};
+  return m_live_process->TraceGetBinaryData(request);
+}
+
+Expected<std::vector<uint8_t>>
+Trace::GetLiveCoreBinaryData(lldb::core_id_t core_id, llvm::StringRef kind) {
+  if (!m_live_process)
+    return createStringError(inconvertibleErrorCode(),
+                             "Tracing requires a live process.");
+  llvm::Optional<size_t> size = GetLiveCoreBinaryDataSize(core_id, kind);
+  if (!size)
+    return createStringError(
+        inconvertibleErrorCode(),
+        "Tracing data \"%s\" is not available for core_id %" PRIu64 ".",
+        kind.data(), core_id);
+
+  TraceGetBinaryDataRequest request{GetPluginName().str(), kind.str(),
+                                    /*tid=*/None,          core_id,
+                                    /*offset=*/0,          *size};
   return m_live_process->TraceGetBinaryData(request);
 }
 
 Expected<std::vector<uint8_t>>
 Trace::GetLiveProcessBinaryData(llvm::StringRef kind) {
   if (!m_live_process)
     return createStringError(inconvertibleErrorCode(),
                              "Tracing requires a live process.");
   llvm::Optional<size_t> size = GetLiveProcessBinaryDataSize(kind);
   if (!size)
     return createStringError(
         inconvertibleErrorCode(),
         "Tracing data \"%s\" is not available for the process.", kind.data());
 
-  TraceGetBinaryDataRequest request{GetPluginName().str(), kind.str(), None, 0,
-                                    *size};
+  TraceGetBinaryDataRequest request{GetPluginName().str(), kind.str(),
+                                    /*tid=*/None,          /*core_id*/ None,
+                                    /*offset=*/0,          *size};
   return m_live_process->TraceGetBinaryData(request);
 }
 
 const char *Trace::RefreshLiveProcessState() {
   if (!m_live_process)
     return nullptr;
 
   uint32_t new_stop_id = m_live_process->GetStopID();
   if (new_stop_id == m_stop_id)
     return nullptr;
 
   Log *log = GetLog(LLDBLog::Target);
   LLDB_LOG(log, "Trace::RefreshLiveProcessState invoked");
 
   m_stop_id = new_stop_id;
   m_live_thread_data.clear();
   m_live_refresh_error.reset();
+  m_cores.reset();
 
   auto HandleError = [&](Error &&err) -> const char * {
     m_live_refresh_error = toString(std::move(err));
     return m_live_refresh_error->c_str();
   };
 
   Expected<std::string> json_string = GetLiveProcessState();
   if (!json_string)
     return HandleError(json_string.takeError());
 
   Expected<TraceGetStateResponse> live_process_state =
       json::parse<TraceGetStateResponse>(*json_string, "TraceGetStateResponse");
   if (!live_process_state)
     return HandleError(live_process_state.takeError());
 
-  for (std::string &warning : live_process_state->warnings)
-    LLDB_LOG(log, "Warning when fetching the trace state: {0}", warning);
+  if (live_process_state->warnings) {
+    for (std::string &warning : *live_process_state->warnings)
+      LLDB_LOG(log, "== Warning when fetching the trace state: {0}", warning);
+  }
 
   for (const TraceThreadState &thread_state :
        live_process_state->traced_threads) {
     for (const TraceBinaryData &item : thread_state.binary_data)
       m_live_thread_data[thread_state.tid][item.kind] = item.size;
   }
 
+  LLDB_LOG(log, "== Found {0} threads being traced",
+           live_process_state->traced_threads.size());
+
+  if (live_process_state->cores) {
+    m_cores.emplace();
+    for (const TraceCoreState &core_state : *live_process_state->cores) {
+      m_cores->push_back(core_state.core_id);
+      for (const TraceBinaryData &item : core_state.binary_data)
+        m_live_core_data[core_state.core_id][item.kind] = item.size;
+    }
+    LLDB_LOG(log, "== Found {0} cpu cores being traced",
+            live_process_state->cores->size());
+  }
+
+
   for (const TraceBinaryData &item : live_process_state->process_binary_data)
     m_live_process_data[item.kind] = item.size;
 
   if (Error err = DoRefreshLiveProcessState(std::move(*live_process_state),
                                             *json_string))
     return HandleError(std::move(err));
 
   return nullptr;
 }
 
+Trace::Trace(ArrayRef<ProcessSP> postmortem_processes,
+             Optional<std::vector<lldb::core_id_t>> postmortem_cores) {
+  for (ProcessSP process_sp : postmortem_processes)
+    m_postmortem_processes.push_back(process_sp.get());
+  m_cores = postmortem_cores;
+}
+
 Process *Trace::GetLiveProcess() { return m_live_process; }
 
+ArrayRef<Process *> Trace::GetPostMortemProcesses() {
+  return m_postmortem_processes;
+}
+
+std::vector<Process *> Trace::GetAllProcesses() {
+  if (Process *proc = GetLiveProcess())
+    return {proc};
+  return GetPostMortemProcesses();
+}
+
 uint32_t Trace::GetStopID() {
   RefreshLiveProcessState();
   return m_stop_id;
 }
 
 llvm::Expected<FileSpec>
 Trace::GetPostMortemThreadDataFile(lldb::tid_t tid, llvm::StringRef kind) {
   auto NotFoundError = [&]() {
Trace::GetPostMortemThreadDataFile(lldb::tid_t tid, llvm::StringRef kind) {
   std::unordered_map<std::string, FileSpec> &data_kind_to_file_spec_map =
       it->second;
   auto it2 = data_kind_to_file_spec_map.find(kind.str());
   if (it2 == data_kind_to_file_spec_map.end())
     return NotFoundError();
   return it2->second;
 }
 
+llvm::Expected<FileSpec>
+Trace::GetPostMortemCoreDataFile(lldb::core_id_t core_id,
+                                 llvm::StringRef kind) {
+  auto NotFoundError = [&]() {
+    return createStringError(
+        inconvertibleErrorCode(),
+        formatv("The core with id={0} doesn't have the tracing data {1}",
+                core_id, kind));
+  };
+
+  auto it = m_postmortem_core_data.find(core_id);
+  if (it == m_postmortem_core_data.end())
+    return NotFoundError();
+
+  std::unordered_map<std::string, FileSpec> &data_kind_to_file_spec_map =
+      it->second;
+  auto it2 = data_kind_to_file_spec_map.find(kind.str());
+  if (it2 == data_kind_to_file_spec_map.end())
+    return NotFoundError();
+  return it2->second;
+}
+
 void Trace::SetPostMortemThreadDataFile(lldb::tid_t tid, llvm::StringRef kind,
                                         FileSpec file_spec) {
   m_postmortem_thread_data[tid][kind.str()] = file_spec;
 }
 
+void Trace::SetPostMortemCoreDataFile(lldb::core_id_t core_id,
+                                      llvm::StringRef kind,
+                                      FileSpec file_spec) {
+  m_postmortem_core_data[core_id][kind.str()] = file_spec;
+}
+
 llvm::Error
 Trace::OnLiveThreadBinaryDataRead(lldb::tid_t tid, llvm::StringRef kind,
                                   OnBinaryDataReadCallback callback) {
   Expected<std::vector<uint8_t>> data = GetLiveThreadBinaryData(tid, kind);
   if (!data)
     return data.takeError();
   return callback(*data);
 }
 
-llvm::Error
-Trace::OnPostMortemThreadBinaryDataRead(lldb::tid_t tid, llvm::StringRef kind,
-                                        OnBinaryDataReadCallback callback) {
-  Expected<FileSpec> file = GetPostMortemThreadDataFile(tid, kind);
-  if (!file)
-    return file.takeError();
+llvm::Error Trace::OnLiveCoreBinaryDataRead(lldb::core_id_t core_id,
+                                            llvm::StringRef kind,
+                                            OnBinaryDataReadCallback callback) {
+  Expected<std::vector<uint8_t>> data = GetLiveCoreBinaryData(core_id, kind);
+  if (!data)
+    return data.takeError();
+  return callback(*data);
+}
+
+llvm::Error Trace::OnDataFileRead(FileSpec file,
   ErrorOr<std::unique_ptr<MemoryBuffer>> trace_or_error =
-      MemoryBuffer::getFile(file->GetPath());
+      MemoryBuffer::getFile(file.GetPath());
   if (std::error_code err = trace_or_error.getError())
     return errorCodeToError(err);
 
   MemoryBuffer &data = **trace_or_error;
   ArrayRef<uint8_t> array_ref(
       reinterpret_cast<const uint8_t *>(data.getBufferStart()),
       data.getBufferSize());
   return callback(array_ref);
 }
 
+llvm::Error
+Trace::OnPostMortemThreadBinaryDataRead(lldb::tid_t tid, llvm::StringRef kind,
+                                        OnBinaryDataReadCallback callback) {
+  Expected<FileSpec> file = GetPostMortemThreadDataFile(tid, kind);
+  if (!file)
+    return file.takeError();
+  return OnDataFileRead(*file, callback);
+}
+
+llvm::Error
+Trace::OnPostMortemCoreBinaryDataRead(lldb::core_id_t core_id,
+                                      llvm::StringRef kind,
+                                      OnBinaryDataReadCallback callback) {
+  Expected<FileSpec> file = GetPostMortemCoreDataFile(core_id, kind);
+  if (!file)
+    return file.takeError();
+  return OnDataFileRead(*file, callback);
+}
+
 llvm::Error Trace::OnThreadBinaryDataRead(lldb::tid_t tid, llvm::StringRef kind,
                                           OnBinaryDataReadCallback callback) {
+  RefreshLiveProcessState();
   if (m_live_process)
     return OnLiveThreadBinaryDataRead(tid, kind, callback);
   else
     return OnPostMortemThreadBinaryDataRead(tid, kind, callback);
 }
+
+llvm::Error Trace::OnCoreBinaryDataRead(lldb::core_id_t core_id,
+                                        llvm::StringRef kind,
+                                        OnBinaryDataReadCallback callback) {
+  RefreshLiveProcessState();
+  if (m_live_process)
+    return OnLiveCoreBinaryDataRead(core_id, kind, callback);
+  else
+    return OnPostMortemCoreBinaryDataRead(core_id, kind, callback);
+}
+
+ArrayRef<lldb::core_id_t> Trace::GetTracedCores() {
+  RefreshLiveProcessState();
+  if (m_cores)
+    return *m_cores;
+  return {};
+}

lldb/source/Utility/TraceGDBRemotePackets.cpp

 }
 
 bool fromJSON(const json::Value &value, TraceGetStateResponse &packet,
               Path path) {
   ObjectMapper o(value, path);
   return o && o.map("tracedThreads", packet.traced_threads) &&
          o.map("processBinaryData", packet.process_binary_data) &&
          o.map("cores", packet.cores) &&
-         o.mapOptional("warnings", packet.warnings);
+         o.map("warnings", packet.warnings);
 }
 
 json::Value toJSON(const TraceGetStateResponse &packet) {
   return json::Value(Object{{"tracedThreads", packet.traced_threads},
                             {"processBinaryData", packet.process_binary_data},
                             {"cores", packet.cores},
                             {"warnings", packet.warnings}});
 }
 
+void TraceGetStateResponse::AddWarning(StringRef warning) {
+  if (!warnings)
+    warnings.emplace();
+  warnings->push_back(warning.data());
+}
+
 bool fromJSON(const json::Value &value, TraceCoreState &packet,
               json::Path path) {
   ObjectMapper o(value, path);
   int64_t core_id;
   if (!o || !o.map("coreId", core_id) ||
       !o.map("binaryData", packet.binary_data))
     return false;
   packet.core_id = static_cast<lldb::core_id_t>(core_id);
   return true;
 }
 
 json::Value toJSON(const TraceCoreState &packet) {
   return json::Value(
       Object{{"coreId", packet.core_id}, {"binaryData", packet.binary_data}});
 }
 /// \}
 
 /// jLLDBTraceGetBinaryData
 /// \{
 json::Value toJSON(const TraceGetBinaryDataRequest &packet) {
   return json::Value(Object{{"type", packet.type},
                             {"kind", packet.kind},
                             {"offset", packet.offset},
                             {"tid", packet.tid},
+                            {"coreId", packet.core_id},
                             {"size", packet.size}});
 }
 
 bool fromJSON(const json::Value &value, TraceGetBinaryDataRequest &packet,
               Path path) {
   ObjectMapper o(value, path);
   return o && o.map("type", packet.type) && o.map("kind", packet.kind) &&
          o.map("tid", packet.tid) && o.map("offset", packet.offset) &&
-         o.map("size", packet.size);
+         o.map("size", packet.size) && o.map("coreId", packet.core_id);
 }
 /// \}
 
 } // namespace lldb_private

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

std::chrono::nanoseconds LinuxPerfZeroTscConversion::ToNanos(uint64_t tsc) {
   uint64_t rem_flag = (((uint64_t)1 << time_shift) - 1);
   uint64_t rem = tsc & rem_flag;
   return std::chrono::nanoseconds{time_zero + quot * time_mult +
                                   ((rem * time_mult) >> time_shift)};
 }
 
 json::Value toJSON(const LinuxPerfZeroTscConversion &packet) {
   return json::Value(json::Object{
-      {"kind", "tscPerfZeroConversion"},
       {"timeMult", packet.time_mult},
       {"timeShift", packet.time_shift},
       {"timeZero", packet.time_zero},
   });
 }
 
 bool fromJSON(const json::Value &value, LinuxPerfZeroTscConversion &packet,
               json::Path path) {

lldb/test/API/commands/trace/TestTraceLoad.py

Errors:
     def testLoadInvalidTraces(self):
         src_dir = self.getSourceDir()
         # We test first an invalid type
         self.expect("trace load -v " + os.path.join(src_dir, "intelpt-trace", "trace_bad.json"), error=True,
           substrs=['''error: expected object at traceSession.processes[0]
 
 Context:
 {
+  "cpuInfo": { ... },
   "processes": [
     /* error: expected object */
     123
   ],
-  "trace": { ... }
+  "type": "intel-pt"
 }
 
 Schema:
 {
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel" | "unknown",
-      "family": integer,
-      "model": integer,
-      "stepping": integer
-    }
+    // CPU information gotten from, for example, /proc/cpuinfo.
+
+    "vendor": "GenuineIntel" | "unknown",
   },'''])
 
         # Now we test a missing field in the global session file
         self.expect("trace load -v " + os.path.join(src_dir, "intelpt-trace", "trace_bad2.json"), error=True,
             substrs=['error: missing value at traceSession.processes[1].triple', "Context", "Schema"])
 
         # Now we test a missing field in the intel-pt settings
         self.expect("trace load -v " + os.path.join(src_dir, "intelpt-trace", "trace_bad4.json"), error=True,
-            substrs=['''error: missing value at traceSession.trace.cpuInfo.family
+            substrs=['''error: missing value at traceSession.cpuInfo.family
 
 Context:
 {
-  "processes": [],
-  "trace": {
-    "cpuInfo": /* error: missing value */ {
-      "model": 79,
-      "stepping": 1,
-      "vendor": "intel"
-    },
-    "type": "intel-pt"
-  }
+    "vendor": "GenuineIntel"
+  "processes": [],
 }''', "Schema"])
 
         # Now we test an incorrect load address in the intel-pt settings
         self.expect("trace load -v " + os.path.join(src_dir, "intelpt-trace", "trace_bad5.json"), error=True,
-            substrs=['error: expected numeric string at traceSession.processes[0].modules[0].loadAddress',
-                     '"loadAddress": /* error: expected numeric string */ 400000,', "Schema"])
+            substrs=['error: missing value at traceSession.processes[1].pid', "Schema"])
 
         # The following wrong schema will have a valid target and an invalid one. In the case of failure,
         # no targets should be created.
         self.assertEqual(self.dbg.GetNumTargets(), 0)
         self.expect("trace load -v " + os.path.join(src_dir, "intelpt-trace", "trace_bad3.json"), error=True,
             substrs=['error: missing value at traceSession.processes[1].pid'])
         self.assertEqual(self.dbg.GetNumTargets(), 0)

lldb/test/API/commands/trace/TestTraceSave.py

 import lldb
+import json
 from intelpt_testcase import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 from lldbsuite.test.decorators import *
 
+def find(predicate, seq):
+  for item in seq:
+    if predicate(item):
+      return item
+
 class TestTraceSave(TraceIntelPTTestCaseBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def testErrorMessages(self):
         # We first check the output when there are no targets
         self.expect("process trace save",
             substrs=["error: invalid target, create a target using the 'target create' command"],
             error=True)
class TestTraceSave(TraceIntelPTTestCaseBase):
 
     def testSaveWhenNotLiveTrace(self):
         self.expect("trace load -v " +
             os.path.join(self.getSourceDir(), "intelpt-trace", "trace.json"),
             substrs=["intel-pt"])
 
         # Check the output when not doing live tracing
         self.expect("process trace save -d " +
-            os.path.join(self.getBuildDir(), "intelpt-trace", "trace_not_live_dir"),
-            substrs=["error: Saving a trace requires a live process."],
-            error=True)
+            os.path.join(self.getBuildDir(), "intelpt-trace", "trace_not_live_dir"))
+
+    def testSaveMultiCoreTrace(self):
+        '''
+            This test starts a per-core tracing session, then saves the session to disk, and
+            finally it loads it again.
+        '''
+        self.skipIfPerCoreTracingIsNotSupported()
+
+        self.expect("target create " +
+            os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
+        self.expect("b main")
+        self.expect("r")
+        self.expect("process trace start --per-core-tracing")
+        self.expect("b 7")
+
+        output_dir = os.path.join(self.getBuildDir(), "intelpt-trace", "trace_save")
+        self.expect("process trace save -d " + output_dir)
 
+        def checkSessionBundle(session_file_path):
+            with open(session_file_path) as session_file:
+                session = json.load(session_file)
+                # We expect tsc conversion info
+                self.assertTrue("tscPerfZeroConversion" in session)
+                # We expect at least one core
+                self.assertGreater(len(session["cores"]), 0)
+
+                # We expect the required trace files to be created
+                for core in session["cores"]:
+                    core_files_prefix = os.path.join(output_dir, "cores", str(core["coreId"]))
+                    self.assertTrue(os.path.exists(core_files_prefix + ".intelpt_trace"))
+                    self.assertTrue(os.path.exists(core_files_prefix + ".perf_context_switch_trace"))
+
+                # We expect at least one one process
+                self.assertGreater(len(session["processes"]), 0)
+                for process in session["processes"]:
+                    # We expect at least one thread
+                    self.assertGreater(len(process["threads"]), 0)
+                    # We don't expect thread traces
+                    for thread in process["threads"]:
+                        self.assertTrue(("traceBuffer" not in thread) or (thread["traceBuffer"] is None))
+
+        original_trace_session_file = os.path.join(output_dir, "trace.json")
+        checkSessionBundle(original_trace_session_file)
+
+        output_dir = os.path.join(self.getBuildDir(), "intelpt-trace", "trace_save")
+        self.expect("trace load " + os.path.join(output_dir, "trace.json"))
+        output_copy_dir = os.path.join(self.getBuildDir(), "intelpt-trace", "copy_trace_save")
+        self.expect("process trace save -d " + output_copy_dir)
+
+        # We now check that the new bundle is correct on its own
+        copied_trace_session_file = os.path.join(output_copy_dir, "trace.json")
+        checkSessionBundle(copied_trace_session_file)
+
+        # We finally check that the new bundle has the same information as the original one
+        with open(original_trace_session_file) as original_file:
+            original = json.load(original_file)
+            with open(copied_trace_session_file) as copy_file:
+                copy = json.load(copy_file)
+
+                self.assertEqual(len(original["processes"]), len(copy["processes"]))
+
+                for process in original["processes"]:
+                    copied_process = find(lambda proc : proc["pid"] == process["pid"], copy["processes"])
+                    self.assertTrue(copied_process is not None)
+
+                    for thread in process["threads"]:
+                        copied_thread = find(lambda thr : thr["tid"] == thread["tid"], copied_process["threads"])
+                        self.assertTrue(copied_thread is not None)
+
+                for core in original["cores"]:
+                    copied_core = find(lambda cor : cor["coreId"] == core["coreId"], copy["cores"])
+                    self.assertTrue(copied_core is not None)
 
     def testSaveTrace(self):
         self.expect("target create " +
             os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
         self.expect("b main")
         self.expect("r")
         self.expect("thread trace start")
         self.expect("b 7")

lldb/test/API/commands/trace/TestTraceSchema.py

 import lldb
 from intelpt_testcase import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 from lldbsuite.test.decorators import *
 
 class TestTraceLoad(TraceIntelPTTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def testSchema(self):
-        self.expect("trace schema intel-pt", substrs=["trace", "triple", "threads", "traceFile"])
+        self.expect("trace schema intel-pt", substrs=["triple", "threads", "traceBuffer"])
 
     def testInvalidPluginSchema(self):
         self.expect("trace schema invalid-plugin", error=True,
             substrs=['error: no trace plug-in matches the specified type: "invalid-plugin"'])
 
     def testAllSchemas(self):
         self.expect("trace schema all", substrs=['''{
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel" | "unknown",
-      "family": integer,
-      "model": integer,
-      "stepping": integer
-    }
+    // CPU information gotten from, for example, /proc/cpuinfo.
+
+    "vendor": "GenuineIntel" | "unknown",
   },'''])

lldb/test/API/commands/trace/intelpt-trace-multi-file/multi-file-no-ld.json

 {
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel",
-      "family": 6,
-      "model": 79,
-      "stepping": 1
-    }
+    "vendor": "GenuineIntel",
   },
   "processes": [
     {
       "pid": 815455,
       "triple": "x86_64-*-linux",
       "threads": [
         {
           "tid": 815455,
-          "traceFile": "multi-file.trace"
+          "traceBuffer": "multi-file.trace"
         }
       ],
       "modules": [
         {
           "file": "a.out",
           "systemPath": "a.out",
-          "loadAddress": "0x0000000000400000",
+          "loadAddress": 4194304,
           "uuid": "D2414468-7112-B7C5-408D-FF07E30D5B17-A5BFD2C4"
         },
         {
           "file": "libfoo.so",
           "systemPath": "libfoo.so",
-          "loadAddress": "0x00007ffff7bd9000",
+          "loadAddress": 140737349783552,
           "uuid": "B30FFEDA-8BB2-3D08-4580-C5937ED11E2B-21BE778C"
         },
         {
           "file": "libbar.so",
           "systemPath": "libbar.so",
-          "loadAddress": "0x00007ffff79d7000",
+          "loadAddress": 140737347678208,
           "uuid": "6633B038-EA73-D1A6-FF9A-7D0C0EDF733D-95FEA2CC"
         }
       ]
     }
   ]
 }

lldb/test/API/commands/trace/intelpt-trace/trace.json

 {
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel",
-      "family": 6,
-      "model": 79,
-      "stepping": 1
-    }
+    "vendor": "GenuineIntel",
   },
   "processes": [
     {
       "pid": 1234,
       "triple": "x86_64-*-linux",
       "threads": [
         {
           "tid": 3842849,
-          "traceFile": "3842849.trace"
+          "traceBuffer": "3842849.trace"
         }
       ],
       "modules": [
         {
           "file": "a.out",
           "systemPath": "a.out",
-          "loadAddress": "0x0000000000400000",
+          "loadAddress": 4194304,
           "uuid": "6AA9A4E2-6F28-2F33-377D-59FECE874C71-5B41261A"
         }
       ]
     }
   ]
 }

lldb/test/API/commands/trace/intelpt-trace/trace_2threads.json

 {
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel",
-      "family": 6,
-      "model": 79,
-      "stepping": 1
-    }
+    "vendor": "GenuineIntel",
   },
   "processes": [
     {
       "pid": 1234,
       "triple": "x86_64-*-linux",
       "threads": [
         {
           "tid": 3842849,
-          "traceFile": "3842849.trace"
+          "traceBuffer": "3842849.trace"
         },
         {
           "tid": 3842850,
-          "traceFile": "3842849.trace"
+          "traceBuffer": "3842849.trace"
         }
       ],
       "modules": [
         {
           "file": "a.out",
           "systemPath": "a.out",
-          "loadAddress": "0x0000000000400000",
+          "loadAddress": 4194304,
           "uuid": "6AA9A4E2-6F28-2F33-377D-59FECE874C71-5B41261A"
         }
       ]
     }
   ]
 }

lldb/test/API/commands/trace/intelpt-trace/trace_bad.json

 {
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel",
-      "family": 6,
-      "model": 79,
-      "stepping": 1
-    }
+    "vendor": "GenuineIntel",
   },
   "processes": [
     123
   ]
 }

lldb/test/API/commands/trace/intelpt-trace/trace_bad2.json

 {
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel",
-      "family": 6,
-      "model": 79,
-      "stepping": 1
-    }
+    "vendor": "GenuineIntel",
   },
   "processes": [
     {
       "pid": 1234,
       "triple": "x86_64-*-linux",
       "threads": [
         {
           "tid": 5678,
-          "traceFile": "3842849.trace"
+          "traceBuffer": "3842849.trace"
         }
       ],
       "modules": [
         {
           "file": "a.out",
           "systemPath": "a.out",
-          "loadAddress": "0x0000000000400000",
+          "loadAddress": 4194304,
           "uuid": "6AA9A4E2-6F28-2F33-377D-59FECE874C71-5B41261A"
         }
       ]
     },
     {
       "pid": 12345,
       "threads": [
         {
           "tid": 56789,
-          "traceFile": "3842849.trace"
+          "traceBuffer": "3842849.trace"
         }
       ],
       "modules": []
     }
   ]
 }

lldb/test/API/commands/trace/intelpt-trace/trace_bad3.json

 {
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel",
-      "family": 6,
-      "model": 79,
-      "stepping": 1
-    }
+    "vendor": "GenuineIntel",
   },
   "processes": [
     {
       "pid": 1234,
       "triple": "x86_64-*-linux",
       "threads": [
         {
           "tid": 5678,
-          "traceFile": "3842849.trace"
+          "traceBuffer": "3842849.trace"
         }
       ],
       "modules": [
         {
           "file": "a.out",
           "systemPath": "a.out",
-          "loadAddress": "0x0000000000400000",
+          "loadAddress": 4194304,
           "uuid": "6AA9A4E2-6F28-2F33-377D-59FECE874C71-5B41261A"
         }
       ]
     },
     {}
   ]
 }

lldb/test/API/commands/trace/intelpt-trace/trace_bad4.json

 {
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel",
-      "model": 79,
-      "stepping": 1
-    }
+    "vendor": "GenuineIntel",
   },
   "processes": [
   ]
 }

lldb/test/API/commands/trace/intelpt-trace/trace_bad5.json

 {
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel",
-      "family": 6,
-      "model": 79,
-      "stepping": 1
-    }
+    "vendor": "GenuineIntel",
   },
   "processes": [
     {
       "pid": 1234,
       "triple": "x86_64-*-linux",
       "threads": [
         {
           "tid": 5678,
-          "traceFile": "3842849.trace"
+          "traceBuffer": "3842849.trace"
         }
       ],
       "modules": [
         {
           "file": "a.out",
           "systemPath": "a.out",
           "loadAddress": 400000,
           "uuid": "6AA9A4E2-6F28-2F33-377D-59FECE874C71-5B41261A"
         }
       ]
     },
     {}
   ]
 }

lldb/test/API/commands/trace/intelpt-trace/trace_bad_image.json

 {
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel",
-      "family": 6,
-      "model": 79,
-      "stepping": 1
-    }
+    "vendor": "GenuineIntel",
   },
   "processes": [
     {
       "pid": 1234,
       "triple": "x86_64-*-linux",
       "threads": [
         {
           "tid": 3842849,
-          "traceFile": "3842849.trace"
+          "traceBuffer": "3842849.trace"
         }
       ],
       "modules": [
         {
           "file": "a.out",
           "systemPath": "a.out",
-          "loadAddress": "0x0000000000FFFFF0",
+          "loadAddress": 16777200,
           "uuid": "6AA9A4E2-6F28-2F33-377D-59FECE874C71-5B41261A"
         }
       ]
     }
   ]
 }

lldb/test/API/commands/trace/intelpt-trace/trace_wrong_cpu.json

 {
-  "trace": {
-    "type": "intel-pt",
-    "cpuInfo": {
-      "vendor": "intel",
-      "family": 2123123,
-      "model": 12123123,
-      "stepping": 1231231
-    }
+    "vendor": "GenuineIntel",
   },
   "processes": [
     {
       "pid": 1234,
       "triple": "x86_64-*-linux",
       "threads": [
         {
           "tid": 3842849,
-          "traceFile": "3842849.trace"
+          "traceBuffer": "3842849.trace"
         }
       ],
       "modules": [
         {
           "file": "a.out",
           "systemPath": "a.out",
-          "loadAddress": "0x0000000000400000",
+          "loadAddress": 4194304,
           "uuid": "6AA9A4E2-6F28-2F33-377D-59FECE874C71-5B41261A"
         }
       ]
     }
   ]
 }

lldb/unittests/Process/Linux/PerfTests.cpp

 //===-- PerfTests.cpp -----------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifdef __x86_64__
-
 #include "Perf.h"
 
 #include "llvm/Support/Error.h"
 
 #include "gtest/gtest.h"
 
 #include <chrono>
 #include <cstdint>
std::chrono::nanoseconds converted_tsc_diff =
       params->ToNanos(*tsc_after_sleep) - params->ToNanos(*tsc_before_sleep);
 
   std::chrono::microseconds acceptable_overhead(500);
 
   ASSERT_GE(converted_tsc_diff.count(), SLEEP_NANOS.count());
   ASSERT_LT(converted_tsc_diff.count(),
             (SLEEP_NANOS + acceptable_overhead).count());
 }
-
-size_t ReadCylicBufferWrapper(void *buf, size_t buf_size, void *cyc_buf,
-                              size_t cyc_buf_size, size_t cyc_start,
-                              size_t offset) {
-  llvm::MutableArrayRef<uint8_t> dst(reinterpret_cast<uint8_t *>(buf),
-                                     buf_size);
-  llvm::ArrayRef<uint8_t> src(reinterpret_cast<uint8_t *>(cyc_buf),
-                              cyc_buf_size);
-  ReadCyclicBuffer(dst, src, cyc_start, offset);
-  return dst.size();
-}
-
-TEST(CyclicBuffer, EdgeCases) {
-  size_t bytes_read;
-  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
-
-  // We will always leave the last bytes untouched
-  // so that string comparisons work.
-  char smaller_buffer[4] = {};
-
-  // empty buffer to read into
-  bytes_read = ReadCylicBufferWrapper(smaller_buffer, 0, cyclic_buffer,
-                                      sizeof(cyclic_buffer), 3, 0);
-  ASSERT_EQ(0u, bytes_read);
-
-  // empty cyclic buffer
-  bytes_read = ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
-                                      cyclic_buffer, 0, 3, 0);
-  ASSERT_EQ(0u, bytes_read);
-
-  // bigger offset
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 6);
-  ASSERT_EQ(0u, bytes_read);
-
-  // wrong offset
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 7);
-  ASSERT_EQ(0u, bytes_read);
-
-  // wrong start
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 7);
-  ASSERT_EQ(0u, bytes_read);
-}
-
-TEST(CyclicBuffer, EqualSizeBuffer) {
-  size_t bytes_read = 0;
-  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
-
-  char cyclic[] = "cyclic";
-  for (size_t i = 0; i < sizeof(cyclic); i++) {
-    // We will always leave the last bytes untouched
-    // so that string comparisons work.
-    char equal_size_buffer[7] = {};
-    bytes_read =
-        ReadCylicBufferWrapper(equal_size_buffer, sizeof(cyclic_buffer),
-                               cyclic_buffer, sizeof(cyclic_buffer), 3, i);
-    ASSERT_EQ((sizeof(cyclic) - i - 1), bytes_read);
-    ASSERT_STREQ(equal_size_buffer, (cyclic + i));
-  }
-}
-
-TEST(CyclicBuffer, SmallerSizeBuffer) {
-  size_t bytes_read;
-  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
-
-  // We will always leave the last bytes untouched
-  // so that string comparisons work.
-  char smaller_buffer[4] = {};
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 0);
-  ASSERT_EQ(3u, bytes_read);
-  ASSERT_STREQ(smaller_buffer, "cyc");
-
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 1);
-  ASSERT_EQ(3u, bytes_read);
-  ASSERT_STREQ(smaller_buffer, "ycl");
-
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 2);
-  ASSERT_EQ(3u, bytes_read);
-  ASSERT_STREQ(smaller_buffer, "cli");
-
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 3);
-  ASSERT_EQ(3u, bytes_read);
-  ASSERT_STREQ(smaller_buffer, "lic");
-
-  {
-    char smaller_buffer[4] = {};
-    bytes_read =
-        ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                               cyclic_buffer, sizeof(cyclic_buffer), 3, 4);
-    ASSERT_EQ(2u, bytes_read);
-    ASSERT_STREQ(smaller_buffer, "ic");
-  }
-  {
-    char smaller_buffer[4] = {};
-    bytes_read =
-        ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                               cyclic_buffer, sizeof(cyclic_buffer), 3, 5);
-    ASSERT_EQ(1u, bytes_read);
-    ASSERT_STREQ(smaller_buffer, "c");
-  }
-}
-
-TEST(CyclicBuffer, BiggerSizeBuffer) {
-  size_t bytes_read = 0;
-  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
-
-  char cyclic[] = "cyclic";
-  for (size_t i = 0; i < sizeof(cyclic); i++) {
-    // We will always leave the last bytes untouched
-    // so that string comparisons work.
-    char bigger_buffer[10] = {};
-    bytes_read =
-        ReadCylicBufferWrapper(bigger_buffer, (sizeof(bigger_buffer) - 1),
-                               cyclic_buffer, sizeof(cyclic_buffer), 3, i);
-    ASSERT_EQ((sizeof(cyclic) - i - 1), bytes_read);
-    ASSERT_STREQ(bigger_buffer, (cyclic + i));
-  }
-}
-
-#endif // __x86_64__

lldb/unittests/Utility/TraceGDBRemotePacketsTest.cpp

TEST(TraceGDBRemotePacketsTest, IntelPTGetStateResponse) {
   uint32_t test_time_mult = 1076264588;
   uint16_t test_time_shift = 31;
   // Intentionally set time_zero value out of the signed type's range.
   uint64_t test_time_zero =
       static_cast<uint64_t>(std::numeric_limits<int64_t>::max()) + 1;
 
   // Create TraceIntelPTGetStateResponse.
   TraceIntelPTGetStateResponse response;
-  response.tsc_conversion = std::make_unique<LinuxPerfZeroTscConversion>(
-      test_time_mult, test_time_shift, test_time_zero);
+  response.tsc_perf_zero_conversion = LinuxPerfZeroTscConversion{test_time_mult, test_time_shift, test_time_zero};
 
   // Serialize then deserialize.
   Expected<TraceIntelPTGetStateResponse> deserialized_response =
       json::parse<TraceIntelPTGetStateResponse>(
           llvm::formatv("{0}", toJSON(response)).str(),
           "TraceIntelPTGetStateResponse");
   if (!deserialized_response)
     FAIL() << toString(deserialized_response.takeError());
 
   // Choose arbitrary TSC value to test the Convert function.
   const uint64_t TSC = std::numeric_limits<uint32_t>::max();
   // Expected nanosecond value pre calculated using the TSC to wall time
   // conversion formula located in the time_zero section of
   // https://man7.org/linux/man-pages/man2/perf_event_open.2.html
   const uint64_t EXPECTED_NANOS = 9223372039007304983u;
 
   uint64_t pre_serialization_conversion =
-      response.tsc_conversion->Convert(TSC).count();
+      response.tsc_perf_zero_conversion->ToNanos(TSC).count();
   uint64_t post_serialization_conversion =
-      deserialized_response->tsc_conversion->Convert(TSC).count();
+      deserialized_response->tsc_perf_zero_conversion->ToNanos(TSC).count();
 
   // Check equality:
   // Ensure that both the TraceGetStateResponse and TraceIntelPTGetStateResponse
   // portions of the JSON representation are unchanged.
   ASSERT_EQ(toJSON(response), toJSON(*deserialized_response));
   // Ensure the result of the Convert function is unchanged.
   ASSERT_EQ(EXPECTED_NANOS, pre_serialization_conversion);
   ASSERT_EQ(EXPECTED_NANOS, post_serialization_conversion);
TEST(TraceGDBRemotePacketsTest, IntelPTGetStateResponseEmpty) {
   if (!deserialized_response)
     FAIL() << toString(deserialized_response.takeError());
 
   // Check equality:
   // Ensure that both the TraceGetStateResponse and TraceIntelPTGetStateResponse
   // portions of the JSON representation are unchanged.
   ASSERT_EQ(toJSON(response), toJSON(*deserialized_response));
   // Ensure that the tsc_conversion's are nullptr.
-  ASSERT_EQ(response.tsc_conversion.get(), nullptr);
-  ASSERT_EQ(response.tsc_conversion.get(),
-            deserialized_response->tsc_conversion.get());
+  ASSERT_EQ(response.tsc_perf_zero_conversion, None);
+  ASSERT_EQ(response.tsc_perf_zero_conversion,
+            deserialized_response->tsc_perf_zero_conversion);
 }