[trace][intel-pt] Implement trace start and trace stop

[wallace]

Summary

This implements the interactive trace start and stop methods.

This diff ended up being much larger than I anticipated because, by doing it, I found that I had implemented in the beginning many things in a non optimal way. In any case, the code is much better now.

There's a lot of boilerplate code due to the gdb-remote protocol, but the main changes are:

• New tracing packets: jLLDBTraceStop, jLLDBTraceStart, jLLDBTraceGetBinaryData. The gdb-remote packet definitions are quite comprehensive.
• Implementation of the "process trace start|stop" and "thread trace start|stop" commands.
• Implementation of an API in Trace.h to interact with live traces.
• Created an IntelPTDecoder for live threads, that use the debugger's stop id as checkpoint for its internal cache.
• Added a functionality to stop the process in case "process tracing" is enabled and a new thread can't traced.
• Reworked how traces are manager in lldb-server, including the removal of the old Intel code
• Renamed a bunch of things for consistency and better naming
• Added tests

I have some ideas to unify the code paths for post mortem and live threads, but I'll do that in another diff.

Example flow for a single threaded process:

(lldb) file /home/wallace/llvm-sand/external/llvm-project/lldb/test/API/commands/trace/intelpt-trace/a.out                                                                                                                                                    Current executable set to '/home/wallace/llvm-sand/external/llvm-project/lldb/test/API/commands/trace/intelpt-trace/a.out' (x86_64).
(lldb) b main
Breakpoint 1: where = a.out`main + 4 at main.cpp:2, address = 0x0000000000400511
(lldb) r
Process 1563054 launched: '/home/wallace/llvm-sand/external/llvm-project/lldb/test/API/commands/trace/intelpt-trace/a.out' (x86_64)
Process 1563054 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x0000000000400511 a.out`main at main.cpp:2
   1    int main() {
-> 2      int ret = 0;
   3   
   4      for (int i = 0; i < 4; i++)
   5        ret ^= 1;
   6   
   7      return ret;
(lldb) thread trace start
(lldb) b 7
Breakpoint 2: where = a.out`main + 34 at main.cpp:7, address = 0x000000000040052f
(lldb) c
Process 1563054 resuming
Process 1563054 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 2.1
    frame #0: 0x000000000040052f a.out`main at main.cpp:7
   4      for (int i = 0; i < 4; i++)
   5        ret ^= 1;
   6   
-> 7      return ret;
   8    }
(lldb) thread trace dump instructions 
thread #1: tid = 1563054, total instructions = 21
  a.out`main + 11 at main.cpp:4
    [ 1] 0x0000000000400518    movl   $0x0, -0x8(%rbp)
    [ 2] 0x000000000040051f    jmp    0x400529                  ; <+28> at main.cpp:4
  a.out`main + 28 at main.cpp:4
    [ 3] 0x0000000000400529    cmpl   $0x3, -0x8(%rbp)
    [ 4] 0x000000000040052d    jle    0x400521                  ; <+20> at main.cpp:5
 ...
  a.out`main + 28 at main.cpp:4
    [19] 0x0000000000400529    cmpl   $0x3, -0x8(%rbp)
    [20] 0x000000000040052d    jle    0x400521                  ; <+20> at main.cpp:5

Example flow for a multi-threaded process with "all" tracing:

(lldb) file ~/llvm-sand/build/Release/Linux-x86_64/llvm/lldb-test-build.noindex/commands/trace/multiple-threads/TestTraceStartStopMultipleThreads.testStartMultipleLiveThreadsWithAllStops/a.out
Current executable set to '/home/wallace/llvm-sand/build/Release/Linux-x86_64/llvm/lldb-test-build.noindex/commands/trace/multiple-threads/TestTraceStartStopMultipleThreads.testStartMultipleLiveThreadsWithAllStops/a.out' (x86_64).
(lldb) b main
Breakpoint 1: where = a.out`main + 15 at main.cpp:17:15, address = 0x0000000000400a6f
(lldb) b 6
Breakpoint 2: where = a.out`f3() + 4 at main.cpp:6:5, address = 0x00000000004009f4
(lldb) b 11
Breakpoint 3: where = a.out`f2() + 8 at main.cpp:11:5, address = 0x0000000000400a08
(lldb) r
Process 4030831 launched: '/home/wallace/llvm-sand/build/Release/Linux-x86_64/llvm/lldb-test-build.noindex/commands/trace/multiple-threads/TestTraceStartStopMultipleThreads.testStartMultipleLiveThreadsWithAllStops/a.out' (x86_64)
Process 4030831 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x0000000000400a6f a.out`main at main.cpp:17:15
   14   }
   15  
   16   int main() { // main
-> 17     std::thread t2(f2);
   18     t2.join();
   19     return 0;
   20   }
(lldb) process trace start
(lldb) c
Process 4030831 resuming
Process 4030831 stopped
* thread #2, name = 'a.out', stop reason = breakpoint 3.1
    frame #0: 0x0000000000400a08 a.out`f2() at main.cpp:11:5
   8   
   9    void f2() {
   10     int n;
-> 11     n = 1; // thread 2
   12     std::thread t3(f3);
   13     t3.join();
   14   }
(lldb) thread trace dump instructions -c 5
thread #2: tid = 4032721, total instructions = 211
  a.out`void (*&&std::forward<void (*)()>(std::remove_reference<void (*)()>::type&))() + 13 at move.h:75:7
    [206] 0x0000000000400f5d    retq   
  a.out`void std::__invoke_impl<void, void (*)()>(std::__invoke_other, void (*&&)()) + 21 at invoke.h:60:14
    [207] 0x00000000004010b5    callq  *(%rax)
  a.out`f2() at main.cpp:9
    [208] 0x0000000000400a00    pushq  %rbp
    [209] 0x0000000000400a01    movq   %rsp, %rbp
    [210] 0x0000000000400a04    subq   $0x30, %rsp
(lldb) c
Process 4030831 resuming
Process 4030831 stopped
* thread #3, name = 'a.out', stop reason = breakpoint 2.1
    frame #0: 0x00000000004009f4 a.out`f3() at main.cpp:6:5
   3   
   4    void f3() {
   5      int m;
-> 6      m = 2; // thread 3
   7    }
   8   
   9    void f2() {
(lldb) thread trace dump instructions -c 5
thread #3: tid = 4034431, total instructions = 210
  a.out`void (*&&std::forward<void (*)()>(std::remove_reference<void (*)()>::type&))() + 12 at move.h:75:7
    [205] 0x0000000000400f5c    popq   %rbp
    [206] 0x0000000000400f5d    retq   
  a.out`void std::__invoke_impl<void, void (*)()>(std::__invoke_other, void (*&&)()) + 21 at invoke.h:60:14
    [207] 0x00000000004010b5    callq  *(%rax)
  a.out`f3() at main.cpp:4
    [208] 0x00000000004009f0    pushq  %rbp
    [209] 0x00000000004009f1    movq   %rsp, %rbp

Example flow for a simple crash and its trace dump:

(lldb) file /tmp/test/a.out 
Current executable set to '/tmp/test/a.out' (x86_64).
(lldb) b main
Breakpoint 1: where = a.out`main + 8 at main.cpp:6, address = 0x0000000000400845
(lldb) r
Process 4121521 launched: '/tmp/test/a.out' (x86_64)
Process 4121521 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x0000000000400845 a.out`main at main.cpp:6
   3   
   4    int main() {
   5      int x;
-> 6      cin >> x;
   7      cout << 12 / x << endl;
   8      return 0;
   9    }
(lldb) process trace start
(lldb) c
Process 4121521 resuming
0
Process 4121521 stopped
* thread #1, name = 'a.out', stop reason = signal SIGFPE: integer divide by zero
    frame #0: 0x000000000040085f a.out`main at main.cpp:7
   4    int main() {
   5      int x;
   6      cin >> x;
-> 7      cout << 12 / x << endl;
   8      return 0;
   9    }
   10     
(lldb) thread trace dump instructions -c 5                                                                                                                                           thread #1: tid = 4121521, total instructions = 8704
  libstdc++.so.6`std::istream::operator>>(int&) + 185
    [8699] 0x00007ffff7b52ce9    popq   %rbp
    [8700] 0x00007ffff7b52cea    retq   
  a.out`main + 25 at main.cpp:7
    [8701] 0x0000000000400856    movl   -0x4(%rbp), %ecx
    [8702] 0x0000000000400859    movl   $0xc, %eax
    [8703] 0x000000000040085e    cltd

Example of a failure due to insufficient process buffer

(lldb) b main
Breakpoint 1: where = a.out`main + 15 at main.cpp:17:15, address = 0x0000000000400a6f
(lldb) r
Process 2098567 launched: '/home/wallace/llvm-sand/build/Debug/fbcode-x86_64/llvm/lldb-test-build.noindex/commands/trace/multiple-threads/TestTraceStartStopMultipleThreads.testStartMultipleLiveThreadsWithAllStops/a.out' (x86_64)
Process 2098567 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x0000000000400a6f a.out`main at main.cpp:17:15
   14   }
   15  
   16   int main() { // main
-> 17     std::thread t2(f2);
   18     t2.join();
   19     return 0;
   20   }
(lldb) process trace start -l 5000                                                                                                            (lldb) c
Process 2098567 resuming
Process 2098567 stopped
* thread #2, name = 'a.out', stop reason = Thread 2099442 can't be traced as the process trace size limit has been reached. Consider retracing with a higher limit.
    frame #0: 0x00007ffff70cf931 libc.so.6`__clone + 49
libc.so.6`__clone:
->  0x7ffff70cf931 <+49>: testq  %rax, %rax
    0x7ffff70cf934 <+52>: jl     0x7ffff70cf975            ; <+0>
    0x7ffff70cf936 <+54>: je     0x7ffff70cf939            ; <+57>
    0x7ffff70cf938 <+56>: retq

[clayborg]

So I think I get the gist of what you were trying to go for with this patch. I stopped inline comments after I got the idea.

A few things:

We need to be able to enable tracing on all threads for a process and have lldb-server just "do the right thing" and enable tracing for all threads as they get created. If we have to stop the process each time a thread is created just to give LLDB the chance to enable tracing for that thread, this will be too slow and cumbersome. The ptrace implementation for unix already has to attach to each thread as it comes along by running some code in the NativeProcessProtocol subclass, so we should be able to start tracing any and all threads as needed.

NativeProcessProtocol should have generic plug-in like functions for starting and stopping tracing that each subclass will override. See inlined comments.

See inlined comments about the jLLDB packets and let me know what you think.

lldb/docs/lldb-gdb-remote.txt

277

Do we need "type" here? Only one kind of trace is currently returned by jLLDBTraceSupportedType right now. I am ok with passing it down again in case we change to returning a list from jLLDBTraceSupportedType.

278

Do we want this as optional? What if we want to trace all threads? I would be a real pain if we always have to detect new threads showing up and then sending a jLLDBTraceStart as this will really slow down the process for no good reason. So it would be nice if we can specify this as optional and if the "tid" is not specified, have the lldb-server start tracing any new threads as they come along.

308

Do we need "type" here just like in jLLDBTraceStart?

309

Is this optional? Want if we want to stop tracing all threads?

324–333

Would it be better for this command to just return all the data we need? Maybe a single packet like:

jLLDBTraceGetInfo

And it would return JSON that includes all available data like:

{
  "vendor": "intel" | "unknown",
  "family": <decimal>,
  "model": <decimal>,
  "stepping": <decimal>,
  "tids": [
    {
      "tid": <decimal>,
      "dataSize": <decimal>, // Size of all trace data for this thread in case it is huge, so we can download parts of it?
    }
  ]
 }

Then we have another packet to fetch the data for each thread with a packet like "jLLDBTraceGetData" whose schema for input would be "tid" and "offset" and "size". This would allow us to fetch partial data in case we need to interrupt the fetching since this data can be bigger. The return value for this function would be just like the "binary memory read" where the bytes are much more efficiently encoded as binary and not as HEX8 format.

lldb/include/lldb/Core/PluginManager.h

336–337

Why do we need these callbacks? Can we just keep the "TraceCreateInstance create_callback" and then add virtual functions to the API in Trace.h?

lldb/include/lldb/Host/common/NativeProcessProtocol.h

320

Shouldn't this be generic so it can work with any NativeProcessProtocol implementation? Think about doing this same stuff on ARM. We don't want to have functions in NativeProcessProtocol like "StopIntelPTrace" and "StopARMTrace" and "StopARM64Trace" that are all stubbed out. It would be better to have something generic that passes along structured data to each function where the type of the trace is specified in the structured data.

341

Ditto above comment about making this generic.

lldb/include/lldb/Target/Process.h

2578

Should this be named "StartTracing" in case the options don't specify a thread ID?

2594

Seems like this should be named "StopTracing" and also take "const llvm::json::Value &options" kist ;oile the StartTracing call above so we can disable a single thread or all of them?

lldb/include/lldb/Target/Trace.h

239

Shouldn't TParams just be JSON?

[wallace]

Address comments. See the updated diff description for the updates.

[wallace]

nit

[wallace]

rebase and fix compile error on Darwin

[wallace]

clang-format

[clayborg]

The start and stop operations have 3 variants for now:

• specificThreads: operate on specific threads (e.g. thread trace start 2 3 9)
• currentAndFutureThreads: operate of all threads including future ones (e.g. thread trace start all)
• process: operate on a process as a single trace instance, instead of operating on each thread. Not supported, but left there to make the code more generic. Eventually I'll have to implement this anyway. (e.g. maybe? process trace start)

So how does "currentAndFutureThreads" differ from "process"?

It might be better to have "thread trace start" be able to specify one or more threads (but not all), and use "process trace start" to enable tracing for all threads in this patch?

lldb/docs/lldb-gdb-remote.txt

279

Seems like we don't need the "variant" here. If we have "tids" then we are enabling tracing for only that list of threads, and if it is missing, then we enable it for all threads.

See my questions in the non-inlined comment section about the "process" variant.

299–300

still unclear what this means. If we don't have it implemented, then we should probably leave it out for now.

311

Is this the trace buffer size that will be used for each thread? For all threads? Is this size divided up between the threads? What happens when new threads get created? Can we run out of memory in the kernel if a process creates too many threads if this buffer is for each thread? Need clarification on what this number means.

312

Any more details on what this is? Number? string? Why is it needed and what does it control/do?

341

Same comment as above. Why do we need the variant? If there is a "tids" then we do only those threads, else we do all threads in a process?

404

Are these custom for each plug-in? Any details on what intel-pt can specify here? You supplied intel PT specific info for other settings above in the docs.

lldb/include/lldb/Target/Trace.h

149

Why was "const" remove from the "Thread" here?

203

Why no const?

lldb/include/lldb/Utility/TraceOptions.h

73–76

move to TraceIntelPT.h/.cpp files. We don't want each plug-in added their definitions in this global TraceOptions.h file

104–117

move to TraceIntelPT.h/.cpp files. We don't want each plug-in added their definitions in this global TraceOptions.h file

123–138

We really shouldn't have any Intel PT stuff in this header file. It should be in the TraceIntelPT.h/.cpp file. We don't want each plug-in added their definitions in this global TraceOptions.h file

lldb/include/lldb/lldb-enumerations.h

773–784

This is the public API header file. Move to lldb/include/lldb/lldb-private-enumerations.h

lldb/source/Commands/CommandObjectThread.cpp

2006–2009

It would be nice to remove the "all" scenario here and just implement "process trace start".

lldb/source/Commands/CommandObjectThreadUtil.cpp

172

remove "all" and create "process trace start"?

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

1521

Having a fixed size of memory for each thread can be dangerous. What if the user specifies a really large value, and then creates thousands of threads? What will happen to the system? Will if fail gracefully? Can you deadlock your computer?

[wallace]

lldb/docs/lldb-gdb-remote.txt

279

After thinking a lot about it, I think that providing whole-process tracing instead of per-thread tracing is going to be impractical for lldb, which means that only two variants are necessary and your suggestion is correct.

I'll elaborate more: whole-process tracing means using a single buffer per logical core, having each of these buffers contain the instructions of all the threads that run on its core. As Intel PT doesn't trace thread switches, it's necessary to add a secondary context switch trace to be able to produce per-thread traces, which is a requirement for analyzing the instruction of a thread. This splitting is done by correlating the timestamps of the context switches with the timestamps of the packets in the Intel PT trace. There are two problems here:

• Tracing context switches requires the kernel to have certain capabilities that are not ubiquitous on all systems, and some of these are more accurate than others. One option is to use PERF_RECORD_SWITCH, but it's not available everywhere.
• Even if you were able to trace context switches, now you depend on the granularity of the timestamps in the intel pt packets. Old Intel hardware provides a timestamp for every few KBs of packets, and newer hardware allows you to have a timestamp for each cpu cycle. In any case, you can end up with invalid splits, as you need to interpolate the timestamps for the packets whose timestamp is not available, and you could assign a packet to the wrong thread.

I was chatting about that with some infra folks at fb, and they think that they will only be able to support this kind of tracing by implementing a special collector that has access to a special feature in the kernel they are working on, and would only work on the most recent Intel hardware with high timestamp accuracy.

That being said, it seems that it's not worth working on that for LLDB. Each company that wants that level of tracing should work on their own way to do accurate thread splitting, and it would be misleading to implement something in LLDB that can produce wrong values. For LLDB we can use per-thread tracing, which will ensure 100% accuracy.

311

This is KB per thread. See my comment below about adding a limit on the total buffer memory used.

404

Yes, it's custom for each plug-in. I added entry for intel pt in line 411.

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

1521

AFAIK, the buffer is stored in a region in memory that is fixed and shouldn't be swapped, as the CPU needs to write directly there without interrupting the traced process. So I imagine that if you have too many threads, then you might end up consuming all your RAM and killing your computer.

In any case, your point is valid. Given that we don't know beforehand how many things will end up being created, what about creating a setting for the maximum total amount of memory to use? E.g. 500MB. The user could override it if needed. At least with this, the first threads, which are commonly the long-lived threads, will be traced, and future short-lived threads won't be traced, but they don't matter that much.

[clayborg]

See my inlined comments, but it would be great to be able to just trace a few threads if any "tids" are specified in the "jLLDBTraceStart" packet, and all threads using a per thread buffer and call that "process". We would still use a per thread buffer for "process" tracing, basically "currentAndFutureThreads" will become the equivalent of "process" tracing. Just have the Intel PT trace plug-in take care of it. We can avoid any use of the one buffer for the entire process issues you mentioned that way, and it effectively does what the user wants. Adding a max memory settings to the custom settings in "jLLDBTraceStart" for Intel PT sounds like a good idea as well.

lldb/docs/lldb-gdb-remote.txt

279

I would be happy to just call "currentAndFutureThreads" to be the same thing as "process" here. No one cares how it is done, and this ends up tracing all threads anyway right? Can't we just make it happen? A user doesn't care if it uses the same trace buffer for all threads, just as long as all threads can be traced.

311

maybe better named as "threadBufferSize"? Does it have to be in KB? Does it actually have to be a multiple of kernel page sizes at all? The description isn't clear that this is a per thread buffer, so a better description would be great that explains this.

312

more description on this please?

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

1521

max memory setting would be nice and should maybe be specified at trace start?

[wallace]

I'll redo this diff in smaller diffs

[wallace]

Changed my mind :)

[wallace]

Updates in the diff description

[clayborg]

lldb/docs/lldb-gdb-remote.txt

246–251

Do we want to return a list of types here in case we have more than one option?

278–279

Is this comment out of date now? If we are doing thread tracing they should be just specific threads not right? Not "This is a best effort request, which tries to trace as many threads as possible".

305

Should we be rounding down or up? If someone specifies "1" for "threadBufferSize" it would round down to zero. Or maybe we specific this should be a multiple of 4K or we will fail?

429–430

Should this "cpuInfo" be a process data type and sent as binary that we fetch with jLLDBTraceGetBinaryData? The JSON would look something like:

{
  "tracedThreads": [
    { "tid": 123, "data": [ { "kind": "thread-data", "size": 1024 } ] },
    { "tid": 234, "data": [ { "kind": "thread-data", "size": 1024 } ] }
  ],
  "process-data": [
    { "pid": 345, "data",  [ { "kind": "cpuInfo", "size": 16 } ] }
  ]
}

lldb/include/lldb/lldb-enumerations.h

251

We should have a processor trace specific stop reason so we should rename this to something like "eStopReasonProcessorTrace". We will use this for many things:

• max memory for process is being exceeded (what this is being used
• trace buffers are full and need to be emptied (for future use with fixed buffers that stop the process when they are full)
• anything else trace related

Then you can encode things into the the StopInfo class. See StopInfo::CreateStopReasonWithSignal(...) and other functions that encode additional data for stop reasons.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

649

"process trace"?

lldb/source/Target/Target.cpp

3082–3083

This will crash if there is no process, so maybe above if statement should be:

if (!m_trace_sp && m_process_sp)

lldb/source/Target/Thread.cpp

1689

"processor trace"?

[wallace]

Addresses all issues, following our offline discussion.

[clayborg]

Looking really good.

See inline comments about the need for a ProcessorTraceStopReason.

Since we have the eStopReasonProcessorTrace stop reason now, we should probably deliver these stops to the Trace plug-in so that it can respond maybe? Fine if we can to do this in another patch.

lldb/include/lldb/Target/StopInfo.h

133

Do we need an extra enumeration for eStopReasonProcessorTrace that we would add as a parameter? I could think of:

enum ProcessorTraceStopReason {
///< Max memory for process has been exceeded  (current patch and the only reason we stop with eStopReasonProcessorTrace , right?)
eProcessorTraceProcessBufferFull = 1
///< For using a buffer that fills and then stops the process (future patch)
eProcessorTraceThreadBufferFull, 
///< For when tracing specific threads and all threads that were traced have exited (future patch)
eProcessorTraceTraceEnded, 
eProcessorTraceXXXX
};

Then this data could be return from SBThread APIs via:

size_t SBThread::GetStopReasonDataCount();
uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx);

Where SBThread::GetStopReasonDataCount() would return 1, and SBThread::GetStopReasonDataAtIndex(0) would return this enumeration. We would also use this enumeration in the Trace plug-ins when responding to stops that were eStopReasonProcessorTrace

[wallace]

I like that idea, but i'd rather do it in a different patch once we have a second stop event, so that I make sure the entire thing makes sense.

[clayborg]

Sounds good. Lets gets this in then and start iterating on future patches!

[jankratochvil]

Checked in a regression fix: rG18a85276426b9604a9ceca8c528b694964dd8d7c

lldb/docs/lldb-gdb-remote.txt

 //  they are not provided to lldb, lldb will likely need to send one to
 //  two packets per thread to fetch the data at every private stop.
 //----------------------------------------------------------------------
 
 send packet: QListThreadsInStopReply
 read packet: OK
 
 //----------------------------------------------------------------------
-// jLLDBTraceSupportedType
+// jLLDBTraceSupported
 //
 // BRIEF
 //  Get the processor tracing type supported by the gdb-server for the current
 //  inferior. Responses might be different depending on the architecture and
 //  capabilities of the underlying OS.
 //
-//  The return packet is a JSON object with the following schema
-//
-//  {
-//    "name": <tracing technology name, e.g. intel-pt, arm-coresight>
-//    "description": <description string for this technology>
-//  }
+//  OUTPUT SCHEMA
+//   {
+//     "name": <string>,
+//         Tracing technology name, e.g. intel-pt, arm-coresight.
+//     "description": <string>,
+//         Description for this technology.
+//   }
 //
-//  If no tracing technology is supported for the inferior, or no process is
-//  running, then an error should be returned.
+//   If no tracing technology is supported for the inferior, or no process is
+//   running, then an error message is returned.
 //
 // NOTE
 //  This packet is used by Trace plug-ins (see lldb_private::Trace.h) to
 //  do live tracing. Specifically, the name of the plug-in should match the name
 //  of the tracing technology returned by this packet.
 //----------------------------------------------------------------------
 
-send packet: jLLDBTraceSupportedType
-read packet: {"name": <name>, "description", <description>}/E<error code>;AAAAAAAAA
+send packet: jLLDBTraceSupported
+read packet: {"name":<name>, "description":<description>}/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
-// jTraceStart:
-//
-// This packet is deprecated.
+// jLLDBTraceStart
 //
 // BRIEF
-//  Packet for starting trace of type lldb::TraceType. The following
-//  parameters should be appended to the packet formatted as a JSON
-//  dictionary, where the schematic for the JSON dictionary in terms of
-//  the recognized Keys is given below in the table.
-//  Different tracing types could require different custom parameters.
-//  Such custom tracing parameters if needed should be collectively
-//  specified in a JSON dictionary and the dictionary can be appended
-//  to this packet (as Value corresponding to "params"). Since sending
-//  JSON data over gdb-remote protocol has certain limitations, binary
-//  escaping convention should be used.
+//  Start tracing a process or its threads using a provided tracing technology.
+//  The input and output are specified as JSON objects. In case of success, an OK
+//  response is returned, or an error otherwise.
 //
-//  Following is the list of parameters -
+// PROCESS TRACING
+//  This traces existing and future threads of the current process. An error is
+//  returned if the process is already being traced.
 //
-//  Key             Value (Integer)                         (O)Optional/
-//                  (except params which should be a        (M)Mandatory
-//                  JSON dictionary)
-//  ==========      ====================================================
+// THREAD TRACING
+//  This traces specific threads.
 //
-//  type            The type of trace to start (see          M
-//                  lldb-enumerations for TraceType)
+// INPUT SCHEMA
+//  {
+//    "type": <string>,
+//        Tracing technology name, e.g. intel-pt, arm-coresight.
 //
-//  buffersize      The size of the buffer to allocate       M
-//                  for trace gathering.
+//    /* thread tracing only */
+//    "tids": [<decimal integer>],
+//        Individual threads to trace.
 //
-//  threadid        The id of the thread to start tracing    O
-//                  on.
+//    ... other parameters specific to the provided tracing type
+//  }
 //
-//  metabuffersize  The size of buffer to hold meta data     O
-//                  used for decoding the trace data.
+// NOTES
+//  - If "tids" is not provided, then the operation is "process tracing",
+//    otherwise it's "thread tracing".
+//  - Each tracing technology can have different levels of support for "thread
+//    tracing" and "process tracing".
+//
+// INTEL-PT
+//  intel-pt supports both "thread tracing" and "process tracing".
+//
+//  "Process tracing" is implemented by tracing each thread individually, but
+//  managed by the same "process trace" instance.
+//  Each actual thread trace, either from "process tracing" or "thread tracing",
+//  is stored in an in-memory circular buffer, which keeps the most recent data.
 //
-//  params          Any parameters that are specific to      O
-//                  certain trace technologies should be
-//                  collectively specified as a JSON
-//                  dictionary
-//  ==========      ====================================================
+//  Additional params in the input schema:
+//   {
+//     "threadBufferSize": <decimal integer>,
+//         Trace buffer size per thread in bytes. It must be a power of 2
+//         greater than or equal to 4096 (2^12) bytes.
+//
+//     /* process tracing only */
+//     "processBufferSizeLimit": <decimal integer>,
+//         Maximum total buffer size per process in bytes.
+//         This limit applies to the sum of the sizes of all trace buffers for
+//         the current process, excluding the ones started with "thread tracing".
+//
+//         Whenever a thread is attempted to be traced due to "process tracing"
+//         and the limit would be reached, the process is stopped with a
+//         "tracing" reason along with a meaningful description, so that the
+//         user can retrace the process if needed.
+//   }
 //
-//  Each tracing instance is identified by a trace id which is returned
-//  as the reply to this packet. In case the tracing failed to begin an
-//  error code along with a hex encoded ASCII message is returned
-//  instead.
+//  Notes:
+//   - Modifying the parameters of an existing trace is not supported. The user
+//     needs to stop the trace and start a new one.
+//   - If "process tracing" is attempted and there are individual threads
+//     already being traced with "thread tracing", these traces are left
+//     unaffected and the threads not traced twice.
+//   - If "thread tracing" is attempted on a thread already being traced with
+//     either "thread tracing" or "process tracing", it fails.
 //----------------------------------------------------------------------
 
-send packet: jTraceStart:{"type":<type>,"buffersize":<buffersize>}]
-read packet: <trace id>/E<error code>;AAAAAAAAA
+Process tracing:
+send packet: jLLDBTraceStart:{"type":<type>,...other params}]
+read packet: OK/E<error code>;AAAAAAAAA
+
+Thread tracing:
+send packet: jLLDBTraceStart:{"type":<type>,"tids":<tids>,...other params}]
+read packet: OK/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
-// jTraceStop:
-//
-// This packet is deprecated.
+// jLLDBTraceStop
 //
 // BRIEF
-//  Stop tracing instance with trace id <trace id>, of course trace
-//  needs to be started before. The following parameters should be
-//  formatted as a JSON dictionary to the packet. Since sending
-//  JSON data over gdb-remote protocol has certain limitations, binary
-//  escaping convention should be used.
+//  Stop tracing a process or its threads using a provided tracing technology.
+//  The input and output are specified as JSON objects. In case of success, an OK
+//  response is returned, or an error otherwise.
 //
-//  Following is the list of parameters -
+// PROCESS TRACE STOPPING
+//  Stopping a process trace doesn't stop the active traces initiated with
+//  "thread tracing".
 //
-//  Key             Value (Integer)                         (O)Optional/
-//                                                          (M)Mandatory
-//  ==========      ====================================================
+// THREAD TRACE STOPPING
+//  This is a best effort request, which tries to stop as many traces as
+//  possible.
 //
-//  traceid         The trace id of the tracing instance    M
+// INPUT SCHEMA
+//  The schema for the input is
 //
-//  threadid        The id of the thread to stop tracing    O
-//                  on. Since <trace id> could map to
-//                  multiple trace instances (in case it
-//                  maps to the complete process), the
-//                  threadid of a particular thread could
-//                  be appended as "threadid:<thread id>;"
-//                  to stop tracing on that thread.
-//  ==========      ====================================================
+//  {
+//    "type": <string>
+//       Tracing technology name, e.g. intel-pt, arm-coresight.
 //
-//  An OK response is sent in case of success else an error code along
-//  with a hex encoded ASCII message is returned.
+//    /* thread trace stopping only */
+//    "tids":  [<decimal integer>]
+//       Individual thread traces to stop.
+//  }
+//
+// NOTES
+//  - If "tids" is not provided, then the operation is "process trace stopping".
+//
+// INTEL PT
+//  Stopping a specific thread trace started with "process tracing" is allowed.
 //----------------------------------------------------------------------
 
-send packet: jTraceStop:{"traceid":<trace id>}]
-read packet: <OK response>/E<error code>;AAAAAAAAA
+Process trace stopping:
+send packet: jLLDBTraceStop:{"type":<type>}]
+read packet: OK/E<error code>;AAAAAAAAA
+
+Thread trace stopping:
+send packet: jLLDBTraceStop:{"type":<type>,"tids":<tids>}]
+read packet: OK/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
-// jTraceBufferRead:
-//
-// This packet is deprecated.
+// jLLDBTraceGetState
 //
 // BRIEF
-//  Packet for reading the trace for tracing instance <trace id>, i.e the
-//  id obtained from StartTrace API. The following parameters should be
-//  formatted as a JSON dictionary to the packet. Since sending
-//  JSON data over gdb-remote protocol has certain limitations, binary
-//  escaping convention should be used.
-//
-//  Following is the list of parameters -
+//  Get the current state of the process and its threads being traced by
+//  a given trace technology. The response is a JSON object with custom
+//  information depending on the trace technology. In case of errors, an
+//  error message is returned.
 //
-//  Key             Value (Integer)                         (O)Optional/
-//                                                          (M)Mandatory
-//  ==========      ====================================================
-//  traceid         The trace id of the tracing instance    M
+// INPUT SCHEMA
+//  {
+//     "type": <string>
+//        Tracing technology name, e.g. intel-pt, arm-coresight.
+//  }
 //
-//  offset          The offset to start reading the data    M
-//                  from.
+// OUTPUT SCHEMA
+//  {
+//    "tracedThreads": [{
+//      "tid": <decimal integer>,
+//      "binaryData": [
+//        {
+//          "kind": <string>,
+//              Identifier for some binary data related to this thread to
+//              fetch with the jLLDBTraceGetBinaryData packet.
+//          "size": <decimal integer>,
+//              Size in bytes of this thread data.
+//        },
+//      ]
+//    }],
+//    "processBinaryData": [
+//      {
+//        "kind": <string>,
+//            Identifier for some binary data related to this process to
+//            fetch with the jLLDBTraceGetBinaryData packet.
+//        "size": <decimal integer>,
+//            Size in bytes of this thread data.
+//      },
+//    }]
+//  }
 //
-//  buffersize      The size of the data intended to read.  M
+// NOTES
+//   - "traceThreads" includes all thread traced by both "process tracing" and
+//     "thread tracing".
 //
-//  threadid        The id of the thread to retrieve data   O
-//                  from.
-//  ==========      ====================================================
+// INTEL PT
 //
-//  The trace data is sent as raw binary data if the read was successful
-//  else an error code along with a hex encoded ASCII message is sent.
+//  Binary data kinds:
+//    - threadTraceBuffer: trace buffer for a thread.
+//    - cpuInfo: contents of the /proc/cpuinfo file.
 //----------------------------------------------------------------------
 
-send packet: jTraceBufferRead:{"traceid":<trace id>,"offset":<byteoffset>,"buffersize":<byte_count>}]
-read packet: <binary trace data>/E<error code>;AAAAAAAAA
+send packet: jLLDBTraceGetState:{"type":<type>}]
+read packet: {...object}/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
-// jTraceMetaRead:
-//
-// This packet is deprecated.
-//
-// BRIEF
-//  Similar Packet as above except it reads meta data.
-//----------------------------------------------------------------------
-
-/----------------------------------------------------------------------
-// jTraceConfigRead:
-//
-// This packet is deprecated.
+// jLLDBTraceGetBinaryData
 //
 // BRIEF
-//  Request the trace configuration for the tracing instance with id
-//  <trace id>.
+//  Get binary data given a trace technology and a data identifier.
+//  The input is specified as a JSON object and the response has the same format
+//  as the "binary memory read" (aka "x") packet. In case of failures, an error
+//  message is returned.
 //
-//  Following is the list of parameters -
+// SCHEMA
+//  The schema for the input is
 //
-//  Key             Value (Integer)                         (O)Optional/
-//                                                          (M)Mandatory
-//  ==========      ====================================================
-//  traceid         The trace id of the tracing instance    M
+//  {
+//   "type": <string>,
+//       Tracing technology name, e.g. intel-pt, arm-coresight.
+//   "kind": <string>,
+//       Identifier for the data.
+//   "tid"?: <Optional decimal>,
+//       Tid in decimal if the data belongs to a thread.
+//   "offset": <decimal>,
+//       Offset of the data in bytes.
+//   "size": <decimal>,
+//      Number of bytes in to read starting from the offset.
+//  }
 //
-//  threadid        The id of the thread to obtain trace    O
-//                  configuration from. Since <trace id>
-//                  could map to multiple trace instances
-//                  (in case it maps to the complete
-//                  process), the threadid of a particular
-//                  thread could be appended as
-//                  "threadid:<thread id>;" to obtain the
-//                  trace configuration of that thread.
-//  ==========      ====================================================
+// INTEL PT
 //
-//  In the response packet the trace configuration is sent as text,
-//  formatted as a JSON dictionary. Since sending JSON data over
-//  gdb-remote protocol has certain limitations, binary escaping
-//  convention is used.
-//  In case the trace instance with the <trace id> was not found, an
-//  error code along with a hex encoded ASCII message is returned.
+//  Binary data kinds:
+//    - threadTraceBuffer: trace buffer for a thread.
+//    - cpuInfo: contents of the /proc/cpuinfo file.
 //----------------------------------------------------------------------
 
-send packet: jTraceConfigRead:{"traceid":<trace id>}
-read packet: {"conf1":<conf1>,"conf2":<conf2>,"params":{"paramName":paramValue}]}];/E<error code>;AAAAAAAAA
+send packet: jLLDBTraceGetBinaryData:{"type":<type>,"kind":<query>,"tid":<tid>,"offset":<offset>,"size":<size>}]
+read packet: <binary data>/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
 // "qRegisterInfo<hex-reg-id>"
 //
 // BRIEF
 //  Discover register information from the remote GDB server.
 //
 // PRIORITY TO IMPLEMENT

lldb/include/lldb/Core/PluginManager.h

static bool RegisterPlugin(ConstString name, const char *description,
                              SymbolVendorCreateInstance create_callback);
 
   static bool UnregisterPlugin(SymbolVendorCreateInstance create_callback);
 
   static SymbolVendorCreateInstance
   GetSymbolVendorCreateCallbackAtIndex(uint32_t idx);
 
   // Trace
-  static bool RegisterPlugin(ConstString name, const char *description,
-                             TraceCreateInstance create_callback,
-                             llvm::StringRef schema,
-                             TraceGetStartCommand get_start_command);
+  static bool RegisterPlugin(
+      ConstString name, const char *description,
+      TraceCreateInstanceForSessionFile create_callback_for_session_file,
+      TraceCreateInstanceForLiveProcess create_callback_for_live_process,
+      llvm::StringRef schema);
 
-  static bool UnregisterPlugin(TraceCreateInstance create_callback);
+  static bool
+  UnregisterPlugin(TraceCreateInstanceForSessionFile create_callback);
 
-  static TraceCreateInstance GetTraceCreateCallback(ConstString plugin_name);
+  static TraceCreateInstanceForSessionFile
+  GetTraceCreateCallback(ConstString plugin_name);
 
-  static lldb::CommandObjectSP
-  GetTraceStartCommand(llvm::StringRef plugin_name,
-                       CommandInterpreter &interpreter);
+  static TraceCreateInstanceForLiveProcess
+  GetTraceCreateCallbackForLiveProcess(ConstString plugin_name);
 
   /// Get the JSON schema for a trace session file corresponding to the given
   /// plugin.
   ///
   /// \param[in] plugin_name
   ///     The name of the plugin.
   ///
   /// \return

lldb/include/lldb/Host/common/NativeProcessProtocol.h

 
 #include "NativeBreakpointList.h"
 #include "NativeThreadProtocol.h"
 #include "NativeWatchpointList.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Status.h"
-#include "lldb/Utility/TraceOptions.h"
+#include "lldb/Utility/TraceGDBRemotePackets.h"
 #include "lldb/Utility/UnimplementedError.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
public:
     /// \return
     ///     A NativeProcessProtocol shared pointer if the operation succeeded or
     ///     an error object if it failed.
     virtual llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
     Attach(lldb::pid_t pid, NativeDelegate &native_delegate,
            MainLoop &mainloop) const = 0;
   };
 
-  /// StartTracing API for starting a tracing instance with the
-  /// TraceOptions on a specific thread or process.
+  /// Start tracing a process or its threads.
   ///
-  /// \param[in] config
-  ///     The configuration to use when starting tracing.
+  /// \param[in] json_params
+  ///     JSON object with the information of what and how to trace.
+  ///     In the case of gdb-remote, this object should conform to the
+  ///     jLLDBTraceStart packet.
   ///
-  /// \param[out] error
-  ///     Status indicates what went wrong.
+  ///     This object should have a string entry called "type", which is the
+  ///     tracing technology name.
   ///
-  /// \return
-  ///     The API returns a user_id which can be used to get trace
-  ///     data, trace configuration or stopping the trace instance.
-  ///     The user_id is a key to identify and operate with a tracing
-  ///     instance. It may refer to the complete process or a single
-  ///     thread.
-  virtual lldb::user_id_t StartTrace(const TraceOptions &config,
-                                     Status &error) {
-    error.SetErrorString("Not implemented");
-    return LLDB_INVALID_UID;
-  }
-
-  /// StopTracing API as the name suggests stops a tracing instance.
-  ///
-  /// \param[in] traceid
-  ///     The user id of the trace intended to be stopped. Now a
-  ///     user_id may map to multiple threads in which case this API
-  ///     could be used to stop the tracing for a specific thread by
-  ///     supplying its thread id.
-  ///
-  /// \param[in] thread
-  ///     Thread is needed when the complete process is being traced
-  ///     and the user wishes to stop tracing on a particular thread.
+  /// \param[in] type
+  ///     Tracing technology type, as described in the \a json_params.
   ///
   /// \return
-  ///     Status indicating what went wrong.
-  virtual Status StopTrace(lldb::user_id_t traceid,
-                           lldb::tid_t thread = LLDB_INVALID_THREAD_ID) {
-    return Status("Not implemented");
+  ///     \a llvm::Error::success if the operation was successful, or an
+  ///     \a llvm::Error otherwise.
+  virtual llvm::Error TraceStart(llvm::StringRef json_params,
+                                 llvm::StringRef type) {
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Unsupported tracing type '%s'",
+                                   type.data());
   }
 
-  /// This API provides the trace data collected in the form of raw
-  /// data.
-  ///
-  /// \param[in] traceid thread
-  ///     The traceid and thread provide the context for the trace
-  ///     instance.
-  ///
-  /// \param[in] buffer
-  ///     The buffer provides the destination buffer where the trace
-  ///     data would be read to. The buffer should be truncated to the
-  ///     filled length by this function.
-  ///
-  /// \param[in] offset
-  ///     There is possibility to read partially the trace data from
-  ///     a specified offset where in such cases the buffer provided
-  ///     may be smaller than the internal trace collection container.
-  ///
-  /// \return
-  ///     The size of the data actually read.
-  virtual Status GetData(lldb::user_id_t traceid, lldb::tid_t thread,
-                         llvm::MutableArrayRef<uint8_t> &buffer,
-                         size_t offset = 0) {
-    return Status("Not implemented");
+  /// \copydoc Process::TraceStop(const TraceStopRequest &)
+  virtual llvm::Error TraceStop(const TraceStopRequest &request) {
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Unsupported tracing type '%s'",
+                                   request.type.data());
   }
 
-  /// Similar API as above except it aims to provide any extra data
-  /// useful for decoding the actual trace data.
-  virtual Status GetMetaData(lldb::user_id_t traceid, lldb::tid_t thread,
-                             llvm::MutableArrayRef<uint8_t> &buffer,
-                             size_t offset = 0) {
-    return Status("Not implemented");
+  /// \copydoc Process::TraceGetState(llvm::StringRef type)
+  virtual llvm::Expected<llvm::json::Value>
+  TraceGetState(llvm::StringRef type) {
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Unsupported tracing type '%s'",
+                                   type.data());
   }
 
-  /// API to query the TraceOptions for a given user id
-  ///
-  /// \param[in] traceid
-  ///     The user id of the tracing instance.
-  ///
-  /// \param[out] config
-  ///     The configuration being used for tracing.
-  ///
-  /// \return A status indicating what went wrong.
-  virtual Status GetTraceConfig(lldb::user_id_t traceid, TraceOptions &config) {
-    return Status("Not implemented");
+  /// \copydoc Process::TraceGetBinaryData(const TraceGetBinaryDataRequest &)
+  virtual llvm::Expected<std::vector<uint8_t>>
+  TraceGetBinaryData(const TraceGetBinaryDataRequest &request) {
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        "Unsupported data kind '%s' for the '%s' tracing technology",
+        request.kind.c_str(), request.type.c_str());
   }
 
-  /// \copydoc Process::GetSupportedTraceType()
-  virtual llvm::Expected<TraceTypeInfo> GetSupportedTraceType() {
+  /// \copydoc Process::TraceSupported()
+  virtual llvm::Expected<TraceSupportedResponse> TraceSupported() {
     return llvm::make_error<UnimplementedError>();
   }
 
 protected:
   struct SoftwareBreakpoint {
     uint32_t ref_count;
     llvm::SmallVector<uint8_t, 4> saved_opcodes;
     llvm::ArrayRef<uint8_t> breakpoint_opcodes;

lldb/include/lldb/Target/Process.h

 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Listener.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
-#include "lldb/Utility/TraceOptions.h"
+#include "lldb/Utility/TraceGDBRemotePackets.h"
 #include "lldb/Utility/UnimplementedError.h"
 #include "lldb/Utility/UserIDResolver.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VersionTuple.h"
 
void PruneThreadPlans();
   /// one way to tell whether a feature is available.
   ///
   /// \return
   ///     The plugin if one is available for the specified feature;
   ///     otherwise, returns an empty shared pointer.
   lldb::StructuredDataPluginSP
   GetStructuredDataPlugin(ConstString type_name) const;
 
+  /// Deprecated
+  ///
   /// Starts tracing with the configuration provided in options. To enable
   /// tracing on the complete process the thread_id in the options should be
   /// set to LLDB_INVALID_THREAD_ID. The API returns a user_id which is needed
   /// by other API's that manipulate the trace instance. The handling of
   /// erroneous or unsupported configuration is left to the trace technology
   /// implementations in the server, as they could be returned as an error, or
   /// rounded to a valid configuration to start tracing. In the later case the
   /// GetTraceConfig should supply the actual used trace configuration.
   virtual lldb::user_id_t StartTrace(const TraceOptions &options,
                                      Status &error) {
     error.SetErrorString("Not implemented");
     return LLDB_INVALID_UID;
   }
 
+  /// Deprecated
+  ///
   /// Stops the tracing instance leading to deletion of the trace data. The
   /// tracing instance is identified by the user_id which is obtained when
   /// tracing was started from the StartTrace. In case tracing of the complete
   /// process needs to be stopped the thread_id should be set to
   /// LLDB_INVALID_THREAD_ID. In the other case that tracing on an individual
   /// thread needs to be stopped a thread_id can be supplied.
   virtual Status StopTrace(lldb::user_id_t uid, lldb::tid_t thread_id) {
     return Status("Not implemented");
   }
 
+  /// Deprecated
+  ///
   /// Provides the trace data as raw bytes. A buffer needs to be supplied to
   /// copy the trace data. The exact behavior of this API may vary across
   /// trace technology, as some may support partial reading of the trace data
   /// from a specified offset while some may not. The thread_id should be used
   /// to select a particular thread for trace extraction.
   virtual Status GetData(lldb::user_id_t uid, lldb::tid_t thread_id,
                          llvm::MutableArrayRef<uint8_t> &buffer,
                          size_t offset = 0) {
     return Status("Not implemented");
   }
 
+  /// Deprecated
+  ///
   /// Similar API as above except for obtaining meta data
   virtual Status GetMetaData(lldb::user_id_t uid, lldb::tid_t thread_id,
                              llvm::MutableArrayRef<uint8_t> &buffer,
                              size_t offset = 0) {
     return Status("Not implemented");
   }
 
-  /// API to obtain the trace configuration used by a trace instance.
-  /// Configurations that may be specific to some trace technology should be
-  /// stored in the custom parameters. The options are transported to the
-  /// server, which shall interpret accordingly. The thread_id can be
-  /// specified in the options to obtain the configuration used by a specific
-  /// thread. The thread_id specified should also match the uid otherwise an
-  /// error will be returned.
-  virtual Status GetTraceConfig(lldb::user_id_t uid, TraceOptions &options) {
-    return Status("Not implemented");
-  }
-
+protected:
+  friend class Trace;
   ///  Get the processor tracing type supported for this process.
   ///  Responses might be different depending on the architecture and
   ///  capabilities of the underlying OS.
   ///
   ///  \return
   ///     The supported trace type or an \a llvm::Error if tracing is
   ///     not supported for the inferior.
-  virtual llvm::Expected<TraceTypeInfo> GetSupportedTraceType();
+  virtual llvm::Expected<TraceSupportedResponse> TraceSupported();
+
+  /// Start tracing a process or its threads.
+  ///
+  /// \param[in] request
+  ///     JSON object with the information necessary to start tracing. In the
+  ///     case of gdb-remote processes, this JSON object should conform to the
+  ///     jLLDBTraceStart packet.
+  ///
+  /// \return
+  ///     \a llvm::Error::success if the operation was successful, or
+  ///     \a llvm::Error otherwise.
+  virtual llvm::Error TraceStart(const llvm::json::Value &request) {
+    return llvm::make_error<UnimplementedError>();
+  }
+
+  /// Stop tracing a live process or its threads.
+  ///
+  /// \param[in] request
+  ///     The information determining which threads or process to stop tracing.
+  ///
+  /// \return
+  ///     \a llvm::Error::success if the operation was successful, or
+  ///     \a llvm::Error otherwise.
+  virtual llvm::Error TraceStop(const TraceStopRequest &request) {
+    return llvm::make_error<UnimplementedError>();
+  }
+
+  /// Get the current tracing state of the process and its threads.
+  ///
+  /// \param[in] type
+  ///     Tracing technology type to consider.
+  ///
+  /// \return
+  ///     A JSON object string with custom data depending on the trace
+  ///     technology, or an \a llvm::Error in case of errors.
+  virtual llvm::Expected<std::string> TraceGetState(llvm::StringRef type) {
+    return llvm::make_error<UnimplementedError>();
+  }
+
+  /// Get binary data given a trace technology and a data identifier.
+  ///
+  /// \param[in] request
+  ///     Object with the params of the requested data.
+  ///
+  /// \return
+  ///     A vector of bytes with the requested data, or an \a llvm::Error in
+  ///     case of failures.
+  virtual llvm::Expected<std::vector<uint8_t>>
+  TraceGetBinaryData(const TraceGetBinaryDataRequest &request) {
+    return llvm::make_error<UnimplementedError>();
+  }
 
   // This calls a function of the form "void * (*)(void)".
   bool CallVoidArgVoidPtrReturn(const Address *address,
                                 lldb::addr_t &returned_func,
                                 bool trap_exceptions = false);
 
-protected:
   /// Update the thread list following process plug-in's specific logic.
   ///
   /// This method should only be invoked by \a UpdateThreadList.
   ///
   /// \return
   ///     \b true if the new thread list could be generated, \b false otherwise.
   virtual bool DoUpdateThreadList(ThreadList &old_thread_list,
                                   ThreadList &new_thread_list) = 0;
 
   /// Actually do the reading of memory from a process.
   ///
   /// Subclasses must override this function and can return fewer bytes than
   /// requested when memory requests are too large. This class will break up
   /// the memory requests and keep advancing the arguments along as needed.
   ///
   /// \param[in] vm_addr
   ///     A virtual load address that indicates where to start reading
   ///     memory from.
   ///
   /// \param[in] size
   ///     The number of bytes to read.
   ///
   /// \param[out] buf
   ///     A byte buffer that is at least \a size bytes long that
   ///     will receive the memory bytes.
   ///
   /// \param[out] error
   ///     An error that indicates the success or failure of this

lldb/include/lldb/Target/ProcessTrace.h

 #define LLDB_TARGET_PROCESSTRACE_H
 
 #include "lldb/Target/PostMortemProcess.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 
 namespace lldb_private {
 
+/// Class that represents a defunct process loaded on memory via the "trace
+/// load" command.
 class ProcessTrace : public PostMortemProcess {
 public:
   static void Initialize();
 
   static void Terminate();
 
   static ConstString GetPluginNameStatic();
 
public:
   Status WillResume() override {
     Status error;
     error.SetErrorStringWithFormat(
         "error: %s does not support resuming processes",
         GetPluginName().GetCString());
     return error;
   }
 
-  bool IsAlive() override;
-
   bool WarnBeforeDetach() const override { return false; }
 
   size_t ReadMemory(lldb::addr_t addr, void *buf, size_t size,
                     Status &error) override;
 
   size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                       Status &error) override;
 

lldb/include/lldb/Target/StopInfo.h

CreateStopReasonWithPlan(lldb::ThreadPlanSP &plan,
                            lldb::ValueObjectSP return_valobj_sp,
                            lldb::ExpressionVariableSP expression_variable_sp);
 
   static lldb::StopInfoSP
   CreateStopReasonWithException(Thread &thread, const char *description);
 
   static lldb::StopInfoSP CreateStopReasonWithExec(Thread &thread);
 
+  static lldb::StopInfoSP
+  CreateStopReasonProcessorTrace(Thread &thread, const char *description);
+
   static lldb::ValueObjectSP
   GetReturnValueObject(lldb::StopInfoSP &stop_info_sp);
 
   static lldb::ExpressionVariableSP
   GetExpressionVariable(lldb::StopInfoSP &stop_info_sp);
 
   static lldb::ValueObjectSP
   GetCrashingDereference(lldb::StopInfoSP &stop_info_sp,

lldb/include/lldb/Target/Target.h

public:
   ///   The trace object.
   void SetTrace(const lldb::TraceSP &trace_sp);
 
   /// Get the \a Trace object containing processor trace information of this
   /// target.
   ///
   /// \return
   ///   The trace object. It might be undefined.
-  const lldb::TraceSP &GetTrace();
+  lldb::TraceSP &GetTrace();
+
+  /// Similar to \a GetTrace, but this also tries to create a \a Trace object
+  /// if not available using the default supported tracing technology for
+  /// this process.
+  llvm::Expected<lldb::TraceSP &> GetTraceOrCreate();
 
   // Since expressions results can persist beyond the lifetime of a process,
   // and the const expression results are available after a process is gone, we
   // provide a way for expressions to be evaluated from the Target itself. If
   // an expression is going to be run, then it should have a frame filled in in
   // the execution context.
   lldb::ExpressionResults EvaluateExpression(
       llvm::StringRef expression, ExecutionContextScope *exe_scope,

lldb/include/lldb/Target/ThreadPostMortemTrace.h

-//===-- ThreadTrace.h -------------------------------------------*- C++ -*-===//
+//===-- ThreadPostMortemTrace.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_THREADTRACE_H
-#define LLDB_TARGET_THREADTRACE_H
+#ifndef LLDB_TARGET_THREADPOSTMORTEMTRACE_H
+#define LLDB_TARGET_THREADPOSTMORTEMTRACE_H
 
 #include "lldb/Target/Thread.h"
 
 namespace lldb_private {
 
-/// \class ThreadTrace ThreadTrace.h
+/// \class ThreadPostMortemTrace ThreadPostMortemTrace.h
 ///
 /// Thread implementation used for representing threads gotten from trace
 /// session files, which are similar to threads from core files.
 ///
 /// See \a TraceSessionFileParser for more information regarding trace session
 /// files.
-class ThreadTrace : public Thread {
+class ThreadPostMortemTrace : public Thread {
 public:
   /// \param[in] process
   ///     The process who owns this thread.
   ///
   /// \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.
-  ThreadTrace(Process &process, lldb::tid_t tid, const FileSpec &trace_file)
+  ThreadPostMortemTrace(Process &process, lldb::tid_t tid,
+                        const 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;
 
 protected:
   bool CalculateStopInfo() override;
 
   lldb::RegisterContextSP m_thread_reg_ctx_sp;
 
 private:
   FileSpec m_trace_file;
 };
 
-typedef std::shared_ptr<ThreadTrace> ThreadTraceSP;
-
 } // namespace lldb_private
 
-#endif // LLDB_TARGET_THREADTRACE_H
+#endif // LLDB_TARGET_THREADPOSTMORTEMTRACE_H

lldb/include/lldb/Target/Trace.h

 //===-- Trace.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_TRACE_H
 #define LLDB_TARGET_TRACE_H
 
+#include <unordered_map>
+
 #include "llvm/Support/JSON.h"
 
 #include "lldb/Core/PluginInterface.h"
+#include "lldb/Target/Thread.h"
 #include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/TraceGDBRemotePackets.h"
 #include "lldb/Utility/UnimplementedError.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 /// \class Trace Trace.h "lldb/Target/Trace.h"
 /// A plug-in interface definition class for trace information.
 ///
 /// Trace plug-ins allow processor trace information to be loaded into LLDB so
 /// that the data can be dumped, used for reverse and forward stepping to allow
 /// introspection into the reason your process crashed or found its way to its
 /// current state.
 ///
 /// Trace information can be loaded into a target without a process to allow
 /// introspection of the trace information during post mortem analysis, such as
 /// when loading core files.
 ///
 /// Processor trace information can also be fetched through the process
 /// interfaces during a live debug session if your process supports gathering
 /// this information.
 ///
 /// In order to support live tracing, the name of the plug-in should match the
 /// name of the tracing type returned by the gdb-remote packet
-/// \a jLLDBTraceSupportedType.
+/// \a jLLDBTraceSupported.
 class Trace : public PluginInterface,
               public std::enable_shared_from_this<Trace> {
 public:
   enum class TraceDirection {
     Forwards = 0,
     Backwards,
   };
 
public:
   ///     The contents of the trace session file describing the trace session.
   ///     See \a TraceSessionFileParser::BuildSchema for more information about
   ///     the schema of this JSON file.
   ///
   /// \param[in] session_file_dir
   ///     The path to the directory that contains the session file. It's used to
   ///     resolved relative paths in the session file.
   static llvm::Expected<lldb::TraceSP>
-  FindPlugin(Debugger &debugger, const llvm::json::Value &trace_session_file,
+  FindPluginForPostMortemProcess(Debugger &debugger,
+                                 const llvm::json::Value &trace_session_file,
                                  llvm::StringRef session_file_dir);
 
+  /// Find a trace plug-in to trace a live process.
+  ///
+  /// \param[in] plugin_name
+  ///     Plug-in name to search.
+  ///
+  /// \param[in] process
+  ///     Live process to trace.
+  ///
+  /// \return
+  ///     A \a TraceSP instance, or an \a llvm::Error if the plug-in name
+  ///     doesn't match any registered plug-ins or tracing couldn't be
+  ///     started.
+  static llvm::Expected<lldb::TraceSP>
+  FindPluginForLiveProcess(llvm::StringRef plugin_name, Process &process);
+
   /// Get the schema of a Trace plug-in given its name.
   ///
   /// \param[in] plugin_name
   ///     Name of the trace plugin.
   static llvm::Expected<llvm::StringRef>
   FindPluginSchema(llvm::StringRef plugin_name);
 
+  /// Get the command handle for the "process trace start" command.
+  virtual lldb::CommandObjectSP
+  GetProcessTraceStartCommand(CommandInterpreter &interpreter) = 0;
+
+  /// Get the command handle for the "thread trace start" command.
+  virtual lldb::CommandObjectSP
+  GetThreadTraceStartCommand(CommandInterpreter &interpreter) = 0;
+
   /// \return
   ///     The JSON schema of this Trace plug-in.
   virtual llvm::StringRef GetSchema() = 0;
 
   /// Each decoded thread contains a cursor to the current position the user is
   /// stopped at. When reverse debugging, each operation like reverse-next or
   /// reverse-continue will move this cursor, which is then picked by any
   /// subsequent dump or reverse operation.
   ///
   /// The initial position for this cursor is the last element of the thread,
   /// which is the most recent chronologically.
   ///
   /// \return
   ///     The current position of the thread's trace or \b 0 if empty.
-  virtual size_t GetCursorPosition(const Thread &thread) = 0;
+  virtual size_t GetCursorPosition(Thread &thread) = 0;
 
   /// Dump \a count instructions of the given thread's trace ending at the
   /// given \a end_position position.
   ///
   /// The instructions are printed along with their indices or positions, which
   /// are increasing chronologically. This means that the \a index 0 represents
   /// the oldest instruction of the trace chronologically.
   ///
public:
   ///     traversed forwards chronologically, i.e. with incrementing indices. If
   ///     \b TraceDirection::Backwards, the traversal is done backwards
   ///     chronologically, i.e. with decrementing indices.
   ///
   /// \param[in] callback
   ///     The callback to execute on each instruction. If it returns \b false,
   ///     the iteration stops.
   virtual void TraverseInstructions(
-      const Thread &thread, size_t position, TraceDirection direction,
+      Thread &thread, size_t position, TraceDirection direction,
       std::function<bool(size_t index, llvm::Expected<lldb::addr_t> load_addr)>
           callback) = 0;
 
-  /// Stop tracing a live thread
+  /// Get the number of available instructions in the trace of the given thread.
   ///
   /// \param[in] thread
-  ///     The thread object to stop tracing.
+  ///     The thread whose trace will be inspected.
   ///
   /// \return
-  ///     An \a llvm::Error if stopping tracing failed, or \b
-  ///     llvm::Error::success() otherwise.
-  virtual llvm::Error StopTracingThread(const Thread &thread) {
-    return llvm::make_error<UnimplementedError>();
-  }
+  ///     The total number of instructions in the trace.
+  virtual size_t GetInstructionCount(Thread &thread) = 0;
 
-  /// Get the number of available instructions in the trace of the given thread.
+  /// Check if a thread is currently traced by this object.
   ///
   /// \param[in] thread
-  ///     The thread whose trace will be inspected.
+  ///     The thread in question.
   ///
   /// \return
-  ///     The total number of instructions in the trace.
-  virtual size_t GetInstructionCount(const Thread &thread) = 0;
+  ///     \b true if the thread is traced by this instance, \b false otherwise.
+  virtual bool IsTraced(const Thread &thread) = 0;
+
+  /// Stop tracing live threads.
+  ///
+  /// \param[in] tids
+  ///     The threads to stop tracing on.
+  ///
+  /// \return
+  ///     \a llvm::Error::success if the operation was successful, or
+  ///     \a llvm::Error otherwise.
+  llvm::Error StopThreads(const std::vector<lldb::tid_t> &tids);
+
+  /// Stop tracing a live process.
+  ///
+  /// \param[in] request
+  ///     The information determining which threads or process to stop tracing.
+  ///
+  /// \return
+  ///     \a llvm::Error::success if the operation was successful, or
+  ///     \a llvm::Error otherwise.
+  llvm::Error StopProcess();
+
+  /// Get the trace file of the given post mortem thread.
+  llvm::Expected<const FileSpec &> GetPostMortemTraceFile(lldb::tid_t tid);
+
+protected:
+  /// 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 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 GetLiveProcessBinaryData
+  llvm::Optional<size_t> GetLiveProcessBinaryDataSize(llvm::StringRef kind);
+  /// Constructor for post mortem processes
+  Trace() = default;
+
+  /// 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
+  ///     case of gdb-remote processes, this JSON object should conform to the
+  ///     jLLDBTraceStart packet.
+  ///
+  /// \return
+  ///     \a llvm::Error::success if the operation was successful, or
+  ///     \a llvm::Error otherwise.
+  llvm::Error Start(const llvm::json::Value &request);
+
+  /// Get the current tracing state of a live process and its threads.
+  ///
+  /// \return
+  ///     A JSON object string with custom data depending on the trace
+  ///     technology, or an \a llvm::Error in case of errors.
+  llvm::Expected<std::string> GetLiveProcessState();
+
+  /// Method to be overriden by the plug-in to refresh its own state.
+  ///
+  /// This is invoked by RefreshLiveProcessState when a new state is found.
+  ///
+  /// \param[in] state
+  ///     The jLLDBTraceGetState response.
+  virtual void
+  DoRefreshLiveProcessState(llvm::Expected<TraceGetStateResponse> state) = 0;
+
+  /// Method to be invoked by the plug-in to refresh the live process state.
+  ///
+  /// The result is cached through the same process stop.
+  void RefreshLiveProcessState();
+
+  /// Process traced by this object if doing live tracing. Otherwise it's null.
+  int64_t m_stop_id = -1;
+  Process *m_live_process = nullptr;
+  /// tid -> data kind -> size
+  std::map<lldb::tid_t, std::unordered_map<std::string, size_t>>
+      m_live_thread_data;
+  /// data kind -> size
+  std::unordered_map<std::string, size_t> m_live_process_data;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_TRACE_H

lldb/include/lldb/Target/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 "llvm/Support/JSON.h"
 
-#include "lldb/Target/ThreadTrace.h"
+#include "lldb/Target/ThreadPostMortemTrace.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.
public:
   struct JSONTraceSession : JSONTraceSessionBase {
     TPluginSettings trace;
   };
   /// \}
 
   /// Helper struct holding the objects created when parsing a process
   struct ParsedProcess {
     lldb::TargetSP target_sp;
-    std::vector<ThreadTraceSP> threads;
+    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.
public:
   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);
 
-  ThreadTraceSP ParseThread(lldb::ProcessSP &process_sp,
+  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.
   ///

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

enum ServerPacketType {
     eServerPacketType_X,
     eServerPacketType_Z,
     eServerPacketType_z,
 
     eServerPacketType__M,
     eServerPacketType__m,
     eServerPacketType_notify, // '%' notification
 
-    eServerPacketType_jTraceStart,      // deprecated
-    eServerPacketType_jTraceBufferRead, // deprecated
-    eServerPacketType_jTraceMetaRead,   // deprecated
-    eServerPacketType_jTraceStop,       // deprecated
-    eServerPacketType_jTraceConfigRead, // deprecated
-
-    eServerPacketType_jLLDBTraceSupportedType,
+    eServerPacketType_jLLDBTraceSupported,
+    eServerPacketType_jLLDBTraceStart,
+    eServerPacketType_jLLDBTraceStop,
+    eServerPacketType_jLLDBTraceGetState,
+    eServerPacketType_jLLDBTraceGetBinaryData,
   };
 
   ServerPacketType GetServerPacketType() const;
 
   enum ResponseType { eUnsupported = 0, eAck, eNack, eError, eOK, eResponse };
 
   ResponseType GetResponseType() const;
 

lldb/include/lldb/Utility/TraceGDBRemotePackets.h

+//===-- TraceGDBRemotePackets.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_UTILITY_TRACEGDBREMOTEPACKETS_H
+#define LLDB_UTILITY_TRACEGDBREMOTEPACKETS_H
+
+#include "llvm/Support/JSON.h"
+
+#include "lldb/lldb-defines.h"
+#include "lldb/lldb-enumerations.h"
+
+/// See docs/lldb-gdb-remote.txt for more information.
+namespace lldb_private {
+
+/// jLLDBTraceSupported gdb-remote packet
+/// \{
+struct TraceSupportedResponse {
+  /// The name of the technology, e.g. intel-pt or arm-coresight.
+  ///
+  /// In order for a Trace plug-in (see \a lldb_private::Trace.h) to support the
+  /// trace technology given by this struct, it should match its name with this
+  /// field.
+  std::string name;
+  /// The description for the technology.
+  std::string description;
+};
+
+bool fromJSON(const llvm::json::Value &value, TraceSupportedResponse &info,
+              llvm::json::Path path);
+
+llvm::json::Value toJSON(const TraceSupportedResponse &packet);
+/// \}
+
+/// jLLDBTraceStart gdb-remote packet
+/// \{
+struct TraceStartRequest {
+  /// Tracing technology name, e.g. intel-pt, arm-coresight.
+  std::string type;
+  /// If \a llvm::None, then this starts tracing the whole process. Otherwise,
+  /// only tracing for the specified threads is enabled.
+  llvm::Optional<std::vector<int64_t>> tids;
+
+  bool IsProcessTracing() const;
+};
+
+bool fromJSON(const llvm::json::Value &value, TraceStartRequest &packet,
+              llvm::json::Path path);
+
+llvm::json::Value toJSON(const TraceStartRequest &packet);
+/// \}
+
+/// jLLDBTraceStop gdb-remote packet
+/// \{
+struct TraceStopRequest {
+  TraceStopRequest() {}
+
+  TraceStopRequest(llvm::StringRef type, const std::vector<lldb::tid_t> &tids);
+
+  TraceStopRequest(llvm::StringRef type) : type(type){};
+
+  bool IsProcessTracing() const;
+
+  /// Tracing technology name, e.g. intel-pt, arm-coresight.
+  std::string type;
+  /// If \a llvm::None, then this stops tracing the whole process. Otherwise,
+  /// only tracing for the specified threads is stopped.
+  llvm::Optional<std::vector<int64_t>> tids;
+};
+
+bool fromJSON(const llvm::json::Value &value, TraceStopRequest &packet,
+              llvm::json::Path path);
+
+llvm::json::Value toJSON(const TraceStopRequest &packet);
+///}
+
+/// jLLDBTraceGetState gdb-remote packet
+/// \{
+struct TraceGetStateRequest {
+  /// Tracing technology name, e.g. intel-pt, arm-coresight.
+  std::string type;
+};
+
+bool fromJSON(const llvm::json::Value &value, TraceGetStateRequest &packet,
+              llvm::json::Path path);
+
+llvm::json::Value toJSON(const TraceGetStateRequest &packet);
+
+struct TraceBinaryData {
+  /// Identifier of data to fetch with jLLDBTraceGetBinaryData.
+  std::string kind;
+  /// Size in bytes for this data.
+  int64_t size;
+};
+
+bool fromJSON(const llvm::json::Value &value, TraceBinaryData &packet,
+              llvm::json::Path path);
+
+llvm::json::Value toJSON(const TraceBinaryData &packet);
+
+struct TraceThreadState {
+  int64_t tid;
+  /// List of binary data objects for this thread.
+  std::vector<TraceBinaryData> binaryData;
+};
+
+bool fromJSON(const llvm::json::Value &value, TraceThreadState &packet,
+              llvm::json::Path path);
+
+llvm::json::Value toJSON(const TraceThreadState &packet);
+
+struct TraceGetStateResponse {
+  std::vector<TraceThreadState> tracedThreads;
+  std::vector<TraceBinaryData> processBinaryData;
+};
+
+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<int64_t> tid;
+  /// Offset in bytes from where to start reading the data.
+  int64_t offset;
+  /// Number of bytes to read.
+  int64_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/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

+//===-- TraceIntelPTGDBRemotePackets.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_UTILITY_TRACEINTELPTGDBREMOTEPACKETS_H
+#define LLDB_UTILITY_TRACEINTELPTGDBREMOTEPACKETS_H
+
+#include "lldb/Utility/TraceGDBRemotePackets.h"
+
+/// See docs/lldb-gdb-remote.txt for more information.
+namespace lldb_private {
+
+/// jLLDBTraceStart gdb-remote packet
+/// \{
+struct TraceIntelPTStartRequest : TraceStartRequest {
+  /// Size in bytes to use for each thread's trace buffer.
+  int64_t threadBufferSize;
+  /// Required when doing "process tracing".
+  ///
+  /// Limit in bytes on all the thread traces started by this "process trace"
+  /// instance. When a thread is about to be traced and the limit would be hit,
+  /// then a "tracing" stop event is triggered.
+  llvm::Optional<int64_t> processBufferSizeLimit;
+};
+
+bool fromJSON(const llvm::json::Value &value, TraceIntelPTStartRequest &packet,
+              llvm::json::Path path);
+
+llvm::json::Value toJSON(const TraceIntelPTStartRequest &packet);
+/// \}
+
+} // namespace lldb_private
+
+#endif // LLDB_UTILITY_TRACEINTELPTGDBREMOTEPACKETS_H

lldb/include/lldb/Utility/TraceOptions.h

 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 
-/// This struct represents a tracing technology.
-struct TraceTypeInfo {
-  /// The name of the technology, e.g. intel-pt or arm-coresight.
-  ///
-  /// In order for a Trace plug-in (see \a lldb_private::Trace.h) to support the
-  /// trace technology given by this struct, it should match its name with this
-  /// field.
-  std::string name;
-  /// A description for the technology.
-  std::string description;
-};
-
+/// Deprecated
 class TraceOptions {
 public:
   TraceOptions() : m_trace_params(new StructuredData::Dictionary()) {}
 
   const StructuredData::DictionarySP &getTraceParams() const {
     return m_trace_params;
   }
 
private:
   lldb::tid_t m_thread_id;
 
   /// m_trace_params is meant to hold any custom parameters
   /// apart from meta buffer size and trace size.
   /// The interpretation of such parameters is left to
   /// the lldb-server.
   StructuredData::DictionarySP m_trace_params;
 };
-}
-
-namespace llvm {
-namespace json {
-
-bool fromJSON(const Value &value, lldb_private::TraceTypeInfo &info, Path path);
 
-} // namespace json
-} // namespace llvm
+} // namespace lldb_private
 
 #endif // LLDB_UTILITY_TRACEOPTIONS_H

lldb/include/lldb/lldb-enumerations.h

enum StopReason {
   eStopReasonTrace,
   eStopReasonBreakpoint,
   eStopReasonWatchpoint,
   eStopReasonSignal,
   eStopReasonException,
   eStopReasonExec, ///< Program was re-exec'ed
   eStopReasonPlanComplete,
   eStopReasonThreadExiting,
-  eStopReasonInstrumentation
+  eStopReasonInstrumentation,
+  eStopReasonProcessorTrace,
 };
 
 /// Command Return Status Types.
 enum ReturnStatus {
   eReturnStatusInvalid,
   eReturnStatusSuccessFinishNoResult,
   eReturnStatusSuccessFinishResult,
   eReturnStatusSuccessContinuingNoResult,
enum BasicType {
   eBasicTypeLongDoubleComplex,
   eBasicTypeObjCID,
   eBasicTypeObjCClass,
   eBasicTypeObjCSel,
   eBasicTypeNullPtr,
   eBasicTypeOther
 };
 
 /// Deprecated
 enum TraceType {
   eTraceTypeNone = 0,
 
   /// Intel Processor Trace
   eTraceTypeProcessorTrace
 };
 
 enum StructuredDataType {
   eStructuredDataTypeInvalid = -1,
   eStructuredDataTypeNull = 0,
   eStructuredDataTypeGeneric,
   eStructuredDataTypeArray,
   eStructuredDataTypeInteger,
   eStructuredDataTypeFloat,
   eStructuredDataTypeBoolean,
   eStructuredDataTypeString,
   eStructuredDataTypeDictionary
 };
 

lldb/include/lldb/lldb-forward.h

 class ThreadPlanRunToAddress;
 class ThreadPlanStepInstruction;
 class ThreadPlanStepOut;
 class ThreadPlanStepOverBreakpoint;
 class ThreadPlanStepRange;
 class ThreadPlanStepThrough;
 class ThreadPlanTracer;
 class ThreadSpec;
-class ThreadTrace;
+class ThreadPostMortemTrace;
 class Trace;
 class TraceSessionFileParser;
 class TraceOptions;
 class Type;
 class TypeAndOrName;
 class TypeCategoryImpl;
 class TypeCategoryMap;
 class TypeEnumMemberImpl;
typedef std::shared_ptr<lldb_private::SyntheticChildrenFrontEnd>
     SyntheticChildrenFrontEndSP;
 typedef std::shared_ptr<lldb_private::Target> TargetSP;
 typedef std::weak_ptr<lldb_private::Target> TargetWP;
 typedef std::shared_ptr<lldb_private::TargetProperties> TargetPropertiesSP;
 typedef std::shared_ptr<lldb_private::Thread> ThreadSP;
 typedef std::weak_ptr<lldb_private::Thread> ThreadWP;
 typedef std::shared_ptr<lldb_private::ThreadCollection> ThreadCollectionSP;
 typedef std::shared_ptr<lldb_private::ThreadPlan> ThreadPlanSP;
+typedef std::shared_ptr<lldb_private::ThreadPostMortemTrace>
+    ThreadPostMortemTraceSP;
 typedef std::weak_ptr<lldb_private::ThreadPlan> ThreadPlanWP;
 typedef std::shared_ptr<lldb_private::ThreadPlanTracer> ThreadPlanTracerSP;
 typedef std::shared_ptr<lldb_private::Trace> TraceSP;
 typedef std::shared_ptr<lldb_private::TraceOptions> TraceOptionsSP;
 typedef std::shared_ptr<lldb_private::Type> TypeSP;
 typedef std::weak_ptr<lldb_private::Type> TypeWP;
 typedef std::shared_ptr<lldb_private::TypeCategoryImpl> TypeCategoryImplSP;
 typedef std::shared_ptr<lldb_private::TypeImpl> TypeImplSP;

lldb/include/lldb/lldb-private-interfaces.h

 typedef lldb::TypeSystemSP (*TypeSystemCreateInstance)(
     lldb::LanguageType language, Module *module, Target *target);
 typedef lldb::REPLSP (*REPLCreateInstance)(Status &error,
                                            lldb::LanguageType language,
                                            Debugger *debugger, Target *target,
                                            const char *repl_options);
 typedef int (*ComparisonFunction)(const void *, const void *);
 typedef void (*DebuggerInitializeCallback)(Debugger &debugger);
-typedef llvm::Expected<lldb::TraceSP> (*TraceCreateInstance)(
+typedef llvm::Expected<lldb::TraceSP> (*TraceCreateInstanceForSessionFile)(
     const llvm::json::Value &trace_session_file,
     llvm::StringRef session_file_dir, lldb_private::Debugger &debugger);
-typedef lldb::CommandObjectSP (*TraceGetStartCommand)(
-    CommandInterpreter &interpreter);
-
+typedef llvm::Expected<lldb::TraceSP> (*TraceCreateInstanceForLiveProcess)(
+    Process &process);
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 
 #endif // LLDB_LLDB_PRIVATE_INTERFACES_H

lldb/source/API/SBThread.cpp

if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
         switch (reason) {
         case eStopReasonInvalid:
         case eStopReasonNone:
         case eStopReasonTrace:
         case eStopReasonExec:
         case eStopReasonPlanComplete:
         case eStopReasonThreadExiting:
         case eStopReasonInstrumentation:
+        case eStopReasonProcessorTrace:
           // There is no data for these stop reasons.
           return 0;
 
         case eStopReasonBreakpoint: {
           break_id_t site_id = stop_info_sp->GetValue();
           lldb::BreakpointSiteSP bp_site_sp(
               exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID(
                   site_id));
if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
         switch (reason) {
         case eStopReasonInvalid:
         case eStopReasonNone:
         case eStopReasonTrace:
         case eStopReasonExec:
         case eStopReasonPlanComplete:
         case eStopReasonThreadExiting:
         case eStopReasonInstrumentation:
+        case eStopReasonProcessorTrace:
           // There is no data for these stop reasons.
           return 0;
 
         case eStopReasonBreakpoint: {
           break_id_t site_id = stop_info_sp->GetValue();
           lldb::BreakpointSiteSP bp_site_sp(
               exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID(
                   site_id));

lldb/source/API/SBTrace.cpp

void SBTrace::StopTrace(SBError &error, lldb::tid_t thread_id) {
   if (!process_sp) {
     error.SetErrorString("invalid process");
     return;
   }
   error.SetError(process_sp->StopTrace(GetTraceUID(), thread_id));
 }
 
 void SBTrace::GetTraceConfig(SBTraceOptions &options, SBError &error) {
-  LLDB_RECORD_METHOD(void, SBTrace, GetTraceConfig,
-                     (lldb::SBTraceOptions &, lldb::SBError &), options, error);
-
-  ProcessSP process_sp(GetSP());
-  error.Clear();
-
-  if (!process_sp) {
-    error.SetErrorString("invalid process");
-  } else {
-    error.SetError(process_sp->GetTraceConfig(GetTraceUID(),
-                                              *(options.m_traceoptions_sp)));
-  }
+  error.SetErrorString("deprecated");
 }
 
 lldb::user_id_t SBTrace::GetTraceUID() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBTrace, GetTraceUID);
 
   if (m_trace_impl_sp)
     return m_trace_impl_sp->uid;
   return LLDB_INVALID_UID;

lldb/source/Commands/CommandObjectProcess.cpp

 //===-- CommandObjectProcess.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 "CommandObjectProcess.h"
+#include "CommandObjectTrace.h"
 #include "CommandOptionsProcessLaunch.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
else
       result.SetStatus(eReturnStatusFailed);
 
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
+// Next are the subcommands of CommandObjectMultiwordProcessTrace
+
+// CommandObjectProcessTraceStart
+class CommandObjectProcessTraceStart : public CommandObjectTraceProxy {
+public:
+  CommandObjectProcessTraceStart(CommandInterpreter &interpreter)
+      : CommandObjectTraceProxy(
+            /*live_debug_session_only*/ true, interpreter,
+            "process trace start",
+            "Start tracing this process with the corresponding trace "
+            "plug-in.",
+            "process trace start [<trace-options>]") {}
+
+protected:
+  lldb::CommandObjectSP GetDelegateCommand(Trace &trace) override {
+    return trace.GetProcessTraceStartCommand(m_interpreter);
+  }
+};
+
+// CommandObjectProcessTraceStop
+class CommandObjectProcessTraceStop : public CommandObjectParsed {
+public:
+  CommandObjectProcessTraceStop(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "process trace stop",
+                            "Stop tracing this process. This does not affect "
+                            "traces started with the "
+                            "\"thread trace start\" command.",
+                            "process trace stop",
+                            eCommandRequiresProcess | eCommandTryTargetAPILock |
+                                eCommandProcessMustBeLaunched |
+                                eCommandProcessMustBePaused |
+                                eCommandProcessMustBeTraced) {}
+
+  ~CommandObjectProcessTraceStop() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    ProcessSP process_sp = m_exe_ctx.GetProcessSP();
+
+    TraceSP trace_sp = process_sp->GetTarget().GetTrace();
+
+    if (llvm::Error err = trace_sp->StopProcess())
+      result.SetError(toString(std::move(err)));
+    else
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+
+    return result.Succeeded();
+  }
+};
+
+// CommandObjectMultiwordProcessTrace
+class CommandObjectMultiwordProcessTrace : public CommandObjectMultiword {
+public:
+  CommandObjectMultiwordProcessTrace(CommandInterpreter &interpreter)
+      : CommandObjectMultiword(
+            interpreter, "trace", "Commands for tracing the current process.",
+            "process trace <subcommand> [<subcommand objects>]") {
+    LoadSubCommand("start", CommandObjectSP(new CommandObjectProcessTraceStart(
+                                interpreter)));
+    LoadSubCommand("stop", CommandObjectSP(
+                               new CommandObjectProcessTraceStop(interpreter)));
+  }
+
+  ~CommandObjectMultiwordProcessTrace() override = default;
+};
+
 // CommandObjectMultiwordProcess
 
 CommandObjectMultiwordProcess::CommandObjectMultiwordProcess(
     CommandInterpreter &interpreter)
     : CommandObjectMultiword(
           interpreter, "process",
           "Commands for interacting with processes on the current platform.",
           "process <subcommand> [<subcommand-options>]") {
CommandObjectMultiwordProcess::CommandObjectMultiwordProcess(
   LoadSubCommand("interrupt", CommandObjectSP(new CommandObjectProcessInterrupt(
                                   interpreter)));
   LoadSubCommand("kill",
                  CommandObjectSP(new CommandObjectProcessKill(interpreter)));
   LoadSubCommand("plugin",
                  CommandObjectSP(new CommandObjectProcessPlugin(interpreter)));
   LoadSubCommand("save-core", CommandObjectSP(new CommandObjectProcessSaveCore(
                                   interpreter)));
+  LoadSubCommand(
+      "trace",
+      CommandObjectSP(new CommandObjectMultiwordProcessTrace(interpreter)));
 }
 
 CommandObjectMultiwordProcess::~CommandObjectMultiwordProcess() = default;

lldb/source/Commands/CommandObjectThread.cpp

 //===-- CommandObjectThread.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 "CommandObjectThread.h"
 
 #include <sstream>
 
 #include "CommandObjectThreadUtil.h"
+#include "CommandObjectTrace.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupPythonClassWithDict.h"
 #include "lldb/Interpreter/Options.h"
public:
 
   ~CommandObjectMultiwordThreadPlan() override = default;
 };
 
 // Next are the subcommands of CommandObjectMultiwordTrace
 
 // CommandObjectTraceStart
 
-/// This class works by delegating the logic to the actual trace plug-in that
-/// can support the current process.
-class CommandObjectTraceStart : public CommandObjectProxy {
+class CommandObjectTraceStart : public CommandObjectTraceProxy {
 public:
   CommandObjectTraceStart(CommandInterpreter &interpreter)
-      : CommandObjectProxy(interpreter, "thread trace start",
-                           "Start tracing threads with the corresponding trace "
-                           "plug-in for the current process.",
-                           "thread trace start [<trace-options>]") {}
+      : CommandObjectTraceProxy(
+            /*live_debug_session_only*/ true, interpreter, "thread trace start",
 
 protected:
-  llvm::Expected<CommandObjectSP> DoGetProxyCommandObject() {
-    ProcessSP process_sp = m_interpreter.GetExecutionContext().GetProcessSP();
-
-    if (!process_sp)
-      return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                     "Process not available.");
-    if (!process_sp->IsAlive())
-      return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                     "Process must be launched.");
-
-    llvm::Expected<TraceTypeInfo> trace_type =
-        process_sp->GetSupportedTraceType();
-
-    if (!trace_type)
-      return llvm::createStringError(
-          llvm::inconvertibleErrorCode(), "Tracing is not supported. %s",
-          llvm::toString(trace_type.takeError()).c_str());
-
-    CommandObjectSP delegate_sp =
-        PluginManager::GetTraceStartCommand(trace_type->name, m_interpreter);
-    if (!delegate_sp)
-      return llvm::createStringError(
-          llvm::inconvertibleErrorCode(),
-          "No trace plug-in matches the specified type: \"%s\"",
-          trace_type->name.c_str());
-    return delegate_sp;
-  }
-
-  CommandObject *GetProxyCommandObject() override {
-    if (llvm::Expected<CommandObjectSP> delegate = DoGetProxyCommandObject()) {
-      m_delegate_sp = *delegate;
-      m_delegate_error.clear();
-      return m_delegate_sp.get();
-    } else {
-      m_delegate_sp.reset();
-      m_delegate_error = llvm::toString(delegate.takeError());
-      return nullptr;
-    }
+  lldb::CommandObjectSP GetDelegateCommand(Trace &trace) override {
+    return trace.GetThreadTraceStartCommand(m_interpreter);
   }
-
-private:
-  llvm::StringRef GetUnsupportedError() override { return m_delegate_error; }
-
-  CommandObjectSP m_delegate_sp;
-  std::string m_delegate_error;
 };
 
 // CommandObjectTraceStop
 
-class CommandObjectTraceStop : public CommandObjectIterateOverThreads {
+class CommandObjectTraceStop : public CommandObjectMultipleThreads {
 public:
   CommandObjectTraceStop(CommandInterpreter &interpreter)
-      : CommandObjectIterateOverThreads(
+      : CommandObjectMultipleThreads(
             interpreter, "thread trace stop",
-            "Stop tracing threads. "
+            "Stop tracing threads, including the ones traced with the "
+            "\"process trace start\" command."
             "Defaults to the current thread. Thread indices can be "
-            "specified as arguments.\n Use the thread-index \"all\" to trace "
-            "all threads.",
+            "specified as arguments.\n Use the thread-index \"all\" to stop "
+            "tracing "
+            "for all existing threads.",
             "thread trace stop [<thread-index> <thread-index> ...]",
             eCommandRequiresProcess | eCommandTryTargetAPILock |
                 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused |
                 eCommandProcessMustBeTraced) {}
 
   ~CommandObjectTraceStop() override = default;
 
-  bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
-    const Thread &thread =
-        *m_exe_ctx.GetProcessPtr()->GetThreadList().FindThreadByID(tid);
-    Trace &trace = *m_exe_ctx.GetTargetSP()->GetTrace();
+  bool DoExecuteOnThreads(Args &command, CommandReturnObject &result,
+                          const std::vector<lldb::tid_t> &tids) override {
+    ProcessSP process_sp = m_exe_ctx.GetProcessSP();
 
-    if (llvm::Error err = trace.StopTracingThread(thread)) {
-      result.AppendErrorWithFormat("Failed stopping thread %" PRIu64 ": %s\n",
-                                   tid, toString(std::move(err)).c_str());
-      result.SetStatus(eReturnStatusFailed);
-    }
+    TraceSP trace_sp = process_sp->GetTarget().GetTrace();
 
-    // We don't return false on errors to try to stop as many threads as
-    // possible.
-    return true;
+    if (llvm::Error err = trace_sp->StopThreads(tids))
+      result.SetError(toString(std::move(err)));
+    else
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+
+    return result.Succeeded();
   }
 };
 
 // CommandObjectTraceDumpInstructions
 #define LLDB_OPTIONS_thread_trace_dump_instructions
 #include "CommandOptions.inc"
 
 class CommandObjectTraceDumpInstructions

lldb/source/Commands/CommandObjectThreadUtil.h

protected:
   bool BucketThread(lldb::tid_t tid, std::set<UniqueStack> &unique_stacks,
                     CommandReturnObject &result);
 
   lldb::ReturnStatus m_success_return = lldb::eReturnStatusSuccessFinishResult;
   bool m_unique_stacks = false;
   bool m_add_return = true;
 };
 
+/// Class similar to \a CommandObjectIterateOverThreads, but which performs
+/// an action on multiple threads at once instead of iterating over each thread.
+class CommandObjectMultipleThreads : public CommandObjectParsed {
+public:
+  using CommandObjectParsed::CommandObjectParsed;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override;
+
+protected:
+  /// Method that handles the command after the main arguments have been parsed.
+  ///
+  /// \param[in] tids
+  ///     The thread ids passed as arguments.
+  ///
+  /// \return
+  ///     A boolean result similar to the one expected from \a DoExecute.
+  virtual bool DoExecuteOnThreads(Args &command, CommandReturnObject &result,
+                                  const std::vector<lldb::tid_t> &tids) = 0;
+};
+
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_COMMANDS_COMMANDOBJECTTHREADUTIL_H

lldb/source/Commands/CommandObjectThreadUtil.cpp

std::set<UniqueStack>::iterator matching_stack =
       unique_stacks.find(new_unique_stack);
   if (matching_stack != unique_stacks.end()) {
     matching_stack->AddThread(thread_index_id);
   } else {
     unique_stacks.insert(new_unique_stack);
   }
   return true;
 }
+
+bool CommandObjectMultipleThreads::DoExecute(Args &command,
+                                             CommandReturnObject &result) {
+  Process &process = m_exe_ctx.GetProcessRef();
+
+  std::vector<lldb::tid_t> tids;
+  const size_t num_args = command.GetArgumentCount();
+
+  std::lock_guard<std::recursive_mutex> guard(
+      process.GetThreadList().GetMutex());
+
+  if (num_args > 0 && ::strcmp(command.GetArgumentAtIndex(0), "all") == 0) {
+    for (ThreadSP thread_sp : process.Threads())
+      tids.push_back(thread_sp->GetID());
+  } else {
+    if (num_args == 0) {
+      Thread &thread = m_exe_ctx.GetThreadRef();
+      tids.push_back(thread.GetID());
+    }
+
+    for (size_t i = 0; i < num_args; i++) {
+      uint32_t thread_idx;
+      if (!llvm::to_integer(command.GetArgumentAtIndex(i), thread_idx)) {
+        result.AppendErrorWithFormat("invalid thread specification: \"%s\"\n",
+                                     command.GetArgumentAtIndex(i));
+        result.SetStatus(eReturnStatusFailed);
+        return false;
+      }
+
+      ThreadSP thread = process.GetThreadList().FindThreadByIndexID(thread_idx);
+
+      if (!thread) {
+        result.AppendErrorWithFormat("no thread with index: \"%s\"\n",
+                                     command.GetArgumentAtIndex(i));
+        result.SetStatus(eReturnStatusFailed);
+        return false;
+      }
+
+      tids.push_back(thread->GetID());
+    }
+  }
+
+  return DoExecuteOnThreads(command, result, tids);
+}

lldb/source/Commands/CommandObjectTrace.h

 //===-- CommandObjectTrace.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_COMMANDS_COMMANDOBJECTTRACE_H
 #define LLDB_SOURCE_COMMANDS_COMMANDOBJECTTRACE_H
 
-#include "lldb/Interpreter/CommandObjectMultiword.h"
+#include "CommandObjectThreadUtil.h"
 
 namespace lldb_private {
 
 class CommandObjectTrace : public CommandObjectMultiword {
 public:
   CommandObjectTrace(CommandInterpreter &interpreter);
 
   ~CommandObjectTrace() override;
 };
 
+/// This class works by delegating the logic to the actual trace plug-in that
+/// can support the current process.
+class CommandObjectTraceProxy : public CommandObjectProxy {
+public:
+  CommandObjectTraceProxy(bool live_debug_session_only,
+                          CommandInterpreter &interpreter, const char *name,
+                          const char *help = nullptr,
+                          const char *syntax = nullptr, uint32_t flags = 0)
+      : CommandObjectProxy(interpreter, name, help, syntax, flags),
+        m_live_debug_session_only(live_debug_session_only) {}
+
+protected:
+  virtual lldb::CommandObjectSP GetDelegateCommand(Trace &trace) = 0;
+
+  llvm::Expected<lldb::CommandObjectSP> DoGetProxyCommandObject();
+
+  CommandObject *GetProxyCommandObject() override;
+
+private:
+  llvm::StringRef GetUnsupportedError() override { return m_delegate_error; }
+
+  bool m_live_debug_session_only;
+  lldb::CommandObjectSP m_delegate_sp;
+  std::string m_delegate_error;
+};
+
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_COMMANDS_COMMANDOBJECTTRACE_H

lldb/source/Commands/CommandObjectTrace.cpp

 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Interpreter/OptionValueLanguage.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Interpreter/Options.h"
+#include "lldb/Target/Process.h"
 #include "lldb/Target/Trace.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm;
 
 // CommandObjectTraceLoad
 #define LLDB_OPTIONS_trace_load
bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
 
     llvm::Expected<json::Value> session_file =
         json::parse(buffer_or_error.get()->getBuffer().str());
     if (!session_file)
       return end_with_failure(session_file.takeError());
 
     if (Expected<lldb::TraceSP> traceOrErr =
-            Trace::FindPlugin(GetDebugger(), *session_file,
-                              json_file.GetDirectory().AsCString())) {
+            Trace::FindPluginForPostMortemProcess(
+                GetDebugger(), *session_file,
       lldb::TraceSP trace_sp = traceOrErr.get();
       if (m_options.m_verbose && trace_sp)
         result.AppendMessageWithFormat("loading trace with plugin %s\n",
                                        trace_sp->GetPluginName().AsCString());
     } else
       return end_with_failure(traceOrErr.takeError());
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
LoadSubCommand("load",
                  CommandObjectSP(new CommandObjectTraceLoad(interpreter)));
   LoadSubCommand("dump",
                  CommandObjectSP(new CommandObjectTraceDump(interpreter)));
   LoadSubCommand("schema",
                  CommandObjectSP(new CommandObjectTraceSchema(interpreter)));
 }
 
 CommandObjectTrace::~CommandObjectTrace() = default;
+
+Expected<CommandObjectSP> CommandObjectTraceProxy::DoGetProxyCommandObject() {
+  ProcessSP process_sp = m_interpreter.GetExecutionContext().GetProcessSP();
+
+  if (!process_sp)
+    return createStringError(inconvertibleErrorCode(),
+                             "Process not available.");
+  if (m_live_debug_session_only && !process_sp->IsLiveDebugSession())
+    return createStringError(inconvertibleErrorCode(),
+                             "Process must be alive.");
+
+  if (Expected<TraceSP &> trace_sp = process_sp->GetTarget().GetTraceOrCreate())
+    return GetDelegateCommand(**trace_sp);
+  else
+    return createStringError(inconvertibleErrorCode(),
+                             "Tracing is not supported. %s",
+                             toString(trace_sp.takeError()).c_str());
+}
+
+CommandObject *CommandObjectTraceProxy::GetProxyCommandObject() {
+  if (Expected<CommandObjectSP> delegate = DoGetProxyCommandObject()) {
+    m_delegate_sp = *delegate;
+    m_delegate_error.clear();
+    return m_delegate_sp.get();
+  } else {
+    m_delegate_sp.reset();
+    m_delegate_error = toString(delegate.takeError());
+    return nullptr;
+  }
+}

lldb/source/Core/PluginManager.cpp

 
 SymbolVendorCreateInstance
 PluginManager::GetSymbolVendorCreateCallbackAtIndex(uint32_t idx) {
   return GetSymbolVendorInstances().GetCallbackAtIndex(idx);
 }
 
 #pragma mark Trace
 
-struct TraceInstance : public PluginInstance<TraceCreateInstance> {
-  TraceInstance(ConstString name, std::string description,
-                CallbackType create_callback, llvm::StringRef schema,
-                TraceGetStartCommand get_start_command)
-      : PluginInstance<TraceCreateInstance>(name, std::move(description),
-                                            create_callback),
-        schema(schema), get_start_command(get_start_command) {}
+struct TraceInstance
+    : public PluginInstance<TraceCreateInstanceForSessionFile> {
+  TraceInstance(
+      ConstString name, std::string description,
+      CallbackType create_callback_for_session_file,
+      TraceCreateInstanceForLiveProcess create_callback_for_live_process,
+      llvm::StringRef schema)
+      : PluginInstance<TraceCreateInstanceForSessionFile>(
+            name, std::move(description), create_callback_for_session_file),
+        schema(schema),
+        create_callback_for_live_process(create_callback_for_live_process) {}
 
   llvm::StringRef schema;
-  TraceGetStartCommand get_start_command;
+  TraceCreateInstanceForLiveProcess create_callback_for_live_process;
 };
 
 typedef PluginInstances<TraceInstance> TraceInstances;
 
 static TraceInstances &GetTracePluginInstances() {
   static TraceInstances g_instances;
   return g_instances;
 }
 
-bool PluginManager::RegisterPlugin(ConstString name, const char *description,
-                                   TraceCreateInstance create_callback,
-                                   llvm::StringRef schema,
-                                   TraceGetStartCommand get_start_command) {
+bool PluginManager::RegisterPlugin(
+    ConstString name, const char *description,
+    TraceCreateInstanceForSessionFile create_callback_for_session_file,
+    TraceCreateInstanceForLiveProcess create_callback_for_live_process,
+    llvm::StringRef schema) {
   return GetTracePluginInstances().RegisterPlugin(
-      name, description, create_callback, schema, get_start_command);
+      name, description, create_callback_for_session_file,
+      create_callback_for_live_process, schema);
 }
 
-bool PluginManager::UnregisterPlugin(TraceCreateInstance create_callback) {
-  return GetTracePluginInstances().UnregisterPlugin(create_callback);
+bool PluginManager::UnregisterPlugin(
+    TraceCreateInstanceForSessionFile create_callback_for_session_file) {
+  return GetTracePluginInstances().UnregisterPlugin(
+      create_callback_for_session_file);
 }
 
-TraceCreateInstance
+TraceCreateInstanceForSessionFile
 PluginManager::GetTraceCreateCallback(ConstString plugin_name) {
   return GetTracePluginInstances().GetCallbackForName(plugin_name);
 }
 
-llvm::StringRef PluginManager::GetTraceSchema(ConstString plugin_name) {
+TraceCreateInstanceForLiveProcess
+PluginManager::GetTraceCreateCallbackForLiveProcess(ConstString plugin_name) {
   for (const TraceInstance &instance : GetTracePluginInstances().GetInstances())
     if (instance.name == plugin_name)
-      return instance.schema;
-  return llvm::StringRef();
+      return instance.create_callback_for_live_process;
+  return nullptr;
 }
 
-CommandObjectSP
-PluginManager::GetTraceStartCommand(llvm::StringRef plugin_name,
-                                    CommandInterpreter &interpreter) {
+llvm::StringRef PluginManager::GetTraceSchema(ConstString plugin_name) {
   for (const TraceInstance &instance : GetTracePluginInstances().GetInstances())
-    if (instance.name.GetStringRef() == plugin_name)
-      return instance.get_start_command(interpreter);
-  return CommandObjectSP();
+    if (instance.name == plugin_name)
+      return instance.schema;
+  return llvm::StringRef();
 }
 
 llvm::StringRef PluginManager::GetTraceSchema(size_t index) {
   if (TraceInstance *instance =
           GetTracePluginInstances().GetInstanceAtIndex(index))
     return instance->schema;
   return llvm::StringRef();
 }

lldb/source/Interpreter/CommandInterpreter.cpp

if (eStateStopped != process_sp->GetState())
     return false;
 
   for (const auto &thread_sp : process_sp->GetThreadList().Threads()) {
     StopInfoSP stop_info = thread_sp->GetStopInfo();
     if (!stop_info)
       return false;
 
     const StopReason reason = stop_info->GetStopReason();
-    if (reason == eStopReasonException || reason == eStopReasonInstrumentation)
+    if (reason == eStopReasonException ||
+        reason == eStopReasonInstrumentation ||
+        reason == eStopReasonProcessorTrace)
       return true;
 
     if (reason == eStopReasonSignal) {
       const auto stop_signal = static_cast<int32_t>(stop_info->GetValue());
       UnixSignalsSP signals_sp = process_sp->GetUnixSignals();
       if (!signals_sp || !signals_sp->SignalIsValid(stop_signal))
         // The signal is unknown, treat it as abnormal.
         return true;

lldb/source/Plugins/Process/Linux/CMakeLists.txt

 add_lldb_library(lldbPluginProcessLinux
+  IntelPTManager.cpp
   NativeProcessLinux.cpp
   NativeRegisterContextLinux.cpp
   NativeRegisterContextLinux_arm.cpp
   NativeRegisterContextLinux_arm64.cpp
   NativeRegisterContextLinux_ppc64le.cpp
   NativeRegisterContextLinux_s390x.cpp
   NativeRegisterContextLinux_x86_64.cpp
   NativeThreadLinux.cpp
-  ProcessorTrace.cpp
   SingleStepCheck.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbSymbol
     lldbTarget
     lldbUtility
     lldbPluginProcessPOSIX
     lldbPluginProcessUtility
   LINK_COMPONENTS
     Support
   )

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

+//===-- IntelPTManager.h -------------------------------------- -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_IntelPTManager_H_
+#define liblldb_IntelPTManager_H_
+
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
+#include "lldb/lldb-types.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
+
+#include <linux/perf_event.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+namespace lldb_private {
+
+namespace process_linux {
+
+/// This class keeps track of one tracing instance of
+/// Intel(R) Processor Trace on Linux OS at thread level.
+///
+/// The kernel interface for us is the perf_event_open.
+class IntelPTThreadTrace;
+typedef std::unique_ptr<IntelPTThreadTrace> IntelPTThreadTraceUP;
+
+class IntelPTThreadTrace {
+
+  class munmap_delete {
+    size_t m_length;
+
+  public:
+    munmap_delete(size_t length) : m_length(length) {}
+    void operator()(void *ptr) {
+      if (m_length)
+        munmap(ptr, m_length);
+    }
+  };
+
+  class file_close {
+
+  public:
+    file_close() = default;
+    void operator()(int *ptr) {
+      if (ptr == nullptr)
+        return;
+      if (*ptr == -1)
+        return;
+      close(*ptr);
+      std::default_delete<int>()(ptr);
+    }
+  };
+
+  std::unique_ptr<perf_event_mmap_page, munmap_delete> m_mmap_meta;
+  std::unique_ptr<uint8_t, munmap_delete> m_mmap_aux;
+  std::unique_ptr<int, file_close> m_fd;
+  lldb::tid_t m_tid;
+
+  /// Start tracing a thread
+  ///
+  /// \param[in] pid
+  ///     The pid of the process whose thread will be traced.
+  ///
+  /// \param[in] buffer_size
+  ///     Size of the thread buffer in bytes.
+  ///
+  /// \return
+  ///     \a llvm::Error::success if tracing was successful, or an
+  ///     \a llvm::Error otherwise.
+  llvm::Error StartTrace(lldb::pid_t pid, lldb::tid_t tid,
+                         uint64_t buffer_size);
+
+  llvm::MutableArrayRef<uint8_t> GetAuxBuffer() const;
+  llvm::MutableArrayRef<uint8_t> GetDataBuffer() const;
+
+  IntelPTThreadTrace()
+      : m_mmap_meta(nullptr, munmap_delete(0)),
+        m_mmap_aux(nullptr, munmap_delete(0)), m_fd(nullptr, file_close()) {}
+
+public:
+  /// Get the content of /proc/cpuinfo that can be later used to decode traces.
+  static llvm::Expected<llvm::ArrayRef<uint8_t>> GetCPUInfo();
+
+  /// Start tracing a thread.
+  ///
+  /// See \a StartTrace.
+  ///
+  /// \return
+  ///   A \a IntelPTThreadTrace instance if tracing was successful, or
+  ///   an \a llvm::Error otherwise.
+  static llvm::Expected<IntelPTThreadTraceUP>
+  Create(lldb::pid_t pid, lldb::tid_t tid, size_t buffer_size);
+
+  /// Read the trace buffer of the currently traced thread.
+  ///
+  /// \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>> GetIntelPTBuffer(size_t offset,
+                                                        size_t size) const;
+
+  Status ReadPerfTraceAux(llvm::MutableArrayRef<uint8_t> &buffer,
+                          size_t offset = 0) const;
+
+  Status ReadPerfTraceData(llvm::MutableArrayRef<uint8_t> &buffer,
+                           size_t offset = 0) const;
+
+  /// Get the size in bytes of the aux section of the thread or process traced
+  /// by this object.
+  size_t GetTraceBufferSize() const;
+
+  /// 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.
+  static void ReadCyclicBuffer(llvm::MutableArrayRef<uint8_t> &dst,
+                               llvm::MutableArrayRef<uint8_t> src,
+                               size_t src_cyc_index, size_t offset);
+
+  /// Return the thread-specific part of the jLLDBTraceGetState packet.
+  TraceThreadState GetState() const;
+};
+
+/// Manages a list of thread traces.
+class IntelPTThreadTraceCollection {
+public:
+  IntelPTThreadTraceCollection(lldb::pid_t pid) : m_pid(pid) {}
+
+  /// Dispose of all traces
+  void Clear();
+
+  bool TracesThread(lldb::tid_t tid) const;
+
+  size_t GetTotalBufferSize() const;
+
+  std::vector<TraceThreadState> GetThreadStates() const;
+
+  llvm::Expected<const IntelPTThreadTrace &>
+  GetTracedThread(lldb::tid_t tid) const;
+
+  llvm::Error TraceStart(lldb::tid_t tid,
+                         const TraceIntelPTStartRequest &request);
+
+  llvm::Error TraceStop(lldb::tid_t tid);
+
+private:
+  lldb::pid_t m_pid;
+  llvm::DenseMap<lldb::tid_t, IntelPTThreadTraceUP> m_thread_traces;
+  /// Total actual thread buffer size in bytes
+  size_t m_total_buffer_size = 0;
+};
+
+/// Manages a "process trace" instance.
+class IntelPTProcessTrace {
+public:
+  IntelPTProcessTrace(lldb::pid_t pid, const TraceIntelPTStartRequest &request)
+      : m_thread_traces(pid), m_tracing_params(request) {}
+
+  bool TracesThread(lldb::tid_t tid) const;
+
+  const IntelPTThreadTraceCollection &GetThreadTraces() const;
+
+  llvm::Error TraceStart(lldb::tid_t tid);
+
+  llvm::Error TraceStop(lldb::tid_t tid);
+
+private:
+  IntelPTThreadTraceCollection m_thread_traces;
+  /// Params used to trace threads when the user started "process tracing".
+  TraceIntelPTStartRequest m_tracing_params;
+};
+
+/// Main class that manages intel-pt process and thread tracing.
+class IntelPTManager {
+public:
+  IntelPTManager(lldb::pid_t pid) : m_pid(pid), m_thread_traces(pid) {}
+
+  static bool IsSupported();
+
+  /// If "process tracing" is enabled, then trace the given thread.
+  llvm::Error OnThreadCreated(lldb::tid_t tid);
+
+  /// Stops tracing a tracing upon a destroy event.
+  llvm::Error OnThreadDestroyed(lldb::tid_t tid);
+
+  /// Implementation of the jLLDBTraceStop packet
+  llvm::Error TraceStop(const TraceStopRequest &request);
+
+  /// Implementation of the jLLDBTraceStart packet
+  ///
+  /// \param[in] process_threads
+  ///     A list of all threads owned by the process.
+  llvm::Error TraceStart(const TraceIntelPTStartRequest &request,
+                         const std::vector<lldb::tid_t> &process_threads);
+
+  /// Implementation of the jLLDBTraceGetState packet
+  llvm::Expected<llvm::json::Value> GetState() const;
+
+  /// Implementation of the jLLDBTraceGetBinaryData packet
+  llvm::Expected<std::vector<uint8_t>>
+  GetBinaryData(const TraceGetBinaryDataRequest &request) const;
+
+  /// Dispose of all traces
+  void Clear();
+
+private:
+  llvm::Error TraceStop(lldb::tid_t tid);
+
+  /// Start tracing a specific thread.
+  llvm::Error TraceStart(lldb::tid_t tid,
+                         const TraceIntelPTStartRequest &request);
+
+  llvm::Expected<const IntelPTThreadTrace &>
+  GetTracedThread(lldb::tid_t tid) const;
+
+  bool IsProcessTracingEnabled() const;
+
+  void ClearProcessTracing();
+
+  lldb::pid_t m_pid;
+  /// Threads traced due to "thread tracing"
+  IntelPTThreadTraceCollection m_thread_traces;
+  /// Threads traced due to "process tracing". Only one active "process tracing"
+  /// instance is assumed for a single process.
+  llvm::Optional<IntelPTProcessTrace> m_process_trace;
+};
+
+} // namespace process_linux
+} // namespace lldb_private
+
+#endif // liblldb_IntelPTManager_H_

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

+//===-- IntelPTManager.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 <algorithm>
+#include <fstream>
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MathExtras.h"
+
+#include "IntelPTManager.h"
+#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
+#include "lldb/Host/linux/Support.h"
+#include "lldb/Utility/StreamString.h"
+
+#include <sys/ioctl.h>
+#include <sys/syscall.h>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace process_linux;
+using namespace llvm;
+
+const char *kOSEventIntelPTTypeFile =
+    "/sys/bus/event_source/devices/intel_pt/type";
+
+/// Return the Linux perf event type for Intel PT.
+static Expected<uint32_t> GetOSEventType() {
+  auto intel_pt_type_text =
+      llvm::MemoryBuffer::getFileAsStream(kOSEventIntelPTTypeFile);
+
+  if (!intel_pt_type_text)
+    return createStringError(inconvertibleErrorCode(),
+                             "Can't open the file '%s'",
+                             kOSEventIntelPTTypeFile);
+
+  uint32_t intel_pt_type = 0;
+  StringRef buffer = intel_pt_type_text.get()->getBuffer();
+  if (buffer.trim().getAsInteger(10, intel_pt_type))
+    return createStringError(
+        inconvertibleErrorCode(),
+        "The file '%s' has a invalid value. It should be an unsigned int.",
+        kOSEventIntelPTTypeFile);
+  return intel_pt_type;
+}
+
+size_t IntelPTThreadTrace::GetTraceBufferSize() const {
+  return m_mmap_meta->aux_size;
+}
+
+Error IntelPTThreadTrace::StartTrace(lldb::pid_t pid, lldb::tid_t tid,
+                                     uint64_t buffer_size) {
+#ifndef PERF_ATTR_SIZE_VER5
+  llvm_unreachable("Intel PT Linux perf event not supported");
+#else
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
+
+  m_tid = tid;
+  LLDB_LOG(log, "called thread id {0}", tid);
+  uint64_t page_size = getpagesize();
+
+  if (__builtin_popcount(buffer_size) != 1 || buffer_size < 4096) {
+    return createStringError(
+        inconvertibleErrorCode(),
+        "The trace buffer size must be a power of 2 greater than or equal to "
+        "4096 (2^12) bytes. It was %" PRIu64 ".",
+        buffer_size);
+  }
+  uint64_t numpages = static_cast<uint64_t>(
+      llvm::PowerOf2Floor((buffer_size + page_size - 1) / page_size));
+  numpages = std::max<uint64_t>(1, numpages);
+  buffer_size = page_size * numpages;
+
+  perf_event_attr attr;
+  memset(&attr, 0, sizeof(attr));
+  attr.size = sizeof(attr);
+  attr.exclude_kernel = 1;
+  attr.sample_type = PERF_SAMPLE_TIME;
+  attr.sample_id_all = 1;
+  attr.exclude_hv = 1;
+  attr.exclude_idle = 1;
+  attr.mmap = 1;
+  attr.config = 0;
+
+  Expected<uint32_t> intel_pt_type = GetOSEventType();
+
+  if (!intel_pt_type)
+    return intel_pt_type.takeError();
+
+  LLDB_LOG(log, "intel pt type {0}", *intel_pt_type);
+  attr.type = *intel_pt_type;
+
+  LLDB_LOG(log, "buffer size {0} ", buffer_size);
+
+  errno = 0;
+  auto fd =
+      syscall(SYS_perf_event_open, &attr, static_cast<::tid_t>(tid), -1, -1, 0);
+  if (fd == -1) {
+    LLDB_LOG(log, "syscall error {0}", errno);
+    return createStringError(inconvertibleErrorCode(),
+                             "perf event syscall failed");
+  }
+
+  m_fd = std::unique_ptr<int, file_close>(new int(fd), file_close());
+
+  errno = 0;
+  auto base =
+      mmap(nullptr, (buffer_size + page_size), PROT_WRITE, MAP_SHARED, fd, 0);
+
+  if (base == MAP_FAILED) {
+    LLDB_LOG(log, "mmap base error {0}", errno);
+    return createStringError(inconvertibleErrorCode(),
+                             "Meta buffer allocation failed");
+  }
+
+  m_mmap_meta = std::unique_ptr<perf_event_mmap_page, munmap_delete>(
+      reinterpret_cast<perf_event_mmap_page *>(base),
+      munmap_delete(buffer_size + page_size));
+
+  m_mmap_meta->aux_offset = m_mmap_meta->data_offset + m_mmap_meta->data_size;
+  m_mmap_meta->aux_size = buffer_size;
+
+  errno = 0;
+  auto mmap_aux = mmap(nullptr, buffer_size, PROT_READ, MAP_SHARED, fd,
+                       static_cast<long int>(m_mmap_meta->aux_offset));
+
+  if (mmap_aux == MAP_FAILED) {
+    LLDB_LOG(log, "second mmap done {0}", errno);
+    return createStringError(inconvertibleErrorCode(),
+                             "Trace buffer allocation failed");
+  }
+  m_mmap_aux = std::unique_ptr<uint8_t, munmap_delete>(
+      reinterpret_cast<uint8_t *>(mmap_aux), munmap_delete(buffer_size));
+  return Error::success();
+#endif
+}
+
+llvm::MutableArrayRef<uint8_t> IntelPTThreadTrace::GetDataBuffer() const {
+#ifndef PERF_ATTR_SIZE_VER5
+  llvm_unreachable("Intel PT Linux perf event not supported");
+#else
+  return MutableArrayRef<uint8_t>(
+      (reinterpret_cast<uint8_t *>(m_mmap_meta.get()) +
+       m_mmap_meta->data_offset),
+      m_mmap_meta->data_size);
+#endif
+}
+
+llvm::MutableArrayRef<uint8_t> IntelPTThreadTrace::GetAuxBuffer() const {
+#ifndef PERF_ATTR_SIZE_VER5
+  llvm_unreachable("Intel PT Linux perf event not supported");
+#else
+  return MutableArrayRef<uint8_t>(m_mmap_aux.get(), m_mmap_meta->aux_size);
+#endif
+}
+
+Expected<ArrayRef<uint8_t>> IntelPTThreadTrace::GetCPUInfo() {
+  static llvm::Optional<std::vector<uint8_t>> cpu_info;
+  if (!cpu_info) {
+    auto buffer_or_error = getProcFile("cpuinfo");
+    if (!buffer_or_error)
+      return Status(buffer_or_error.getError()).ToError();
+    MemoryBuffer &buffer = **buffer_or_error;
+    cpu_info = std::vector<uint8_t>(
+        reinterpret_cast<const uint8_t *>(buffer.getBufferStart()),
+        reinterpret_cast<const uint8_t *>(buffer.getBufferEnd()));
+  }
+  return *cpu_info;
+}
+
+llvm::Expected<IntelPTThreadTraceUP>
+IntelPTThreadTrace::Create(lldb::pid_t pid, lldb::tid_t tid,
+                           size_t buffer_size) {
+  IntelPTThreadTraceUP thread_trace_up(new IntelPTThreadTrace());
+
+  if (llvm::Error err = thread_trace_up->StartTrace(pid, tid, buffer_size))
+    return std::move(err);
+
+  return std::move(thread_trace_up);
+}
+
+Expected<std::vector<uint8_t>>
+IntelPTThreadTrace::GetIntelPTBuffer(size_t offset, size_t size) const {
+  std::vector<uint8_t> data(size, 0);
+  MutableArrayRef<uint8_t> buffer_ref(data);
+  Status error = ReadPerfTraceAux(buffer_ref, 0);
+  if (error.Fail())
+    return error.ToError();
+  return data;
+}
+
+Status
+IntelPTThreadTrace::ReadPerfTraceAux(llvm::MutableArrayRef<uint8_t> &buffer,
+                                     size_t offset) const {
+#ifndef PERF_ATTR_SIZE_VER5
+  llvm_unreachable("perf event not supported");
+#else
+  // Disable the perf event to force a flush out of the CPU's internal buffer.
+  // Besides, we can guarantee that the CPU won't override any data as we are
+  // reading the buffer.
+  //
+  // The Intel documentation says:
+  //
+  // Packets are first buffered internally and then written out asynchronously.
+  // To collect packet output for postprocessing, a collector needs first to
+  // ensure that all packet data has been flushed from internal buffers.
+  // Software can ensure this by stopping packet generation by clearing
+  // IA32_RTIT_CTL.TraceEn (see “Disabling Packet Generation” in
+  // Section 35.2.7.2).
+  //
+  // This is achieved by the PERF_EVENT_IOC_DISABLE ioctl request, as mentioned
+  // in the man page of perf_event_open.
+  ioctl(*m_fd, PERF_EVENT_IOC_DISABLE);
+
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
+  Status error;
+  uint64_t head = m_mmap_meta->aux_head;
+
+  LLDB_LOG(log, "Aux size -{0} , Head - {1}", m_mmap_meta->aux_size, head);
+
+  /**
+   * 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  ->|
+   *
+   * */
+
+  ReadCyclicBuffer(buffer, GetAuxBuffer(), static_cast<size_t>(head), offset);
+  LLDB_LOG(log, "ReadCyclic BUffer Done");
+
+  // Reenable tracing now we have read the buffer
+  ioctl(*m_fd, PERF_EVENT_IOC_ENABLE);
+  return error;
+#endif
+}
+
+Status
+IntelPTThreadTrace::ReadPerfTraceData(llvm::MutableArrayRef<uint8_t> &buffer,
+                                      size_t offset) const {
+#ifndef PERF_ATTR_SIZE_VER5
+  llvm_unreachable("perf event not supported");
+#else
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
+  uint64_t bytes_remaining = buffer.size();
+  Status error;
+
+  uint64_t head = m_mmap_meta->data_head;
+
+  /*
+   * 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
+   */
+
+  LLDB_LOG(log, "bytes_remaining - {0}", bytes_remaining);
+
+  auto data_buffer = GetDataBuffer();
+
+  if (head > data_buffer.size()) {
+    head = head % data_buffer.size();
+    LLDB_LOG(log, "Data size -{0} Head - {1}", m_mmap_meta->data_size, head);
+
+    ReadCyclicBuffer(buffer, data_buffer, static_cast<size_t>(head), offset);
+    bytes_remaining -= buffer.size();
+  } else {
+    LLDB_LOG(log, "Head - {0}", head);
+    if (offset >= head) {
+      LLDB_LOG(log, "Invalid Offset ");
+      error.SetErrorString("invalid offset");
+      buffer = buffer.slice(buffer.size());
+      return error;
+    }
+
+    auto data = data_buffer.slice(offset, (head - offset));
+    auto remaining = std::copy(data.begin(), data.end(), buffer.begin());
+    bytes_remaining -= (remaining - buffer.begin());
+  }
+  buffer = buffer.drop_back(bytes_remaining);
+  return error;
+#endif
+}
+
+void IntelPTThreadTrace::ReadCyclicBuffer(llvm::MutableArrayRef<uint8_t> &dst,
+                                          llvm::MutableArrayRef<uint8_t> src,
+                                          size_t src_cyc_index, size_t offset) {
+
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
+
+  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<MutableArrayRef<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);
+}
+
+TraceThreadState IntelPTThreadTrace::GetState() const {
+  return {static_cast<int64_t>(m_tid),
+          {TraceBinaryData{"threadTraceBuffer",
+                           static_cast<int64_t>(GetTraceBufferSize())}}};
+}
+
+/// IntelPTThreadTraceCollection
+
+bool IntelPTThreadTraceCollection::TracesThread(lldb::tid_t tid) const {
+  return m_thread_traces.count(tid);
+}
+
+Error IntelPTThreadTraceCollection::TraceStop(lldb::tid_t tid) {
+  auto it = m_thread_traces.find(tid);
+  if (it == m_thread_traces.end())
+    return createStringError(inconvertibleErrorCode(),
+                             "Thread %" PRIu64 " not currently traced", tid);
+  m_total_buffer_size -= it->second->GetTraceBufferSize();
+  m_thread_traces.erase(tid);
+  return Error::success();
+}
+
+Error IntelPTThreadTraceCollection::TraceStart(
+    lldb::tid_t tid, const TraceIntelPTStartRequest &request) {
+  if (TracesThread(tid))
+    return createStringError(inconvertibleErrorCode(),
+                             "Thread %" PRIu64 " already traced", tid);
+
+  Expected<IntelPTThreadTraceUP> trace_up =
+      IntelPTThreadTrace::Create(m_pid, tid, request.threadBufferSize);
+  if (!trace_up)
+    return trace_up.takeError();
+
+  m_total_buffer_size += (*trace_up)->GetTraceBufferSize();
+  m_thread_traces.try_emplace(tid, std::move(*trace_up));
+  return Error::success();
+}
+
+size_t IntelPTThreadTraceCollection::GetTotalBufferSize() const {
+  return m_total_buffer_size;
+}
+
+std::vector<TraceThreadState>
+IntelPTThreadTraceCollection::GetThreadStates() const {
+  std::vector<TraceThreadState> states;
+  for (const auto &it : m_thread_traces)
+    states.push_back(it.second->GetState());
+  return states;
+}
+
+Expected<const IntelPTThreadTrace &>
+IntelPTThreadTraceCollection::GetTracedThread(lldb::tid_t tid) const {
+  auto it = m_thread_traces.find(tid);
+  if (it == m_thread_traces.end())
+    return createStringError(inconvertibleErrorCode(),
+                             "Thread %" PRIu64 " not currently traced", tid);
+  return *it->second.get();
+}
+
+void IntelPTThreadTraceCollection::Clear() {
+  m_thread_traces.clear();
+  m_total_buffer_size = 0;
+}
+
+/// IntelPTProcessTrace
+
+bool IntelPTProcessTrace::TracesThread(lldb::tid_t tid) const {
+  return m_thread_traces.TracesThread(tid);
+}
+
+Error IntelPTProcessTrace::TraceStop(lldb::tid_t tid) {
+  return m_thread_traces.TraceStop(tid);
+}
+
+Error IntelPTProcessTrace::TraceStart(lldb::tid_t tid) {
+  if (m_thread_traces.GetTotalBufferSize() + m_tracing_params.threadBufferSize >
+      static_cast<size_t>(*m_tracing_params.processBufferSizeLimit))
+    return createStringError(
+        inconvertibleErrorCode(),
+        "Thread %" PRIu64 " can't be traced as the process trace size limit "
+        "has been reached. Consider retracing with a higher "
+        "limit.",
+        tid);
+
+  return m_thread_traces.TraceStart(tid, m_tracing_params);
+}
+
+const IntelPTThreadTraceCollection &
+IntelPTProcessTrace::GetThreadTraces() const {
+  return m_thread_traces;
+}
+
+/// IntelPTManager
+
+Error IntelPTManager::TraceStop(lldb::tid_t tid) {
+  if (IsProcessTracingEnabled() && m_process_trace->TracesThread(tid))
+    return m_process_trace->TraceStop(tid);
+  return m_thread_traces.TraceStop(tid);
+}
+
+Error IntelPTManager::TraceStop(const TraceStopRequest &request) {
+  if (request.IsProcessTracing()) {
+    if (!IsProcessTracingEnabled()) {
+      return createStringError(inconvertibleErrorCode(),
+                               "Process not currently traced");
+    }
+    ClearProcessTracing();
+    return Error::success();
+  } else {
+    Error error = Error::success();
+    for (int64_t tid : *request.tids)
+      error = joinErrors(std::move(error),
+                         TraceStop(static_cast<lldb::tid_t>(tid)));
+    return error;
+  }
+}
+
+Error IntelPTManager::TraceStart(
+    const TraceIntelPTStartRequest &request,
+    const std::vector<lldb::tid_t> &process_threads) {
+  if (request.IsProcessTracing()) {
+    if (IsProcessTracingEnabled()) {
+      return createStringError(
+          inconvertibleErrorCode(),
+          "Process currently traced. Stop process tracing first");
+    }
+    m_process_trace = IntelPTProcessTrace(m_pid, request);
+
+    Error error = Error::success();
+    for (lldb::tid_t tid : process_threads)
+      error = joinErrors(std::move(error), m_process_trace->TraceStart(tid));
+    return error;
+  } else {
+    Error error = Error::success();
+    for (int64_t tid : *request.tids)
+      error = joinErrors(std::move(error),
+                         m_thread_traces.TraceStart(tid, request));
+    return error;
+  }
+}
+
+Error IntelPTManager::OnThreadCreated(lldb::tid_t tid) {
+  if (!IsProcessTracingEnabled())
+    return Error::success();
+  return m_process_trace->TraceStart(tid);
+}
+
+Error IntelPTManager::OnThreadDestroyed(lldb::tid_t tid) {
+  if (IsProcessTracingEnabled() && m_process_trace->TracesThread(tid))
+    return m_process_trace->TraceStop(tid);
+  else if (m_thread_traces.TracesThread(tid))
+    return m_thread_traces.TraceStop(tid);
+  return Error::success();
+}
+
+Expected<json::Value> IntelPTManager::GetState() const {
+  Expected<ArrayRef<uint8_t>> cpu_info = IntelPTThreadTrace::GetCPUInfo();
+  if (!cpu_info)
+    return cpu_info.takeError();
+
+  TraceGetStateResponse state;
+  state.processBinaryData.push_back(
+      {"cpuInfo", static_cast<int64_t>(cpu_info->size())});
+
+  std::vector<TraceThreadState> thread_states =
+      m_thread_traces.GetThreadStates();
+  state.tracedThreads.insert(state.tracedThreads.end(), thread_states.begin(),
+                             thread_states.end());
+
+  if (IsProcessTracingEnabled()) {
+    thread_states = m_process_trace->GetThreadTraces().GetThreadStates();
+    state.tracedThreads.insert(state.tracedThreads.end(), thread_states.begin(),
+                               thread_states.end());
+  }
+  return toJSON(state);
+}
+
+Expected<const IntelPTThreadTrace &>
+IntelPTManager::GetTracedThread(lldb::tid_t tid) const {
+  if (IsProcessTracingEnabled() && m_process_trace->TracesThread(tid))
+    return m_process_trace->GetThreadTraces().GetTracedThread(tid);
+  return m_thread_traces.GetTracedThread(tid);
+}
+
+Expected<std::vector<uint8_t>>
+IntelPTManager::GetBinaryData(const TraceGetBinaryDataRequest &request) const {
+  if (request.kind == "threadTraceBuffer") {
+    if (Expected<const IntelPTThreadTrace &> trace =
+            GetTracedThread(*request.tid))
+      return trace->GetIntelPTBuffer(request.offset, request.size);
+    else
+      return trace.takeError();
+  } else if (request.kind == "cpuInfo") {
+    return IntelPTThreadTrace::GetCPUInfo();
+  }
+  return createStringError(inconvertibleErrorCode(),
+                           "Unsuported trace binary data kind: %s",
+                           request.kind.c_str());
+}
+
+void IntelPTManager::ClearProcessTracing() { m_process_trace = None; }
+
+bool IntelPTManager::IsSupported() { return (bool)GetOSEventType(); }
+
+bool IntelPTManager::IsProcessTracingEnabled() const {
+  return (bool)m_process_trace;
+}
+
+void IntelPTManager::Clear() {
+  ClearProcessTracing();
+  m_thread_traces.Clear();
+}

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

 #include "lldb/Host/Debug.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-types.h"
 
+#include "IntelPTManager.h"
 #include "NativeThreadLinux.h"
 #include "Plugins/Process/POSIX/NativeProcessELF.h"
 #include "Plugins/Process/Utility/NativeProcessSoftwareSingleStep.h"
-#include "ProcessorTrace.h"
 
 namespace lldb_private {
 class Status;
 class Scalar;
 
 namespace process_linux {
 /// \class NativeProcessLinux
 /// Manages communication with the inferior (debugee) process.
public:
   NativeThreadLinux *GetThreadByID(lldb::tid_t id);
   NativeThreadLinux *GetCurrentThread();
 
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
   GetAuxvData() const override {
     return getProcFile(GetID(), "auxv");
   }
 
-  lldb::user_id_t StartTrace(const TraceOptions &config,
-                             Status &error) override;
+  /// Tracing
+  /// These methods implement the jLLDBTrace packets
+  /// \{
+  llvm::Error TraceStart(llvm::StringRef json_request,
+                         llvm::StringRef type) override;
+
+  llvm::Error TraceStop(const TraceStopRequest &request) override;
 
-  Status StopTrace(lldb::user_id_t traceid,
-                   lldb::tid_t thread) override;
+  llvm::Expected<llvm::json::Value>
+  TraceGetState(llvm::StringRef type) override;
 
-  Status GetData(lldb::user_id_t traceid, lldb::tid_t thread,
-                 llvm::MutableArrayRef<uint8_t> &buffer,
-                 size_t offset = 0) override;
+  llvm::Expected<std::vector<uint8_t>>
+  TraceGetBinaryData(const TraceGetBinaryDataRequest &request) override;
 
-  Status GetMetaData(lldb::user_id_t traceid, lldb::tid_t thread,
-                     llvm::MutableArrayRef<uint8_t> &buffer,
-                     size_t offset = 0) override;
-
-  Status GetTraceConfig(lldb::user_id_t traceid, TraceOptions &config) override;
-
-  virtual llvm::Expected<TraceTypeInfo> GetSupportedTraceType() override;
+  llvm::Expected<TraceSupportedResponse> TraceSupported() override;
+  /// }
 
   // Interface used by NativeRegisterContext-derived classes.
   static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr = nullptr,
                               void *data = nullptr, size_t data_size = 0,
                               long *result = nullptr);
 
   bool SupportHardwareSingleStepping() const;
 
private:
 
   void MonitorSignal(const siginfo_t &info, NativeThreadLinux &thread,
                      bool exited);
 
   bool HasThreadNoLock(lldb::tid_t thread_id);
 
   bool StopTrackingThread(lldb::tid_t thread_id);
 
-  NativeThreadLinux &AddThread(lldb::tid_t thread_id);
+  /// Create a new thread.
+  ///
+  /// If process tracing is enabled and the thread can't be traced, then the
+  /// thread is left stopped with a \a eStopReasonProcessorTrace status, and
+  /// then the process is stopped.
+  ///
+  /// \param[in] resume
+  ///     If a tracing error didn't happen, then resume the thread after
+  ///     creation if \b true, or leave it stopped with SIGSTOP if \b false.
+  NativeThreadLinux &AddThread(lldb::tid_t thread_id, bool resume);
+
+  /// Start tracing a new thread if process tracing is enabled.
+  ///
+  /// Trace mechanisms should modify this method to provide automatic tracing
+  /// for new threads.
+  Status NotifyTracersOfNewThread(lldb::tid_t tid);
+
+  /// Stop tracing threads upon a destroy event.
+  ///
+  /// Trace mechanisms should modify this method to provide automatic trace
+  /// stopping for threads being destroyed.
+  Status NotifyTracersOfThreadDestroyed(lldb::tid_t tid);
 
   /// Writes a siginfo_t structure corresponding to the given thread ID to the
   /// memory region pointed to by \p siginfo.
   Status GetSignalInfo(lldb::tid_t tid, void *siginfo);
 
   /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG)
   /// corresponding to the given thread ID to the memory pointed to by @p
   /// message.
Status ResumeThread(NativeThreadLinux &thread, lldb::StateType state,
                       int signo);
 
   void ThreadWasCreated(NativeThreadLinux &thread);
 
   void SigchldHandler();
 
   Status PopulateMemoryRegionCache();
 
-  lldb::user_id_t StartTraceGroup(const TraceOptions &config,
-                                         Status &error);
-
-  // This function is intended to be used to stop tracing
-  // on a thread that exited.
-  Status StopTracingForThread(lldb::tid_t thread);
-
-  // The below function as the name suggests, looks up a ProcessorTrace
-  // instance from the m_processor_trace_monitor map. In the case of
-  // process tracing where the traceid passed would map to the complete
-  // process, it is mandatory to provide a threadid to obtain a trace
-  // instance (since ProcessorTrace is tied to a thread). In the other
-  // scenario that an individual thread is being traced, just the traceid
-  // is sufficient to obtain the actual ProcessorTrace instance.
-  llvm::Expected<ProcessorTraceMonitor &>
-  LookupProcessorTraceInstance(lldb::user_id_t traceid, lldb::tid_t thread);
-
-  // Stops tracing on individual threads being traced. Not intended
-  // to be used to stop tracing on complete process.
-  Status StopProcessorTracingOnThread(lldb::user_id_t traceid,
-                                      lldb::tid_t thread);
-
-  // Intended to stop tracing on complete process.
-  // Should not be used for stopping trace on
-  // individual threads.
-  void StopProcessorTracingOnProcess();
-
-  llvm::DenseMap<lldb::tid_t, ProcessorTraceMonitorUP>
-      m_processor_trace_monitor;
-
-  // Set for tracking threads being traced under
-  // same process user id.
-  llvm::DenseSet<lldb::tid_t> m_pt_traced_thread_group;
-
-  lldb::user_id_t m_pt_proces_trace_id = LLDB_INVALID_UID;
-  TraceOptions m_pt_process_trace_config;
+  /// Manages Intel PT process and thread traces.
+  IntelPTManager m_intel_pt_manager;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessLinux_H_

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

 }
 
 // Public Instance Methods
 
 NativeProcessLinux::NativeProcessLinux(::pid_t pid, int terminal_fd,
                                        NativeDelegate &delegate,
                                        const ArchSpec &arch, MainLoop &mainloop,
                                        llvm::ArrayRef<::pid_t> tids)
-    : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch) {
+    : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch),
+      m_intel_pt_manager(pid) {
   if (m_terminal_fd != -1) {
     Status status = EnsureFDFlags(m_terminal_fd, O_NONBLOCK);
     assert(status.Success());
   }
 
   Status status;
   m_sigchld_handle = mainloop.RegisterSignal(
       SIGCHLD, [this](MainLoopBase &) { SigchldHandler(); }, status);
   assert(m_sigchld_handle && status.Success());
 
   for (const auto &tid : tids) {
-    NativeThreadLinux &thread = AddThread(tid);
-    thread.SetStoppedBySignal(SIGSTOP);
+    NativeThreadLinux &thread = AddThread(tid, /*resume*/ false);
     ThreadWasCreated(thread);
   }
 
   // Let our process instance know the thread has stopped.
   SetCurrentThreadID(tids[0]);
   SetState(StateType::eStateStopped, false);
 
   // Proccess any signals we received before installing our handler
if (info_err.Fail()) {
                "Ingoring this notification.",
                pid, info_err);
       return;
     }
 
     LLDB_LOG(log, "tid {0}, si_code: {1}, si_pid: {2}", pid, info.si_code,
              info.si_pid);
 
-    NativeThreadLinux &thread = AddThread(pid);
-
-    // Resume the newly created thread.
-    ResumeThread(thread, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
+    NativeThreadLinux &thread = AddThread(pid, /*resume*/ true);
     ThreadWasCreated(thread);
     return;
   }
 
   // Get details on the signal raised.
   if (info_err.Success()) {
     // We have retrieved the signal info.  Dispatch appropriately.
     if (info.si_signo == SIGTRAP)
LLDB_LOG(log,
              "waiting for tid {0} returned an 'exited' event. Not "
              "tracking the thread.",
              tid);
     // Also a very improbable event.
     return;
   }
 
   LLDB_LOG(log, "pid = {0}: tracking new thread tid {1}", GetID(), tid);
-  NativeThreadLinux &new_thread = AddThread(tid);
+  NativeThreadLinux &new_thread = AddThread(tid, /*resume*/ true);
 
-  ResumeThread(new_thread, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
   ThreadWasCreated(new_thread);
 }
 
 void NativeProcessLinux::MonitorSIGTRAP(const siginfo_t &info,
                                         NativeThreadLinux &thread) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   const bool is_main_thread = (thread.GetID() == GetID());
 
Status NativeProcessLinux::Detach() {
 
   for (const auto &thread : m_threads) {
     Status e = Detach(thread->GetID());
     if (e.Fail())
       error =
           e; // Save the error, but still attempt to detach from other threads.
   }
 
-  m_processor_trace_monitor.clear();
-  m_pt_proces_trace_id = LLDB_INVALID_UID;
+  m_intel_pt_manager.Clear();
 
   return error;
 }
 
 Status NativeProcessLinux::Signal(int signo) {
   Status error;
 
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
for (auto it = m_threads.begin(); it != m_threads.end(); ++it) {
     if (*it && ((*it)->GetID() == thread_id)) {
       m_threads.erase(it);
       found = true;
       break;
     }
   }
 
   if (found)
-    StopTracingForThread(thread_id);
+    NotifyTracersOfThreadDestroyed(thread_id);
+
   SignalIfAllThreadsStopped();
   return found;
 }
 
-NativeThreadLinux &NativeProcessLinux::AddThread(lldb::tid_t thread_id) {
+Status NativeProcessLinux::NotifyTracersOfNewThread(lldb::tid_t tid) {
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
+  Status error(m_intel_pt_manager.OnThreadCreated(tid));
+  if (error.Fail())
+    LLDB_LOG(log, "Failed to trace a new thread with intel-pt, tid = {0}. {1}",
+             tid, error.AsCString());
+  return error;
+}
+
+Status NativeProcessLinux::NotifyTracersOfThreadDestroyed(lldb::tid_t tid) {
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
+  Status error(m_intel_pt_manager.OnThreadDestroyed(tid));
+  if (error.Fail())
+    LLDB_LOG(log,
+             "Failed to stop a destroyed thread with intel-pt, tid = {0}. {1}",
+             tid, error.AsCString());
+  return error;
+}
+
+NativeThreadLinux &NativeProcessLinux::AddThread(lldb::tid_t thread_id,
+                                                 bool resume) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
   LLDB_LOG(log, "pid {0} adding thread with tid {1}", GetID(), thread_id);
 
   assert(!HasThreadNoLock(thread_id) &&
          "attempted to add a thread by id that already exists");
 
   // If this is the first thread, save it as the current thread
   if (m_threads.empty())
     SetCurrentThreadID(thread_id);
 
   m_threads.push_back(std::make_unique<NativeThreadLinux>(*this, thread_id));
+  NativeThreadLinux &thread =
+      static_cast<NativeThreadLinux &>(*m_threads.back());
 
-  if (m_pt_proces_trace_id != LLDB_INVALID_UID) {
-    auto traceMonitor = ProcessorTraceMonitor::Create(
-        GetID(), thread_id, m_pt_process_trace_config, true);
-    if (traceMonitor) {
-      m_pt_traced_thread_group.insert(thread_id);
-      m_processor_trace_monitor.insert(
-          std::make_pair(thread_id, std::move(*traceMonitor)));
-    } else {
-      LLDB_LOG(log, "failed to start trace on thread {0}", thread_id);
-      Status error(traceMonitor.takeError());
-      LLDB_LOG(log, "error {0}", error);
-    }
-  }
+  Status tracing_error = NotifyTracersOfNewThread(thread.GetID());
+  if (tracing_error.Fail()) {
+    thread.SetStoppedByProcessorTrace(tracing_error.AsCString());
+    StopRunningThreads(thread.GetID());
+  } else if (resume)
+    ResumeThread(thread, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
+  else
+    thread.SetStoppedBySignal(SIGSTOP);
 
-  return static_cast<NativeThreadLinux &>(*m_threads.back());
+  return thread;
 }
 
 Status NativeProcessLinux::GetLoadedModuleFileSpec(const char *module_path,
                                                    FileSpec &file_spec) {
   Status error = PopulateMemoryRegionCache();
   if (error.Fail())
     return error;
 
Status NativeProcessLinux::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
   PtraceDisplayBytes(req, data, data_size);
 
   if (error.Fail())
     LLDB_LOG(log, "ptrace() failed: {0}", error);
 
   return error;
 }
 
-llvm::Expected<ProcessorTraceMonitor &>
-NativeProcessLinux::LookupProcessorTraceInstance(lldb::user_id_t traceid,
-                                                 lldb::tid_t thread) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-  if (thread == LLDB_INVALID_THREAD_ID && traceid == m_pt_proces_trace_id) {
-    LLDB_LOG(log, "thread not specified: {0}", traceid);
-    return Status("tracing not active thread not specified").ToError();
-  }
+llvm::Expected<TraceSupportedResponse> NativeProcessLinux::TraceSupported() {
+  if (IntelPTManager::IsSupported())
+    return TraceSupportedResponse{"intel-pt", "Intel Processor Trace"};
+  return NativeProcessProtocol::TraceSupported();
 
-  for (auto& iter : m_processor_trace_monitor) {
-    if (traceid == iter.second->GetTraceID() &&
-        (thread == iter.first || thread == LLDB_INVALID_THREAD_ID))
-      return *(iter.second);
-  }
-
-  LLDB_LOG(log, "traceid not being traced: {0}", traceid);
-  return Status("tracing not active for this thread").ToError();
-}
-
-Status NativeProcessLinux::GetMetaData(lldb::user_id_t traceid,
-                                       lldb::tid_t thread,
-                                       llvm::MutableArrayRef<uint8_t> &buffer,
-                                       size_t offset) {
-  TraceOptions trace_options;
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-  Status error;
-
-  LLDB_LOG(log, "traceid {0}", traceid);
-
-  auto perf_monitor = LookupProcessorTraceInstance(traceid, thread);
-  if (!perf_monitor) {
-    LLDB_LOG(log, "traceid not being traced: {0}", traceid);
-    buffer = buffer.slice(buffer.size());
-    error = perf_monitor.takeError();
-    return error;
-  }
-  return (*perf_monitor).ReadPerfTraceData(buffer, offset);
-}
-
-Status NativeProcessLinux::GetData(lldb::user_id_t traceid, lldb::tid_t thread,
-                                   llvm::MutableArrayRef<uint8_t> &buffer,
-                                   size_t offset) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-  Status error;
-
-  LLDB_LOG(log, "traceid {0}", traceid);
-
-  auto perf_monitor = LookupProcessorTraceInstance(traceid, thread);
-  if (!perf_monitor) {
-    LLDB_LOG(log, "traceid not being traced: {0}", traceid);
-    buffer = buffer.slice(buffer.size());
-    error = perf_monitor.takeError();
-    return error;
-  }
-  return (*perf_monitor).ReadPerfTraceAux(buffer, offset);
-}
-
-Status NativeProcessLinux::GetTraceConfig(lldb::user_id_t traceid,
-                                          TraceOptions &config) {
-  Status error;
-  if (config.getThreadID() == LLDB_INVALID_THREAD_ID &&
-      m_pt_proces_trace_id == traceid) {
-    if (m_pt_proces_trace_id == LLDB_INVALID_UID) {
-      error.SetErrorString("tracing not active for this process");
-      return error;
-    }
-    config = m_pt_process_trace_config;
-  } else {
-    auto perf_monitor =
-        LookupProcessorTraceInstance(traceid, config.getThreadID());
-    if (!perf_monitor) {
-      error = perf_monitor.takeError();
-      return error;
-    }
-    error = (*perf_monitor).GetTraceConfig(config);
-  }
-  return error;
-}
-
-llvm::Expected<TraceTypeInfo> NativeProcessLinux::GetSupportedTraceType() {
-  if (ProcessorTraceMonitor::IsSupported())
-    return TraceTypeInfo{"intel-pt", "Intel Processor Trace"};
-  return NativeProcessProtocol::GetSupportedTraceType();
-}
-
-lldb::user_id_t
-NativeProcessLinux::StartTraceGroup(const TraceOptions &config,
-                                           Status &error) {
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-  if (config.getType() != TraceType::eTraceTypeProcessorTrace)
-    return LLDB_INVALID_UID;
-
-  if (m_pt_proces_trace_id != LLDB_INVALID_UID) {
-    error.SetErrorString("tracing already active on this process");
-    return m_pt_proces_trace_id;
-  }
-
-  for (const auto &thread_sp : m_threads) {
-    if (auto traceInstance = ProcessorTraceMonitor::Create(
-            GetID(), thread_sp->GetID(), config, true)) {
-      m_pt_traced_thread_group.insert(thread_sp->GetID());
-      m_processor_trace_monitor.insert(
-          std::make_pair(thread_sp->GetID(), std::move(*traceInstance)));
-    }
-  }
-
-  m_pt_process_trace_config = config;
-  error = ProcessorTraceMonitor::GetCPUType(m_pt_process_trace_config);
-
-  // Trace on Complete process will have traceid of 0
-  m_pt_proces_trace_id = 0;
-
-  LLDB_LOG(log, "Process Trace ID {0}", m_pt_proces_trace_id);
-  return m_pt_proces_trace_id;
-}
-
-lldb::user_id_t NativeProcessLinux::StartTrace(const TraceOptions &config,
-                                               Status &error) {
-  if (config.getType() != TraceType::eTraceTypeProcessorTrace)
-    return NativeProcessProtocol::StartTrace(config, error);
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-
-  lldb::tid_t threadid = config.getThreadID();
-
-  if (threadid == LLDB_INVALID_THREAD_ID)
-    return StartTraceGroup(config, error);
-
-  auto thread_sp = GetThreadByID(threadid);
-  if (!thread_sp) {
-    // Thread not tracked by lldb so don't trace.
-    error.SetErrorString("invalid thread id");
-    return LLDB_INVALID_UID;
-  }
-
-  const auto &iter = m_processor_trace_monitor.find(threadid);
-  if (iter != m_processor_trace_monitor.end()) {
-    LLDB_LOG(log, "Thread already being traced");
-    error.SetErrorString("tracing already active on this thread");
-    return LLDB_INVALID_UID;
-  }
-
-  auto traceMonitor =
-      ProcessorTraceMonitor::Create(GetID(), threadid, config, false);
-  if (!traceMonitor) {
-    error = traceMonitor.takeError();
-    LLDB_LOG(log, "error {0}", error);
-    return LLDB_INVALID_UID;
-  }
-  lldb::user_id_t ret_trace_id = (*traceMonitor)->GetTraceID();
-  m_processor_trace_monitor.insert(
-      std::make_pair(threadid, std::move(*traceMonitor)));
-  return ret_trace_id;
-}
-
-Status NativeProcessLinux::StopTracingForThread(lldb::tid_t thread) {
-  Status error;
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-  LLDB_LOG(log, "Thread {0}", thread);
-
-  const auto& iter = m_processor_trace_monitor.find(thread);
-  if (iter == m_processor_trace_monitor.end()) {
-    error.SetErrorString("tracing not active for this thread");
-    return error;
-  }
-
-  if (iter->second->GetTraceID() == m_pt_proces_trace_id) {
-    // traceid maps to the whole process so we have to erase it from the thread
-    // group.
-    LLDB_LOG(log, "traceid maps to process");
-    m_pt_traced_thread_group.erase(thread);
-  }
-  m_processor_trace_monitor.erase(iter);
-
-  return error;
-}
-
-Status NativeProcessLinux::StopTrace(lldb::user_id_t traceid,
-                                     lldb::tid_t thread) {
-  Status error;
-
-  TraceOptions trace_options;
-  trace_options.setThreadID(thread);
-  error = NativeProcessLinux::GetTraceConfig(traceid, trace_options);
-
-  if (error.Fail())
-    return error;
-
-  switch (trace_options.getType()) {
-  case lldb::TraceType::eTraceTypeProcessorTrace:
-    if (traceid == m_pt_proces_trace_id &&
-        thread == LLDB_INVALID_THREAD_ID)
-      StopProcessorTracingOnProcess();
-    else
-      error = StopProcessorTracingOnThread(traceid, thread);
-    break;
-  default:
-    error.SetErrorString("trace not supported");
-    break;
-  }
-
-  return error;
-}
-
-void NativeProcessLinux::StopProcessorTracingOnProcess() {
-  for (auto thread_id_iter : m_pt_traced_thread_group)
-    m_processor_trace_monitor.erase(thread_id_iter);
-  m_pt_traced_thread_group.clear();
-  m_pt_proces_trace_id = LLDB_INVALID_UID;
-}
-
-Status NativeProcessLinux::StopProcessorTracingOnThread(lldb::user_id_t traceid,
-                                                        lldb::tid_t thread) {
-  Status error;
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-
-  if (thread == LLDB_INVALID_THREAD_ID) {
-    for (auto& iter : m_processor_trace_monitor) {
-      if (iter.second->GetTraceID() == traceid) {
-        // Stopping a trace instance for an individual thread hence there will
-        // only be one traceid that can match.
-        m_processor_trace_monitor.erase(iter.first);
-        return error;
-      }
-      LLDB_LOG(log, "Trace ID {0}", iter.second->GetTraceID());
-    }
+Error NativeProcessLinux::TraceStart(StringRef json_request, StringRef type) {
+  if (type == "intel-pt") {
+    if (Expected<TraceIntelPTStartRequest> request =
+            json::parse<TraceIntelPTStartRequest>(json_request,
+                                                  "TraceIntelPTStartRequest")) {
+      std::vector<lldb::tid_t> process_threads;
+      for (auto &thread : m_threads)
+        process_threads.push_back(thread->GetID());
+      return m_intel_pt_manager.TraceStart(*request, process_threads);
+    } else
+      return request.takeError();
 
-    LLDB_LOG(log, "Invalid TraceID");
-    error.SetErrorString("invalid trace id");
-    return error;
-  }
+  return NativeProcessProtocol::TraceStart(json_request, type);
 
-  // thread is specified so we can use find function on the map.
-  const auto& iter = m_processor_trace_monitor.find(thread);
-  if (iter == m_processor_trace_monitor.end()) {
-    // thread not found in our map.
-    LLDB_LOG(log, "thread not being traced");
-    error.SetErrorString("tracing not active for this thread");
-    return error;
-  }
-  if (iter->second->GetTraceID() != traceid) {
-    // traceid did not match so it has to be invalid.
-    LLDB_LOG(log, "Invalid TraceID");
-    error.SetErrorString("invalid trace id");
-    return error;
-  }
-
-  LLDB_LOG(log, "UID - {0} , Thread -{1}", traceid, thread);
+Error NativeProcessLinux::TraceStop(const TraceStopRequest &request) {
+  if (request.type == "intel-pt")
+    return m_intel_pt_manager.TraceStop(request);
+  return NativeProcessProtocol::TraceStop(request);
 
-  if (traceid == m_pt_proces_trace_id) {
-    // traceid maps to the whole process so we have to erase it from the thread
-    // group.
-    LLDB_LOG(log, "traceid maps to process");
-    m_pt_traced_thread_group.erase(thread);
-  }
-  m_processor_trace_monitor.erase(iter);
+Expected<json::Value> NativeProcessLinux::TraceGetState(StringRef type) {
+  if (type == "intel-pt")
+    return m_intel_pt_manager.GetState();
+  return NativeProcessProtocol::TraceGetState(type);
 
-  return error;
+Expected<std::vector<uint8_t>> NativeProcessLinux::TraceGetBinaryData(
+    const TraceGetBinaryDataRequest &request) {
+  if (request.type == "intel-pt")
+    return m_intel_pt_manager.GetBinaryData(request);
+  return NativeProcessProtocol::TraceGetBinaryData(request);
 }

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

 //===-- NativeThreadLinux.h ----------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NativeThreadLinux_H_
 #define liblldb_NativeThreadLinux_H_
 
 #include "Plugins/Process/Linux/NativeRegisterContextLinux.h"
 #include "Plugins/Process/Linux/SingleStepCheck.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/lldb-private-forward.h"
 
+#include "llvm/ADT/StringRef.h"
+
 #include <csignal>
 #include <map>
 #include <memory>
 #include <string>
 
 namespace lldb_private {
 namespace process_linux {
 
private:
   bool IsStoppedAtBreakpoint();
 
   bool IsStoppedAtWatchpoint();
 
   void SetStoppedByTrace();
 
   void SetStoppedWithNoReason();
 
+  void SetStoppedByProcessorTrace(llvm::StringRef description);
+
   void SetExited();
 
   Status RequestStop();
 
   // Private interface
   void MaybeLogStateChange(lldb::StateType new_state);
 
   void SetStopped();

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

case eStopReasonPlanComplete:
     log.Printf("%s: %s plan complete", __FUNCTION__, header);
     return;
   case eStopReasonThreadExiting:
     log.Printf("%s: %s thread exiting", __FUNCTION__, header);
     return;
   case eStopReasonInstrumentation:
     log.Printf("%s: %s instrumentation", __FUNCTION__, header);
     return;
+  case eStopReasonProcessorTrace:
+    log.Printf("%s: %s processor trace", __FUNCTION__, header);
+    return;
   default:
     log.Printf("%s: %s invalid stop reason %" PRIu32, __FUNCTION__, header,
                static_cast<uint32_t>(stop_info.reason));
   }
 }
 }
 
 NativeThreadLinux::NativeThreadLinux(NativeProcessLinux &process,

 
 void NativeThreadLinux::SetStoppedWithNoReason() {
   SetStopped();
 
   m_stop_info.reason = StopReason::eStopReasonNone;
   m_stop_info.details.signal.signo = 0;
 }
 
+void NativeThreadLinux::SetStoppedByProcessorTrace(
+    llvm::StringRef description) {
+  SetStopped();
+
+  m_stop_info.reason = StopReason::eStopReasonProcessorTrace;
+  m_stop_info.details.signal.signo = 0;
+  m_stop_description = description.str();
+}
+
 void NativeThreadLinux::SetExited() {
   const StateType new_state = StateType::eStateExited;
   MaybeLogStateChange(new_state);
   m_state = new_state;
 
   m_stop_info.reason = StopReason::eStopReasonThreadExiting;
 }
 

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

-//===-- ProcessorTrace.h -------------------------------------- -*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_ProcessorTrace_H_
-#define liblldb_ProcessorTrace_H_
-
-#include "lldb/Utility/Status.h"
-#include "lldb/Utility/TraceOptions.h"
-#include "lldb/lldb-types.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/DenseSet.h"
-
-#include <linux/perf_event.h>
-#include <sys/mman.h>
-#include <unistd.h>
-
-namespace lldb_private {
-
-namespace process_linux {
-
-// This class keeps track of one tracing instance of
-// Intel(R) Processor Trace on Linux OS. There is a map keeping track
-// of different tracing instances on each thread, which enables trace
-// gathering on a per thread level.
-//
-// The tracing instance is linked with a trace id. The trace id acts like
-// a key to the tracing instance and trace manipulations could be
-// performed using the trace id.
-//
-// The trace id could map to trace instances for a group of threads
-// (spanning to all the threads in the process) or a single thread.
-// The kernel interface for us is the perf_event_open.
-
-class ProcessorTraceMonitor;
-typedef std::unique_ptr<ProcessorTraceMonitor> ProcessorTraceMonitorUP;
-
-class ProcessorTraceMonitor {
-
-  class munmap_delete {
-    size_t m_length;
-
-  public:
-    munmap_delete(size_t length) : m_length(length) {}
-    void operator()(void *ptr) {
-      if (m_length)
-        munmap(ptr, m_length);
-    }
-  };
-
-  class file_close {
-
-  public:
-    file_close() = default;
-    void operator()(int *ptr) {
-      if (ptr == nullptr)
-        return;
-      if (*ptr == -1)
-        return;
-      close(*ptr);
-      std::default_delete<int>()(ptr);
-    }
-  };
-
-  std::unique_ptr<perf_event_mmap_page, munmap_delete> m_mmap_meta;
-  std::unique_ptr<uint8_t, munmap_delete> m_mmap_aux;
-  std::unique_ptr<int, file_close> m_fd;
-
-  // perf_event_mmap_page *m_mmap_base;
-  lldb::user_id_t m_traceid;
-  lldb::tid_t m_thread_id;
-
-  // Counter to track trace instances.
-  static lldb::user_id_t m_trace_num;
-
-  void SetTraceID(lldb::user_id_t traceid) { m_traceid = traceid; }
-
-  Status StartTrace(lldb::pid_t pid, lldb::tid_t tid,
-                    const TraceOptions &config);
-
-  llvm::MutableArrayRef<uint8_t> GetAuxBuffer();
-  llvm::MutableArrayRef<uint8_t> GetDataBuffer();
-
-  ProcessorTraceMonitor()
-      : m_mmap_meta(nullptr, munmap_delete(0)),
-        m_mmap_aux(nullptr, munmap_delete(0)), m_fd(nullptr, file_close()),
-        m_traceid(LLDB_INVALID_UID), m_thread_id(LLDB_INVALID_THREAD_ID){};
-
-  void SetThreadID(lldb::tid_t tid) { m_thread_id = tid; }
-
-public:
-  static llvm::Expected<uint32_t> GetOSEventType();
-
-  static bool IsSupported();
-
-  static Status GetCPUType(TraceOptions &config);
-
-  static llvm::Expected<ProcessorTraceMonitorUP>
-  Create(lldb::pid_t pid, lldb::tid_t tid, const TraceOptions &config,
-         bool useProcessSettings);
-
-  Status ReadPerfTraceAux(llvm::MutableArrayRef<uint8_t> &buffer,
-                          size_t offset = 0);
-
-  Status ReadPerfTraceData(llvm::MutableArrayRef<uint8_t> &buffer,
-                           size_t offset = 0);
-
-  ~ProcessorTraceMonitor() = default;
-
-  lldb::tid_t GetThreadID() const { return m_thread_id; }
-
-  lldb::user_id_t GetTraceID() const { return m_traceid; }
-
-  Status GetTraceConfig(TraceOptions &config) const;
-
-  /// 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.
-  static void ReadCyclicBuffer(llvm::MutableArrayRef<uint8_t> &dst,
-                               llvm::MutableArrayRef<uint8_t> src,
-                               size_t src_cyc_index, size_t offset);
-};
-} // namespace process_linux
-} // namespace lldb_private
-#endif

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

-//===-- ProcessorTrace.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 <algorithm>
-#include <fstream>
-
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/MathExtras.h"
-
-#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
-#include "ProcessorTrace.h"
-#include "lldb/Host/linux/Support.h"
-
-#include <sys/ioctl.h>
-#include <sys/syscall.h>
-
-using namespace lldb;
-using namespace lldb_private;
-using namespace process_linux;
-using namespace llvm;
-
-lldb::user_id_t ProcessorTraceMonitor::m_trace_num = 1;
-const char *kOSEventIntelPTTypeFile =
-    "/sys/bus/event_source/devices/intel_pt/type";
-
-Status ProcessorTraceMonitor::GetTraceConfig(TraceOptions &config) const {
-#ifndef PERF_ATTR_SIZE_VER5
-  llvm_unreachable("perf event not supported");
-#else
-  Status error;
-
-  config.setType(lldb::TraceType::eTraceTypeProcessorTrace);
-  config.setMetaDataBufferSize(m_mmap_meta->data_size);
-
-  config.setTraceBufferSize(m_mmap_meta->aux_size);
-
-  error = GetCPUType(config);
-
-  return error;
-#endif
-}
-
-Expected<uint32_t> ProcessorTraceMonitor::GetOSEventType() {
-  auto intel_pt_type_text =
-      llvm::MemoryBuffer::getFileAsStream(kOSEventIntelPTTypeFile);
-
-  if (!intel_pt_type_text)
-    return createStringError(inconvertibleErrorCode(),
-                             "Can't open the file '%s'",
-                             kOSEventIntelPTTypeFile);
-
-  uint32_t intel_pt_type = 0;
-  StringRef buffer = intel_pt_type_text.get()->getBuffer();
-  if (buffer.trim().getAsInteger(10, intel_pt_type))
-    return createStringError(
-        inconvertibleErrorCode(),
-        "The file '%s' has a invalid value. It should be an unsigned int.",
-        kOSEventIntelPTTypeFile);
-  return intel_pt_type;
-}
-
-bool ProcessorTraceMonitor::IsSupported() { return (bool)GetOSEventType(); }
-
-Status ProcessorTraceMonitor::StartTrace(lldb::pid_t pid, lldb::tid_t tid,
-                                         const TraceOptions &config) {
-#ifndef PERF_ATTR_SIZE_VER5
-  llvm_unreachable("perf event not supported");
-#else
-  Status error;
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-
-  LLDB_LOG(log, "called thread id {0}", tid);
-  uint64_t page_size = getpagesize();
-  uint64_t bufsize = config.getTraceBufferSize();
-  uint64_t metabufsize = config.getMetaDataBufferSize();
-
-  uint64_t numpages = static_cast<uint64_t>(
-      llvm::PowerOf2Floor((bufsize + page_size - 1) / page_size));
-  numpages = std::max<uint64_t>(1, numpages);
-  bufsize = page_size * numpages;
-
-  numpages = static_cast<uint64_t>(
-      llvm::PowerOf2Floor((metabufsize + page_size - 1) / page_size));
-  metabufsize = page_size * numpages;
-
-  perf_event_attr attr;
-  memset(&attr, 0, sizeof(attr));
-  attr.size = sizeof(attr);
-  attr.exclude_kernel = 1;
-  attr.sample_type = PERF_SAMPLE_TIME;
-  attr.sample_id_all = 1;
-  attr.exclude_hv = 1;
-  attr.exclude_idle = 1;
-  attr.mmap = 1;
-
-  Expected<uint32_t> intel_pt_type = GetOSEventType();
-
-  if (!intel_pt_type) {
-    error = intel_pt_type.takeError();
-    return error;
-  }
-
-  LLDB_LOG(log, "intel pt type {0}", *intel_pt_type);
-  attr.type = *intel_pt_type;
-
-  LLDB_LOG(log, "meta buffer size {0}", metabufsize);
-  LLDB_LOG(log, "buffer size {0} ", bufsize);
-
-  if (error.Fail()) {
-    LLDB_LOG(log, "Status in custom config");
-
-    return error;
-  }
-
-  errno = 0;
-  auto fd =
-      syscall(SYS_perf_event_open, &attr, static_cast<::tid_t>(tid), -1, -1, 0);
-  if (fd == -1) {
-    LLDB_LOG(log, "syscall error {0}", errno);
-    error.SetErrorString("perf event syscall Failed");
-    return error;
-  }
-
-  m_fd = std::unique_ptr<int, file_close>(new int(fd), file_close());
-
-  errno = 0;
-  auto base =
-      mmap(nullptr, (metabufsize + page_size), PROT_WRITE, MAP_SHARED, fd, 0);
-
-  if (base == MAP_FAILED) {
-    LLDB_LOG(log, "mmap base error {0}", errno);
-    error.SetErrorString("Meta buffer allocation failed");
-    return error;
-  }
-
-  m_mmap_meta = std::unique_ptr<perf_event_mmap_page, munmap_delete>(
-      reinterpret_cast<perf_event_mmap_page *>(base),
-      munmap_delete(metabufsize + page_size));
-
-  m_mmap_meta->aux_offset = m_mmap_meta->data_offset + m_mmap_meta->data_size;
-  m_mmap_meta->aux_size = bufsize;
-
-  errno = 0;
-  auto mmap_aux = mmap(nullptr, bufsize, PROT_READ, MAP_SHARED, fd,
-                       static_cast<long int>(m_mmap_meta->aux_offset));
-
-  if (mmap_aux == MAP_FAILED) {
-    LLDB_LOG(log, "second mmap done {0}", errno);
-    error.SetErrorString("Trace buffer allocation failed");
-    return error;
-  }
-  m_mmap_aux = std::unique_ptr<uint8_t, munmap_delete>(
-      reinterpret_cast<uint8_t *>(mmap_aux), munmap_delete(bufsize));
-  return error;
-#endif
-}
-
-llvm::MutableArrayRef<uint8_t> ProcessorTraceMonitor::GetDataBuffer() {
-#ifndef PERF_ATTR_SIZE_VER5
-  llvm_unreachable("perf event not supported");
-#else
-  return MutableArrayRef<uint8_t>(
-      (reinterpret_cast<uint8_t *>(m_mmap_meta.get()) +
-       m_mmap_meta->data_offset),
-      m_mmap_meta->data_size);
-#endif
-}
-
-llvm::MutableArrayRef<uint8_t> ProcessorTraceMonitor::GetAuxBuffer() {
-#ifndef PERF_ATTR_SIZE_VER5
-  llvm_unreachable("perf event not supported");
-#else
-  return MutableArrayRef<uint8_t>(m_mmap_aux.get(), m_mmap_meta->aux_size);
-#endif
-}
-
-Status ProcessorTraceMonitor::GetCPUType(TraceOptions &config) {
-
-  Status error;
-  uint64_t cpu_family = -1;
-  uint64_t model = -1;
-  uint64_t stepping = -1;
-  std::string vendor_id;
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-
-  auto BufferOrError = getProcFile("cpuinfo");
-  if (!BufferOrError)
-    return BufferOrError.getError();
-
-  LLDB_LOG(log, "GetCPUType Function");
-
-  StringRef Rest = BufferOrError.get()->getBuffer();
-  while (!Rest.empty()) {
-    StringRef Line;
-    std::tie(Line, Rest) = Rest.split('\n');
-
-    SmallVector<StringRef, 2> columns;
-    Line.split(columns, StringRef(":"), -1, false);
-
-    if (columns.size() < 2)
-      continue; // continue searching
-
-    columns[1] = columns[1].trim(" ");
-    if (columns[0].contains("cpu family") &&
-        columns[1].getAsInteger(10, cpu_family))
-      continue;
-
-    else if (columns[0].contains("model") && columns[1].getAsInteger(10, model))
-      continue;
-
-    else if (columns[0].contains("stepping") &&
-             columns[1].getAsInteger(10, stepping))
-      continue;
-
-    else if (columns[0].contains("vendor_id")) {
-      vendor_id = columns[1].str();
-      if (!vendor_id.empty())
-        continue;
-    }
-    LLDB_LOG(log, "{0}:{1}:{2}:{3}", cpu_family, model, stepping, vendor_id);
-
-    if ((cpu_family != static_cast<uint64_t>(-1)) &&
-        (model != static_cast<uint64_t>(-1)) &&
-        (stepping != static_cast<uint64_t>(-1)) && (!vendor_id.empty())) {
-      auto params_dict = std::make_shared<StructuredData::Dictionary>();
-      params_dict->AddIntegerItem("cpu_family", cpu_family);
-      params_dict->AddIntegerItem("cpu_model", model);
-      params_dict->AddIntegerItem("cpu_stepping", stepping);
-      params_dict->AddStringItem("cpu_vendor", vendor_id);
-
-      llvm::StringRef intel_custom_params_key("intel-pt");
-
-      auto intel_custom_params = std::make_shared<StructuredData::Dictionary>();
-      intel_custom_params->AddItem(
-          intel_custom_params_key,
-          StructuredData::ObjectSP(std::move(params_dict)));
-
-      config.setTraceParams(intel_custom_params);
-      return error; // we are done
-    }
-  }
-
-  error.SetErrorString("cpu info not found");
-  return error;
-}
-
-llvm::Expected<ProcessorTraceMonitorUP>
-ProcessorTraceMonitor::Create(lldb::pid_t pid, lldb::tid_t tid,
-                              const TraceOptions &config,
-                              bool useProcessSettings) {
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-
-  Status error;
-  if (tid == LLDB_INVALID_THREAD_ID) {
-    error.SetErrorString("thread not specified");
-    return error.ToError();
-  }
-
-  ProcessorTraceMonitorUP pt_monitor_up(new ProcessorTraceMonitor);
-
-  error = pt_monitor_up->StartTrace(pid, tid, config);
-  if (error.Fail())
-    return error.ToError();
-
-  pt_monitor_up->SetThreadID(tid);
-
-  if (useProcessSettings) {
-    pt_monitor_up->SetTraceID(0);
-  } else {
-    pt_monitor_up->SetTraceID(m_trace_num++);
-    LLDB_LOG(log, "Trace ID {0}", m_trace_num);
-  }
-  return std::move(pt_monitor_up);
-}
-
-Status
-ProcessorTraceMonitor::ReadPerfTraceAux(llvm::MutableArrayRef<uint8_t> &buffer,
-                                        size_t offset) {
-#ifndef PERF_ATTR_SIZE_VER5
-  llvm_unreachable("perf event not supported");
-#else
-  // Disable the perf event to force a flush out of the CPU's internal buffer.
-  // Besides, we can guarantee that the CPU won't override any data as we are
-  // reading the buffer.
-  //
-  // The Intel documentation says:
-  //
-  // Packets are first buffered internally and then written out asynchronously.
-  // To collect packet output for postprocessing, a collector needs first to
-  // ensure that all packet data has been flushed from internal buffers.
-  // Software can ensure this by stopping packet generation by clearing
-  // IA32_RTIT_CTL.TraceEn (see “Disabling Packet Generation” in
-  // Section 35.2.7.2).
-  //
-  // This is achieved by the PERF_EVENT_IOC_DISABLE ioctl request, as mentioned
-  // in the man page of perf_event_open.
-  ioctl(*m_fd, PERF_EVENT_IOC_DISABLE);
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-  Status error;
-  uint64_t head = m_mmap_meta->aux_head;
-
-  LLDB_LOG(log, "Aux size -{0} , Head - {1}", m_mmap_meta->aux_size, head);
-
-  /**
-   * 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  ->|
-   *
-   * */
-
-  ReadCyclicBuffer(buffer, GetAuxBuffer(), static_cast<size_t>(head), offset);
-  LLDB_LOG(log, "ReadCyclic BUffer Done");
-
-  // Reenable tracing now we have read the buffer
-  ioctl(*m_fd, PERF_EVENT_IOC_ENABLE);
-  return error;
-#endif
-}
-
-Status
-ProcessorTraceMonitor::ReadPerfTraceData(llvm::MutableArrayRef<uint8_t> &buffer,
-                                         size_t offset) {
-#ifndef PERF_ATTR_SIZE_VER5
-  llvm_unreachable("perf event not supported");
-#else
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-  uint64_t bytes_remaining = buffer.size();
-  Status error;
-
-  uint64_t head = m_mmap_meta->data_head;
-
-  /*
-   * 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
-   */
-
-  LLDB_LOG(log, "bytes_remaining - {0}", bytes_remaining);
-
-  auto data_buffer = GetDataBuffer();
-
-  if (head > data_buffer.size()) {
-    head = head % data_buffer.size();
-    LLDB_LOG(log, "Data size -{0} Head - {1}", m_mmap_meta->data_size, head);
-
-    ReadCyclicBuffer(buffer, data_buffer, static_cast<size_t>(head), offset);
-    bytes_remaining -= buffer.size();
-  } else {
-    LLDB_LOG(log, "Head - {0}", head);
-    if (offset >= head) {
-      LLDB_LOG(log, "Invalid Offset ");
-      error.SetErrorString("invalid offset");
-      buffer = buffer.slice(buffer.size());
-      return error;
-    }
-
-    auto data = data_buffer.slice(offset, (head - offset));
-    auto remaining = std::copy(data.begin(), data.end(), buffer.begin());
-    bytes_remaining -= (remaining - buffer.begin());
-  }
-  buffer = buffer.drop_back(bytes_remaining);
-  return error;
-#endif
-}
-
-void ProcessorTraceMonitor::ReadCyclicBuffer(
-    llvm::MutableArrayRef<uint8_t> &dst, llvm::MutableArrayRef<uint8_t> src,
-    size_t src_cyc_index, size_t offset) {
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-
-  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<MutableArrayRef<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);
-}

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

 #include <string>
 #include <vector>
 
 #include "lldb/Host/File.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/GDBRemote.h"
 #include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/StructuredData.h"
-#include "lldb/Utility/TraceOptions.h"
+#include "lldb/Utility/TraceGDBRemotePackets.h"
 #if defined(_WIN32)
 #include "lldb/Host/windows/PosixApi.h"
 #endif
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
public:
 
   /// Configure a StructuredData feature on the remote end.
   ///
   /// \see \b Process::ConfigureStructuredData(...) for details.
   Status
   ConfigureRemoteStructuredData(ConstString type_name,
                                 const StructuredData::ObjectSP &config_sp);
 
-  lldb::user_id_t SendStartTracePacket(const TraceOptions &options,
-                                       Status &error);
+  llvm::Expected<TraceSupportedResponse> SendTraceSupported();
 
-  Status SendStopTracePacket(lldb::user_id_t uid, lldb::tid_t thread_id);
+  llvm::Error SendTraceStart(const llvm::json::Value &request);
 
-  Status SendGetDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id,
-                           llvm::MutableArrayRef<uint8_t> &buffer,
-                           size_t offset = 0);
-
-  Status SendGetMetaDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id,
-                               llvm::MutableArrayRef<uint8_t> &buffer,
-                               size_t offset = 0);
+  llvm::Error SendTraceStop(const TraceStopRequest &request);
 
-  Status SendGetTraceConfigPacket(lldb::user_id_t uid, TraceOptions &options);
+  llvm::Expected<std::string> SendTraceGetState(llvm::StringRef type);
 
-  llvm::Expected<TraceTypeInfo> SendGetSupportedTraceType();
+  llvm::Expected<std::vector<uint8_t>>
+  SendTraceGetBinaryData(const TraceGetBinaryDataRequest &request);
 
 protected:
   LazyBool m_supports_not_sending_acks;
   LazyBool m_supports_thread_suffix;
   LazyBool m_supports_threads_in_stop_reply;
   LazyBool m_supports_vCont_all;
   LazyBool m_supports_vCont_any;
   LazyBool m_supports_vCont_c;

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

bool GDBRemoteCommunicationClient::SyncThreadState(lldb::tid_t tid) {
   StreamString packet;
   StringExtractorGDBRemote response;
   packet.Printf("QSyncThreadState:%4.4" PRIx64 ";", tid);
   return SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
              GDBRemoteCommunication::PacketResult::Success &&
          response.IsOKResponse();
 }
 
-lldb::user_id_t
-GDBRemoteCommunicationClient::SendStartTracePacket(const TraceOptions &options,
-                                                   Status &error) {
+llvm::Expected<TraceSupportedResponse>
+GDBRemoteCommunicationClient::SendTraceSupported() {
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
-  lldb::user_id_t ret_uid = LLDB_INVALID_UID;
 
   StreamGDBRemote escaped_packet;
-  escaped_packet.PutCString("jTraceStart:");
-
-  StructuredData::Dictionary json_packet;
-  json_packet.AddIntegerItem("type", options.getType());
-  json_packet.AddIntegerItem("buffersize", options.getTraceBufferSize());
-  json_packet.AddIntegerItem("metabuffersize", options.getMetaDataBufferSize());
-
-  if (options.getThreadID() != LLDB_INVALID_THREAD_ID)
-    json_packet.AddIntegerItem("threadid", options.getThreadID());
-
-  StructuredData::DictionarySP custom_params = options.getTraceParams();
-  if (custom_params)
-    json_packet.AddItem("params", custom_params);
-
-  StreamString json_string;
-  json_packet.Dump(json_string, false);
-  escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
+  escaped_packet.PutCString("jLLDBTraceSupported");
 
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
                                    true) ==
       GDBRemoteCommunication::PacketResult::Success) {
-    if (!response.IsNormalResponse()) {
-      error = response.GetStatus();
-      LLDB_LOG(log, "Target does not support Tracing , error {0}", error);
-    } else {
-      ret_uid = response.GetHexMaxU64(false, LLDB_INVALID_UID);
-    }
-  } else {
-    LLDB_LOG(log, "failed to send packet");
-    error.SetErrorStringWithFormat("failed to send packet: '%s'",
-                                   escaped_packet.GetData());
+    if (response.IsErrorResponse())
+      return response.GetStatus().ToError();
+    if (response.IsUnsupportedResponse())
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "jLLDBTraceSupported is unsupported");
+
+    return llvm::json::parse<TraceSupportedResponse>(response.Peek(),
+                                                     "TraceSupportedResponse");
   }
-  return ret_uid;
+  LLDB_LOG(log, "failed to send packet: jLLDBTraceSupported");
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "failed to send packet: jLLDBTraceSupported");
 }
 
-Status
-GDBRemoteCommunicationClient::SendStopTracePacket(lldb::user_id_t uid,
-                                                  lldb::tid_t thread_id) {
+llvm::Error
+GDBRemoteCommunicationClient::SendTraceStop(const TraceStopRequest &request) {
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
-  StringExtractorGDBRemote response;
-  Status error;
 
-  StructuredData::Dictionary json_packet;
   StreamGDBRemote escaped_packet;
-  StreamString json_string;
-  escaped_packet.PutCString("jTraceStop:");
-
-  json_packet.AddIntegerItem("traceid", uid);
+  escaped_packet.PutCString("jLLDBTraceStop:");
 
-  if (thread_id != LLDB_INVALID_THREAD_ID)
-    json_packet.AddIntegerItem("threadid", thread_id);
+  std::string json_string;
+  llvm::raw_string_ostream os(json_string);
+  os << toJSON(request);
+  os.flush();
 
-  json_packet.Dump(json_string, false);
-
-  escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
+  escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size());
 
+  StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
                                    true) ==
       GDBRemoteCommunication::PacketResult::Success) {
-    if (!response.IsOKResponse()) {
-      error = response.GetStatus();
-      LLDB_LOG(log, "stop tracing failed");
-    }
-  } else {
-    LLDB_LOG(log, "failed to send packet");
-    error.SetErrorStringWithFormat(
-        "failed to send packet: '%s' with error '%d'", escaped_packet.GetData(),
-        response.GetError());
-  }
-  return error;
+    if (response.IsErrorResponse())
+      return response.GetStatus().ToError();
+    if (response.IsUnsupportedResponse())
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "jLLDBTraceStop is unsupported");
+    if (response.IsOKResponse())
+      return llvm::Error::success();
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Invalid jLLDBTraceStart response");
   }
-
-Status GDBRemoteCommunicationClient::SendGetDataPacket(
-    lldb::user_id_t uid, lldb::tid_t thread_id,
-    llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
-
-  StreamGDBRemote escaped_packet;
-  escaped_packet.PutCString("jTraceBufferRead:");
-  return SendGetTraceDataPacket(escaped_packet, uid, thread_id, buffer, offset);
+  LLDB_LOG(log, "failed to send packet: jLLDBTraceStop");
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "failed to send packet: jLLDBTraceStop '%s'",
+                                 escaped_packet.GetData());
 }
 
-Status GDBRemoteCommunicationClient::SendGetMetaDataPacket(
-    lldb::user_id_t uid, lldb::tid_t thread_id,
-    llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
+llvm::Error
+GDBRemoteCommunicationClient::SendTraceStart(const llvm::json::Value &params) {
+  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
 
   StreamGDBRemote escaped_packet;
-  escaped_packet.PutCString("jTraceMetaRead:");
-  return SendGetTraceDataPacket(escaped_packet, uid, thread_id, buffer, offset);
-}
+  escaped_packet.PutCString("jLLDBTraceStart:");
 
-llvm::Expected<TraceTypeInfo>
-GDBRemoteCommunicationClient::SendGetSupportedTraceType() {
-  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+  std::string json_string;
+  llvm::raw_string_ostream os(json_string);
+  os << params;
+  os.flush();
 
-  StreamGDBRemote escaped_packet;
-  escaped_packet.PutCString("jLLDBTraceSupportedType");
+  escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size());
 
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
                                    true) ==
       GDBRemoteCommunication::PacketResult::Success) {
     if (response.IsErrorResponse())
       return response.GetStatus().ToError();
     if (response.IsUnsupportedResponse())
       return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                     "jLLDBTraceSupportedType is unsupported");
-
-    if (llvm::Expected<TraceTypeInfo> type =
-            llvm::json::parse<TraceTypeInfo>(response.Peek()))
-      return *type;
-    else
-      return type.takeError();
+                                     "jLLDBTraceStart is unsupported");
+    if (response.IsOKResponse())
+      return llvm::Error::success();
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Invalid jLLDBTraceStart response");
   }
-  LLDB_LOG(log, "failed to send packet: jLLDBTraceSupportedType");
-  return llvm::createStringError(
-      llvm::inconvertibleErrorCode(),
-      "failed to send packet: jLLDBTraceSupportedType");
+  LLDB_LOG(log, "failed to send packet: jLLDBTraceStart");
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "failed to send packet: jLLDBTraceStart '%s'",
+                                 escaped_packet.GetData());
 }
 
-Status
-GDBRemoteCommunicationClient::SendGetTraceConfigPacket(lldb::user_id_t uid,
-                                                       TraceOptions &options) {
+llvm::Expected<std::string>
+GDBRemoteCommunicationClient::SendTraceGetState(llvm::StringRef type) {
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
-  StringExtractorGDBRemote response;
-  Status error;
 
-  StreamString json_string;
   StreamGDBRemote escaped_packet;
-  escaped_packet.PutCString("jTraceConfigRead:");
+  escaped_packet.PutCString("jLLDBTraceGetState:");
 
-  StructuredData::Dictionary json_packet;
-  json_packet.AddIntegerItem("traceid", uid);
+  std::string json_string;
+  llvm::raw_string_ostream os(json_string);
+  os << toJSON(TraceGetStateRequest{type.str()});
+  os.flush();
 
-  if (options.getThreadID() != LLDB_INVALID_THREAD_ID)
-    json_packet.AddIntegerItem("threadid", options.getThreadID());
-
-  json_packet.Dump(json_string, false);
-  escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
+  escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size());
 
+  StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
                                    true) ==
       GDBRemoteCommunication::PacketResult::Success) {
-    if (response.IsNormalResponse()) {
-      uint64_t type = std::numeric_limits<uint64_t>::max();
-      uint64_t buffersize = std::numeric_limits<uint64_t>::max();
-      uint64_t metabuffersize = std::numeric_limits<uint64_t>::max();
-
-      auto json_object = StructuredData::ParseJSON(response.Peek());
-
-      if (!json_object ||
-          json_object->GetType() != lldb::eStructuredDataTypeDictionary) {
-        error.SetErrorString("Invalid Configuration obtained");
-        return error;
-      }
+    if (response.IsErrorResponse())
+      return response.GetStatus().ToError();
+    if (response.IsUnsupportedResponse())
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "jLLDBTraceGetState is unsupported");
+    return std::string(response.Peek());
 
-      auto json_dict = json_object->GetAsDictionary();
-
-      json_dict->GetValueForKeyAsInteger<uint64_t>("metabuffersize",
-                                                   metabuffersize);
-      options.setMetaDataBufferSize(metabuffersize);
-
-      json_dict->GetValueForKeyAsInteger<uint64_t>("buffersize", buffersize);
-      options.setTraceBufferSize(buffersize);
-
-      json_dict->GetValueForKeyAsInteger<uint64_t>("type", type);
-      options.setType(static_cast<lldb::TraceType>(type));
-
-      StructuredData::ObjectSP custom_params_sp =
-          json_dict->GetValueForKey("params");
-      if (custom_params_sp) {
-        if (custom_params_sp->GetType() !=
-            lldb::eStructuredDataTypeDictionary) {
-          error.SetErrorString("Invalid Configuration obtained");
-          return error;
-        } else
-          options.setTraceParams(
-              std::static_pointer_cast<StructuredData::Dictionary>(
-                  custom_params_sp));
-      }
-    } else {
-      error = response.GetStatus();
-    }
-  } else {
-    LLDB_LOG(log, "failed to send packet");
-    error.SetErrorStringWithFormat("failed to send packet: '%s'",
-                                   escaped_packet.GetData());
-  }
-  return error;
-}
+  LLDB_LOG(log, "failed to send packet: jLLDBTraceGetState");
+  return llvm::createStringError(
+      llvm::inconvertibleErrorCode(),
+      "failed to send packet: jLLDBTraceGetState '%s'",
 
-Status GDBRemoteCommunicationClient::SendGetTraceDataPacket(
-    StreamGDBRemote &packet, lldb::user_id_t uid, lldb::tid_t thread_id,
-    llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
+llvm::Expected<std::vector<uint8_t>>
+GDBRemoteCommunicationClient::SendTraceGetBinaryData(
+    const TraceGetBinaryDataRequest &request) {
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
-  Status error;
-
-  StructuredData::Dictionary json_packet;
 
-  json_packet.AddIntegerItem("traceid", uid);
-  json_packet.AddIntegerItem("offset", offset);
-  json_packet.AddIntegerItem("buffersize", buffer.size());
+  StreamGDBRemote escaped_packet;
+  escaped_packet.PutCString("jLLDBTraceGetBinaryData:");
 
-  if (thread_id != LLDB_INVALID_THREAD_ID)
-    json_packet.AddIntegerItem("threadid", thread_id);
+  std::string json_string;
+  llvm::raw_string_ostream os(json_string);
+  os << toJSON(request);
+  os.flush();
 
-  StreamString json_string;
-  json_packet.Dump(json_string, false);
+  escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size());
 
-  packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
   StringExtractorGDBRemote response;
-  if (SendPacketAndWaitForResponse(packet.GetString(), response, true) ==
+  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
+                                   true) ==
       GDBRemoteCommunication::PacketResult::Success) {
-    if (response.IsNormalResponse()) {
-      size_t filled_size = response.GetHexBytesAvail(buffer);
-      buffer = llvm::MutableArrayRef<uint8_t>(buffer.data(), filled_size);
-    } else {
-      error = response.GetStatus();
-      buffer = buffer.slice(buffer.size());
-    }
-  } else {
-    LLDB_LOG(log, "failed to send packet");
-    error.SetErrorStringWithFormat("failed to send packet: '%s'",
-                                   packet.GetData());
-    buffer = buffer.slice(buffer.size());
+    if (response.IsErrorResponse())
+      return response.GetStatus().ToError();
+    if (response.IsUnsupportedResponse())
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "jLLDBTraceGetBinaryData is unsupported");
+    std::string data;
+    response.GetEscapedBinaryData(data);
+    return std::vector<uint8_t>(data.begin(), data.end());
   }
-  return error;
+  LLDB_LOG(log, "failed to send packet: jLLDBTraceGetBinaryData");
+  return llvm::createStringError(
+      llvm::inconvertibleErrorCode(),
+      "failed to send packet: jLLDBTraceGetBinaryData '%s'",
+      escaped_packet.GetData());
 }
 
 llvm::Optional<QOffsets> GDBRemoteCommunicationClient::GetQOffsets() {
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(
           "qOffsets", response, /*send_async=*/false) != PacketResult::Success)
     return llvm::None;
   if (!response.IsNormalResponse())

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h

protected:
 
   PacketResult SendErrorResponse(uint8_t error);
 
   PacketResult SendIllFormedResponse(const StringExtractorGDBRemote &packet,
                                      const char *error_message);
 
   PacketResult SendOKResponse();
 
+  /// Serialize and send a JSON object response.
+  PacketResult SendJSONResponse(const llvm::json::Value &value);
+
+  /// Serialize and send a JSON object response, or respond with an error if the
+  /// input object is an \a llvm::Error.
+  PacketResult SendJSONResponse(llvm::Expected<llvm::json::Value> value);
+
 private:
   GDBRemoteCommunicationServer(const GDBRemoteCommunicationServer &) = delete;
   const GDBRemoteCommunicationServer &
   operator=(const GDBRemoteCommunicationServer &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVER_H

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp

 #include "lldb/Host/Config.h"
 
 #include "GDBRemoteCommunicationServer.h"
 
 #include "ProcessGDBRemoteLog.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 #include "lldb/Utility/UnimplementedError.h"
+#include "llvm/Support/JSON.h"
 #include <cstring>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
+using namespace llvm;
 
 GDBRemoteCommunicationServer::GDBRemoteCommunicationServer(
     const char *comm_name, const char *listener_name)
     : GDBRemoteCommunication(comm_name, listener_name), m_exit_now(false) {
   RegisterPacketHandler(
       StringExtractorGDBRemote::eServerPacketType_QEnableErrorStrings,
       [this](StringExtractorGDBRemote packet, Status &error, bool &interrupt,
              bool &quit) { return this->Handle_QErrorStringEnable(packet); });

 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::SendOKResponse() {
   return SendPacketNoLock("OK");
 }
 
 bool GDBRemoteCommunicationServer::HandshakeWithClient() {
   return GetAck() == PacketResult::Success;
 }
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::SendJSONResponse(const json::Value &value) {
+  std::string json_string;
+  raw_string_ostream os(json_string);
+  os << value;
+  os.flush();
+  StreamGDBRemote escaped_response;
+  escaped_response.PutEscapedBytes(json_string.c_str(), json_string.size());
+  return SendPacketNoLock(escaped_response.GetString());
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::SendJSONResponse(Expected<json::Value> value) {
+  if (!value)
+    return SendErrorResponse(value.takeError());
+  return SendJSONResponse(*value);
+}

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

protected:
   PacketResult Handle_z(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_s(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qXfer(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_QSaveRegisterState(StringExtractorGDBRemote &packet);
 
-  PacketResult Handle_jTraceStart(StringExtractorGDBRemote &packet);
+  PacketResult Handle_jLLDBTraceSupported(StringExtractorGDBRemote &packet);
 
-  PacketResult Handle_jTraceRead(StringExtractorGDBRemote &packet);
+  PacketResult Handle_jLLDBTraceStart(StringExtractorGDBRemote &packet);
 
-  PacketResult Handle_jTraceStop(StringExtractorGDBRemote &packet);
+  PacketResult Handle_jLLDBTraceStop(StringExtractorGDBRemote &packet);
 
-  PacketResult Handle_jTraceConfigRead(StringExtractorGDBRemote &packet);
+  PacketResult Handle_jLLDBTraceGetState(StringExtractorGDBRemote &packet);
 
-  PacketResult Handle_jLLDBTraceSupportedType(StringExtractorGDBRemote &packet);
+  PacketResult Handle_jLLDBTraceGetBinaryData(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_QRestoreRegisterState(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_vAttach(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_vAttachWait(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qVAttachOrWaitSupported(StringExtractorGDBRemote &packet);

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_Z,
                                 &GDBRemoteCommunicationServerLLGS::Handle_Z);
   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_z,
                                 &GDBRemoteCommunicationServerLLGS::Handle_z);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_QPassSignals,
       &GDBRemoteCommunicationServerLLGS::Handle_QPassSignals);
 
   RegisterMemberFunctionHandler(
-      StringExtractorGDBRemote::eServerPacketType_jTraceStart,
-      &GDBRemoteCommunicationServerLLGS::Handle_jTraceStart);
+      StringExtractorGDBRemote::eServerPacketType_jLLDBTraceSupported,
+      &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupported);
   RegisterMemberFunctionHandler(
-      StringExtractorGDBRemote::eServerPacketType_jTraceBufferRead,
-      &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead);
+      StringExtractorGDBRemote::eServerPacketType_jLLDBTraceStart,
+      &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStart);
   RegisterMemberFunctionHandler(
-      StringExtractorGDBRemote::eServerPacketType_jTraceMetaRead,
-      &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead);
+      StringExtractorGDBRemote::eServerPacketType_jLLDBTraceStop,
+      &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStop);
   RegisterMemberFunctionHandler(
-      StringExtractorGDBRemote::eServerPacketType_jTraceStop,
-      &GDBRemoteCommunicationServerLLGS::Handle_jTraceStop);
+      StringExtractorGDBRemote::eServerPacketType_jLLDBTraceGetState,
+      &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetState);
   RegisterMemberFunctionHandler(
-      StringExtractorGDBRemote::eServerPacketType_jTraceConfigRead,
-      &GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead);
-  RegisterMemberFunctionHandler(
-      StringExtractorGDBRemote::eServerPacketType_jLLDBTraceSupportedType,
-      &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupportedType);
+      StringExtractorGDBRemote::eServerPacketType_jLLDBTraceGetBinaryData,
+      &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetBinaryData);
 
   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_g,
                                 &GDBRemoteCommunicationServerLLGS::Handle_g);
 
   RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k,
                         [this](StringExtractorGDBRemote packet, Status &error,
                                bool &interrupt, bool &quit) {
                           quit = true;
static const char *GetStopReasonString(StopReason stop_reason) {
   case eStopReasonWatchpoint:
     return "watchpoint";
   case eStopReasonSignal:
     return "signal";
   case eStopReasonException:
     return "exception";
   case eStopReasonExec:
     return "exec";
+  case eStopReasonProcessorTrace:
+    return "processor trace";
   case eStopReasonInstrumentation:
   case eStopReasonInvalid:
   case eStopReasonPlanComplete:
   case eStopReasonThreadExiting:
   case eStopReasonNone:
     break; // ignored
   }
   return nullptr;
while (true) {
     case eConnectionStatusInterrupted:
     case eConnectionStatusTimedOut:
       return;
     }
   }
 }
 
 GDBRemoteCommunication::PacketResult
-GDBRemoteCommunicationServerLLGS::Handle_jTraceStart(
+GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupported(
     StringExtractorGDBRemote &packet) {
-  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
   // Fail if we don't have a current process.
   if (!m_debugged_process_up ||
       (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
-    return SendErrorResponse(68);
-
-  if (!packet.ConsumeFront("jTraceStart:"))
-    return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
-
-  TraceOptions options;
-  uint64_t type = std::numeric_limits<uint64_t>::max();
-  uint64_t buffersize = std::numeric_limits<uint64_t>::max();
-  lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
-  uint64_t metabuffersize = std::numeric_limits<uint64_t>::max();
-
-  auto json_object = StructuredData::ParseJSON(packet.Peek());
-
-  if (!json_object ||
-      json_object->GetType() != lldb::eStructuredDataTypeDictionary)
-    return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
-
-  auto json_dict = json_object->GetAsDictionary();
-
-  json_dict->GetValueForKeyAsInteger("metabuffersize", metabuffersize);
-  options.setMetaDataBufferSize(metabuffersize);
-
-  json_dict->GetValueForKeyAsInteger("buffersize", buffersize);
-  options.setTraceBufferSize(buffersize);
-
-  json_dict->GetValueForKeyAsInteger("type", type);
-  options.setType(static_cast<lldb::TraceType>(type));
-
-  json_dict->GetValueForKeyAsInteger("threadid", tid);
-  options.setThreadID(tid);
-
-  StructuredData::ObjectSP custom_params_sp =
-      json_dict->GetValueForKey("params");
-  if (custom_params_sp &&
-      custom_params_sp->GetType() != lldb::eStructuredDataTypeDictionary)
-    return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
-
-  options.setTraceParams(
-      std::static_pointer_cast<StructuredData::Dictionary>(custom_params_sp));
-
-  if (buffersize == std::numeric_limits<uint64_t>::max() ||
-      type != lldb::TraceType::eTraceTypeProcessorTrace) {
-    LLDB_LOG(log, "Ill formed packet buffersize = {0} type = {1}", buffersize,
-             type);
-    return SendIllFormedResponse(packet, "JTrace:start: Ill formed packet ");
-  }
-
-  Status error;
-  lldb::user_id_t uid = LLDB_INVALID_UID;
-  uid = m_debugged_process_up->StartTrace(options, error);
-  LLDB_LOG(log, "uid is {0} , error is {1}", uid, error.GetError());
-  if (error.Fail())
-    return SendErrorResponse(error);
+    return SendErrorResponse(Status("Process not running."));
 
-  StreamGDBRemote response;
-  response.Printf("%" PRIx64, uid);
-  return SendPacketNoLock(response.GetString());
+  return SendJSONResponse(m_debugged_process_up->TraceSupported());
 }
 
 GDBRemoteCommunication::PacketResult
-GDBRemoteCommunicationServerLLGS::Handle_jTraceStop(
+GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStop(
     StringExtractorGDBRemote &packet) {
   // Fail if we don't have a current process.
   if (!m_debugged_process_up ||
       (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
-    return SendErrorResponse(68);
-
-  if (!packet.ConsumeFront("jTraceStop:"))
-    return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
-
-  lldb::user_id_t uid = LLDB_INVALID_UID;
-  lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
-
-  auto json_object = StructuredData::ParseJSON(packet.Peek());
-
-  if (!json_object ||
-      json_object->GetType() != lldb::eStructuredDataTypeDictionary)
-    return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
-
-  auto json_dict = json_object->GetAsDictionary();
-
-  if (!json_dict->GetValueForKeyAsInteger("traceid", uid))
-    return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
-
-  json_dict->GetValueForKeyAsInteger("threadid", tid);
+    return SendErrorResponse(Status("Process not running."));
 
-  Status error = m_debugged_process_up->StopTrace(uid, tid);
+  packet.ConsumeFront("jLLDBTraceStop:");
+  Expected<TraceStopRequest> stop_request =
+      json::parse<TraceStopRequest>(packet.Peek(), "TraceStopRequest");
+  if (!stop_request)
+    return SendErrorResponse(stop_request.takeError());
 
-  if (error.Fail())
-    return SendErrorResponse(error);
+  if (Error err = m_debugged_process_up->TraceStop(*stop_request))
+    return SendErrorResponse(std::move(err));
 
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
-GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupportedType(
+GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStart(
     StringExtractorGDBRemote &packet) {
 
   // Fail if we don't have a current process.
   if (!m_debugged_process_up ||
       (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
     return SendErrorResponse(Status("Process not running."));
 
-  llvm::Expected<TraceTypeInfo> supported_trace_type =
-      m_debugged_process_up->GetSupportedTraceType();
-  if (!supported_trace_type)
-    return SendErrorResponse(supported_trace_type.takeError());
-
-  StreamGDBRemote escaped_response;
-  StructuredData::Dictionary json_packet;
-
-  json_packet.AddStringItem("name", supported_trace_type->name);
-  json_packet.AddStringItem("description", supported_trace_type->description);
+  packet.ConsumeFront("jLLDBTraceStart:");
+  Expected<TraceStartRequest> request =
+      json::parse<TraceStartRequest>(packet.Peek(), "TraceStartRequest");
+  if (!request)
+    return SendErrorResponse(request.takeError());
+
+  if (Error err =
+          m_debugged_process_up->TraceStart(packet.Peek(), request->type))
+    return SendErrorResponse(std::move(err));
 
-  StreamString json_string;
-  json_packet.Dump(json_string, false);
-  escaped_response.PutEscapedBytes(json_string.GetData(),
-                                   json_string.GetSize());
-  return SendPacketNoLock(escaped_response.GetString());
+  return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
-GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead(
+GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetState(
     StringExtractorGDBRemote &packet) {
 
   // Fail if we don't have a current process.
   if (!m_debugged_process_up ||
       (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
-    return SendErrorResponse(68);
-
-  if (!packet.ConsumeFront("jTraceConfigRead:"))
-    return SendIllFormedResponse(packet,
-                                 "jTraceConfigRead: Ill formed packet ");
-
-  lldb::user_id_t uid = LLDB_INVALID_UID;
-  lldb::tid_t threadid = LLDB_INVALID_THREAD_ID;
-
-  auto json_object = StructuredData::ParseJSON(packet.Peek());
-
-  if (!json_object ||
-      json_object->GetType() != lldb::eStructuredDataTypeDictionary)
-    return SendIllFormedResponse(packet,
-                                 "jTraceConfigRead: Ill formed packet ");
-
-  auto json_dict = json_object->GetAsDictionary();
-
-  if (!json_dict->GetValueForKeyAsInteger("traceid", uid))
-    return SendIllFormedResponse(packet,
-                                 "jTraceConfigRead: Ill formed packet ");
-
-  json_dict->GetValueForKeyAsInteger("threadid", threadid);
-
-  TraceOptions options;
-  StreamGDBRemote response;
-
-  options.setThreadID(threadid);
-  Status error = m_debugged_process_up->GetTraceConfig(uid, options);
-
-  if (error.Fail())
-    return SendErrorResponse(error);
+    return SendErrorResponse(Status("Process not running."));
 
-  StreamGDBRemote escaped_response;
-  StructuredData::Dictionary json_packet;
+  packet.ConsumeFront("jLLDBTraceGetState:");
+  Expected<TraceGetStateRequest> request =
+      json::parse<TraceGetStateRequest>(packet.Peek(), "TraceGetStateRequest");
+  if (!request)
+    return SendErrorResponse(request.takeError());
 
-  json_packet.AddIntegerItem("type", options.getType());
-  json_packet.AddIntegerItem("buffersize", options.getTraceBufferSize());
-  json_packet.AddIntegerItem("metabuffersize", options.getMetaDataBufferSize());
-
-  StructuredData::DictionarySP custom_params = options.getTraceParams();
-  if (custom_params)
-    json_packet.AddItem("params", custom_params);
-
-  StreamString json_string;
-  json_packet.Dump(json_string, false);
-  escaped_response.PutEscapedBytes(json_string.GetData(),
-                                   json_string.GetSize());
-  return SendPacketNoLock(escaped_response.GetString());
+  return SendJSONResponse(m_debugged_process_up->TraceGetState(request->type));
 }
 
 GDBRemoteCommunication::PacketResult
-GDBRemoteCommunicationServerLLGS::Handle_jTraceRead(
+GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetBinaryData(
     StringExtractorGDBRemote &packet) {
 
   // Fail if we don't have a current process.
   if (!m_debugged_process_up ||
       (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
-    return SendErrorResponse(68);
-
-  enum PacketType { MetaData, BufferData };
-  PacketType tracetype = MetaData;
-
-  if (packet.ConsumeFront("jTraceBufferRead:"))
-    tracetype = BufferData;
-  else if (packet.ConsumeFront("jTraceMetaRead:"))
-    tracetype = MetaData;
-  else {
-    return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
-  }
-
-  lldb::user_id_t uid = LLDB_INVALID_UID;
-
-  uint64_t byte_count = std::numeric_limits<uint64_t>::max();
-  lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
-  uint64_t offset = std::numeric_limits<uint64_t>::max();
-
-  auto json_object = StructuredData::ParseJSON(packet.Peek());
-
-  if (!json_object ||
-      json_object->GetType() != lldb::eStructuredDataTypeDictionary)
-    return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
-
-  auto json_dict = json_object->GetAsDictionary();
-
-  if (!json_dict->GetValueForKeyAsInteger("traceid", uid) ||
-      !json_dict->GetValueForKeyAsInteger("offset", offset) ||
-      !json_dict->GetValueForKeyAsInteger("buffersize", byte_count))
-    return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
-
-  json_dict->GetValueForKeyAsInteger("threadid", tid);
+    return SendErrorResponse(Status("Process not running."));
 
-  // Allocate the response buffer.
-  std::unique_ptr<uint8_t[]> buffer (new (std::nothrow) uint8_t[byte_count]);
-  if (!buffer)
-    return SendErrorResponse(0x78);
+  packet.ConsumeFront("jLLDBTraceGetBinaryData:");
+  llvm::Expected<TraceGetBinaryDataRequest> request =
+      llvm::json::parse<TraceGetBinaryDataRequest>(packet.Peek(),
+                                                   "TraceGetBinaryDataRequest");
+  if (!request)
+    return SendErrorResponse(Status(request.takeError()));
 
+  if (Expected<std::vector<uint8_t>> bytes =
+          m_debugged_process_up->TraceGetBinaryData(*request)) {
     StreamGDBRemote response;
-  Status error;
-  llvm::MutableArrayRef<uint8_t> buf(buffer.get(), byte_count);
-
-  if (tracetype == BufferData)
-    error = m_debugged_process_up->GetData(uid, tid, buf, offset);
-  else if (tracetype == MetaData)
-    error = m_debugged_process_up->GetMetaData(uid, tid, buf, offset);
-
-  if (error.Fail())
-    return SendErrorResponse(error);
-
-  for (auto i : buf)
-    response.PutHex8(i);
-
-  StreamGDBRemote escaped_response;
-  escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
-  return SendPacketNoLock(escaped_response.GetString());
+    response.PutEscapedBytes(bytes->data(), bytes->size());
+    return SendPacketNoLock(response.GetString());
+  } else
+    return SendErrorResponse(bytes.takeError());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo(
     StringExtractorGDBRemote &packet) {
   // Fail if we don't have a current process.
   if (!m_debugged_process_up ||
       (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

public:
 
   // Process Watchpoints
   Status EnableWatchpoint(Watchpoint *wp, bool notify = true) override;
 
   Status DisableWatchpoint(Watchpoint *wp, bool notify = true) override;
 
   Status GetWatchpointSupportInfo(uint32_t &num) override;
 
-  lldb::user_id_t StartTrace(const TraceOptions &options,
-                             Status &error) override;
-
-  Status StopTrace(lldb::user_id_t uid, lldb::tid_t thread_id) override;
+  llvm::Expected<TraceSupportedResponse> TraceSupported() override;
 
-  Status GetData(lldb::user_id_t uid, lldb::tid_t thread_id,
-                 llvm::MutableArrayRef<uint8_t> &buffer,
-                 size_t offset = 0) override;
+  llvm::Error TraceStop(const TraceStopRequest &request) override;
 
-  Status GetMetaData(lldb::user_id_t uid, lldb::tid_t thread_id,
-                     llvm::MutableArrayRef<uint8_t> &buffer,
-                     size_t offset = 0) override;
+  llvm::Error TraceStart(const llvm::json::Value &request) override;
 
-  llvm::Expected<TraceTypeInfo> GetSupportedTraceType() override;
+  llvm::Expected<std::string> TraceGetState(llvm::StringRef type) override;
 
-  Status GetTraceConfig(lldb::user_id_t uid, TraceOptions &options) override;
+  llvm::Expected<std::vector<uint8_t>>
+  TraceGetBinaryData(const TraceGetBinaryDataRequest &request) override;
 
   Status GetWatchpointSupportInfo(uint32_t &num, bool &after) override;
 
   bool StartNoticingNewThreads() override;
 
   bool StopNoticingNewThreads() override;
 
   GDBRemoteCommunicationClient &GetGDBRemote() { return m_gdb_comm; }

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (error.Success()) {
           new EventDataBytes(packet.GetString().data(), packet.GetSize()));
 
     } else
       SetExitStatus(-1, error.AsCString());
   }
   return error;
 }
 
-lldb::user_id_t ProcessGDBRemote::StartTrace(const TraceOptions &options,
-                                             Status &error) {
-  return m_gdb_comm.SendStartTracePacket(options, error);
-}
-
-Status ProcessGDBRemote::StopTrace(lldb::user_id_t uid, lldb::tid_t thread_id) {
-  return m_gdb_comm.SendStopTracePacket(uid, thread_id);
+llvm::Expected<TraceSupportedResponse> ProcessGDBRemote::TraceSupported() {
+  return m_gdb_comm.SendTraceSupported();
 }
 
-Status ProcessGDBRemote::GetData(lldb::user_id_t uid, lldb::tid_t thread_id,
-                                 llvm::MutableArrayRef<uint8_t> &buffer,
-                                 size_t offset) {
-  return m_gdb_comm.SendGetDataPacket(uid, thread_id, buffer, offset);
+llvm::Error ProcessGDBRemote::TraceStop(const TraceStopRequest &request) {
+  return m_gdb_comm.SendTraceStop(request);
 }
 
-Status ProcessGDBRemote::GetMetaData(lldb::user_id_t uid, lldb::tid_t thread_id,
-                                     llvm::MutableArrayRef<uint8_t> &buffer,
-                                     size_t offset) {
-  return m_gdb_comm.SendGetMetaDataPacket(uid, thread_id, buffer, offset);
+llvm::Error ProcessGDBRemote::TraceStart(const llvm::json::Value &request) {
+  return m_gdb_comm.SendTraceStart(request);
 }
 
-Status ProcessGDBRemote::GetTraceConfig(lldb::user_id_t uid,
-                                        TraceOptions &options) {
-  return m_gdb_comm.SendGetTraceConfigPacket(uid, options);
+llvm::Expected<std::string>
+ProcessGDBRemote::TraceGetState(llvm::StringRef type) {
+  return m_gdb_comm.SendTraceGetState(type);
 }
 
-llvm::Expected<TraceTypeInfo> ProcessGDBRemote::GetSupportedTraceType() {
-  return m_gdb_comm.SendGetSupportedTraceType();
+llvm::Expected<std::vector<uint8_t>>
+ProcessGDBRemote::TraceGetBinaryData(const TraceGetBinaryDataRequest &request) {
+  return m_gdb_comm.SendTraceGetBinaryData(request);
 }
 
 void ProcessGDBRemote::DidExit() {
   // When we exit, disconnect from the GDB server communications
   m_gdb_comm.Disconnect();
 }
 
 void ProcessGDBRemote::DidAttach(ArchSpec &process_arch) {
if (thread_sp) {
               thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithException(
                   *thread_sp, description.c_str()));
               handled = true;
             } else if (reason == "exec") {
               did_exec = true;
               thread_sp->SetStopInfo(
                   StopInfo::CreateStopReasonWithExec(*thread_sp));
               handled = true;
+            } else if (reason == "processor trace") {
+              thread_sp->SetStopInfo(StopInfo::CreateStopReasonProcessorTrace(
+                  *thread_sp, description.c_str()));
             }
           } else if (!signo) {
             addr_t pc = thread_sp->GetRegisterContext()->GetPC();
             lldb::BreakpointSiteSP bp_site_sp =
                 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(
                     pc);
 
             // If the current pc is a breakpoint site then the StopInfo should

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

 //===-- CommandObjectTraceStartIntelPT.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_COMMANDOBJECTTRACESTARTINTELPT_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_COMMANDOBJECTTRACESTARTINTELPT_H
 
-#include "../../../../source/Commands/CommandObjectThreadUtil.h"
+#include "../../../../source/Commands/CommandObjectTrace.h"
+#include "TraceIntelPT.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
-class CommandObjectTraceStartIntelPT : public CommandObjectIterateOverThreads {
+class CommandObjectThreadTraceStartIntelPT
+    : public CommandObjectMultipleThreads {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
-    ~CommandOptions() override = default;
-
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override;
 
     void OptionParsingStarting(ExecutionContext *execution_context) override;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
-    size_t m_size_in_kb;
-    uint32_t m_custom_config;
+    size_t m_thread_buffer_size;
   };
 
-  CommandObjectTraceStartIntelPT(CommandInterpreter &interpreter)
-      : CommandObjectIterateOverThreads(
+  CommandObjectThreadTraceStartIntelPT(TraceIntelPT &trace,
+                                       CommandInterpreter &interpreter)
+      : CommandObjectMultipleThreads(
             interpreter, "thread trace start",
             "Start tracing one or more threads with intel-pt. "
             "Defaults to the current thread. Thread indices can be "
             "specified as arguments.\n Use the thread-index \"all\" to trace "
-            "all threads.",
+            "all threads including future threads.",
             "thread trace start [<thread-index> <thread-index> ...] "
             "[<intel-pt-options>]",
             lldb::eCommandRequiresProcess | lldb::eCommandTryTargetAPILock |
                 lldb::eCommandProcessMustBeLaunched |
                 lldb::eCommandProcessMustBePaused),
-        m_options() {}
+        m_trace(trace), m_options() {}
+
+  Options *GetOptions() override { return &m_options; }
+
+protected:
+  bool DoExecuteOnThreads(Args &command, CommandReturnObject &result,
+                          const std::vector<lldb::tid_t> &tids) override;
+
+  TraceIntelPT &m_trace;
+  CommandOptions m_options;
+};
+
+class CommandObjectProcessTraceStartIntelPT : public CommandObjectParsed {
+public:
+  class CommandOptions : public Options {
+  public:
+    CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
-  ~CommandObjectTraceStartIntelPT() override = default;
+    Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
+                          ExecutionContext *execution_context) override;
+
+    void OptionParsingStarting(ExecutionContext *execution_context) override;
+
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
+
+    size_t m_thread_buffer_size;
+    size_t m_process_buffer_size_limit;
+  };
+
+  CommandObjectProcessTraceStartIntelPT(TraceIntelPT &trace,
+                                        CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "process trace start",
+            "Start tracing this process with intel-pt, including future "
+            "threads. "
+            "This is implemented by tracing each thread independently. "
+            "Threads traced with the \"thread trace start\" command are left "
+            "unaffected ant not retraced.",
+            "process trace start [<intel-pt-options>]",
+            lldb::eCommandRequiresProcess | lldb::eCommandTryTargetAPILock |
+                lldb::eCommandProcessMustBeLaunched |
+                lldb::eCommandProcessMustBePaused),
+        m_trace(trace), m_options() {}
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
-  bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override;
+  bool DoExecute(Args &command, CommandReturnObject &result) override;
 
+  TraceIntelPT &m_trace;
   CommandOptions m_options;
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_COMMANDOBJECTTRACESTARTINTELPT_H

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

 //===-- CommandObjectTraceStartIntelPT.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 "CommandObjectTraceStartIntelPT.h"
 
+#include "TraceIntelPT.h"
 #include "lldb/Host/OptionParser.h"
+#include "lldb/Target/Process.h"
 #include "lldb/Target/Trace.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
+// CommandObjectThreadTraceStartIntelPT
+
 #define LLDB_OPTIONS_thread_trace_start_intel_pt
 #include "TraceIntelPTCommandOptions.inc"
 
-Status CommandObjectTraceStartIntelPT::CommandOptions::SetOptionValue(
+Status CommandObjectThreadTraceStartIntelPT::CommandOptions::SetOptionValue(
+    uint32_t option_idx, llvm::StringRef option_arg,
+    ExecutionContext *execution_context) {
+  Status error;
+  const int short_option = m_getopt_table[option_idx].val;
+
+  switch (short_option) {
+  case 's': {
+    int64_t thread_buffer_size;
+    if (option_arg.empty() || option_arg.getAsInteger(0, thread_buffer_size) ||
+        thread_buffer_size < 0)
+      error.SetErrorStringWithFormat("invalid integer value for option '%s'",
+                                     option_arg.str().c_str());
+    else
+      m_thread_buffer_size = thread_buffer_size;
+    break;
+  }
+  default:
+    llvm_unreachable("Unimplemented option");
+  }
+  return error;
+}
+
+void CommandObjectThreadTraceStartIntelPT::CommandOptions::
+    OptionParsingStarting(ExecutionContext *execution_context) {
+  m_thread_buffer_size = 4 * 1024; // 4KB
+}
+
+llvm::ArrayRef<OptionDefinition>
+CommandObjectThreadTraceStartIntelPT::CommandOptions::GetDefinitions() {
+  return llvm::makeArrayRef(g_thread_trace_start_intel_pt_options);
+}
+
+bool CommandObjectThreadTraceStartIntelPT::DoExecuteOnThreads(
+    Args &command, CommandReturnObject &result,
+    const std::vector<lldb::tid_t> &tids) {
+  if (Error err = m_trace.Start(tids, m_options.m_thread_buffer_size))
+    result.SetError(toString(std::move(err)));
+  else
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+
+  return result.Succeeded();
+}
+
+/// CommandObjectProcessTraceStartIntelPT
+
+#define LLDB_OPTIONS_process_trace_start_intel_pt
+#include "TraceIntelPTCommandOptions.inc"
+
+Status CommandObjectProcessTraceStartIntelPT::CommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
   const int short_option = m_getopt_table[option_idx].val;
 
   switch (short_option) {
   case 's': {
-    int32_t size_in_kb;
-    if (option_arg.empty() || option_arg.getAsInteger(0, size_in_kb) ||
-        size_in_kb < 0)
+    int64_t thread_buffer_size;
+    if (option_arg.empty() || option_arg.getAsInteger(0, thread_buffer_size) ||
+        thread_buffer_size < 0)
       error.SetErrorStringWithFormat("invalid integer value for option '%s'",
                                      option_arg.str().c_str());
     else
-      m_size_in_kb = size_in_kb;
+      m_thread_buffer_size = thread_buffer_size;
     break;
   }
-  case 'c': {
-    int32_t custom_config;
-    if (option_arg.empty() || option_arg.getAsInteger(0, custom_config) ||
-        custom_config < 0)
+  case 'l': {
+    int64_t process_buffer_size_limit;
+    if (option_arg.empty() ||
+        option_arg.getAsInteger(0, process_buffer_size_limit) ||
+        process_buffer_size_limit < 0)
       error.SetErrorStringWithFormat("invalid integer value for option '%s'",
                                      option_arg.str().c_str());
     else
-      m_custom_config = custom_config;
+      m_process_buffer_size_limit = process_buffer_size_limit;
     break;
   }
   default:
     llvm_unreachable("Unimplemented option");
   }
   return error;
 }
 
-void CommandObjectTraceStartIntelPT::CommandOptions::OptionParsingStarting(
-    ExecutionContext *execution_context) {
-  m_size_in_kb = 4;
-  m_custom_config = 0;
+void CommandObjectProcessTraceStartIntelPT::CommandOptions::
+    OptionParsingStarting(ExecutionContext *execution_context) {
+  m_thread_buffer_size = 4 * 1024;               // 4KB
+  m_process_buffer_size_limit = 5 * 1024 * 1024; // 500MB
 }
 
 llvm::ArrayRef<OptionDefinition>
-CommandObjectTraceStartIntelPT::CommandOptions::GetDefinitions() {
-  return llvm::makeArrayRef(g_thread_trace_start_intel_pt_options);
+CommandObjectProcessTraceStartIntelPT::CommandOptions::GetDefinitions() {
+  return llvm::makeArrayRef(g_process_trace_start_intel_pt_options);
 }
 
-bool CommandObjectTraceStartIntelPT::HandleOneThread(
-    lldb::tid_t tid, CommandReturnObject &result) {
-  result.AppendMessageWithFormat(
-      "would trace tid %" PRIu64 " with size_in_kb %zu and custom_config %d\n",
-      tid, m_options.m_size_in_kb, m_options.m_custom_config);
+bool CommandObjectProcessTraceStartIntelPT::DoExecute(
+    Args &command, CommandReturnObject &result) {
+  if (Error err = m_trace.Start(m_options.m_thread_buffer_size,
+                                m_options.m_process_buffer_size_limit))
+    result.SetError(toString(std::move(err)));
+  else
     result.SetStatus(eReturnStatusSuccessFinishResult);
+
   return result.Succeeded();
 }

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

 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_DECODEDTHREAD_H
 
 #include <vector>
 
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 
 #include "lldb/Target/Trace.h"
+#include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
 
 #include "intel-pt.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
 /// Class for representing a libipt decoding error.
 class IntelPTError : public llvm::ErrorInfo<IntelPTError> {

 /// Each decoded thread contains a cursor to the current position the user is
 /// stopped at. See \a Trace::GetCursorPosition for more information.
 class DecodedThread {
 public:
   DecodedThread(std::vector<IntelPTInstruction> &&instructions)
       : m_instructions(std::move(instructions)), m_position(GetLastPosition()) {
   }
 
+  /// Constructor with a single error signaling a complete failure of the
+  /// decoding process.
+  DecodedThread(llvm::Error error);
+
   /// Get the instructions from the decoded trace. Some of them might indicate
   /// errors (i.e. gaps) in the trace.
   ///
   /// \return
   ///   The instructions of the trace.
   llvm::ArrayRef<IntelPTInstruction> GetInstructions() const;
 
   /// \return

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

 }
 
 size_t DecodedThread::GetCursorPosition() const { return m_position; }
 
 size_t DecodedThread::SetCursorPosition(size_t new_position) {
   m_position = std::min(new_position, GetLastPosition());
   return m_position;
 }
+
+DecodedThread::DecodedThread(Error error) {
+  m_instructions.emplace_back(std::move(error));
+  m_position = GetLastPosition();
+}

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

 //===-- IntelPTDecoder.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_DECODER_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_DECODER_H
 
 #include "intel-pt.h"
 
 #include "DecodedThread.h"
+#include "forward-declarations.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/FileSpec.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
-/// \a lldb_private::ThreadTrace decoder that stores the output from decoding,
-/// avoiding recomputations, as decoding is expensive.
-class ThreadTraceDecoder {
+/// Base class that handles the decoding of a thread and caches the result.
+class ThreadDecoder {
 public:
-  /// \param[in] trace_thread
-  ///     The thread whose trace file will be decoded.
-  ///
-  /// \param[in] pt_cpu
-  ///     The libipt cpu used when recording the trace.
-  ThreadTraceDecoder(const std::shared_ptr<ThreadTrace> &trace_thread,
-                     const pt_cpu &pt_cpu)
-      : m_trace_thread(trace_thread), m_pt_cpu(pt_cpu), m_decoded_thread() {}
+  virtual ~ThreadDecoder() = default;
+
+  ThreadDecoder() = default;
 
-  /// Decode the thread and store the result internally.
+  /// Decode the thread and store the result internally, to avoid
+  /// recomputations.
   ///
   /// \return
   ///     A \a DecodedThread instance.
   const DecodedThread &Decode();
 
-private:
-  ThreadTraceDecoder(const ThreadTraceDecoder &other) = delete;
-  ThreadTraceDecoder &operator=(const ThreadTraceDecoder &other) = delete;
+  ThreadDecoder(const ThreadDecoder &other) = delete;
+  ThreadDecoder &operator=(const ThreadDecoder &other) = delete;
+
+protected:
+  /// Decode the thread.
+  ///
+  /// \return
+  ///     A \a DecodedThread instance.
+  virtual DecodedThread DoDecode() = 0;
 
-  std::shared_ptr<ThreadTrace> m_trace_thread;
-  pt_cpu m_pt_cpu;
   llvm::Optional<DecodedThread> m_decoded_thread;
 };
 
+/// Decoder implementation for \a lldb_private::ThreadPostMortemTrace, which are
+/// non-live processes that come trace session files.
+class PostMortemThreadDecoder : public ThreadDecoder {
+public:
+  /// \param[in] trace_thread
+  ///     The thread whose trace file will be decoded.
+  ///
+  /// \param[in] trace
+  ///     The main Trace object who owns this decoder and its data.
+  PostMortemThreadDecoder(const lldb::ThreadPostMortemTraceSP &trace_thread,
+                          TraceIntelPT &trace);
+
+private:
+  DecodedThread DoDecode() override;
+
+  lldb::ThreadPostMortemTraceSP m_trace_thread;
+  TraceIntelPT &m_trace;
+};
+
+class LiveThreadDecoder : public ThreadDecoder {
+public:
+  /// \param[in] thread
+  ///     The thread whose traces will be decoded.
+  ///
+  /// \param[in] trace
+  ///     The main Trace object who owns this decoder and its data.
+  LiveThreadDecoder(Thread &thread, TraceIntelPT &trace);
+
+private:
+  DecodedThread DoDecode() override;
+
+  lldb::ThreadSP m_thread_sp;
+  TraceIntelPT &m_trace;
+};
+
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_DECODER_H

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

-//===-- IntelPTDecoder.cpp --------------------------------------*- C++ -*-===//
-//
+//===-- IntelPTDecoder.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 "IntelPTDecoder.h"
 
 #include "llvm/Support/MemoryBuffer.h"
 
+#include "TraceIntelPT.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Target/ThreadTrace.h"
+#include "lldb/Target/ThreadPostMortemTrace.h"
+#include "lldb/Utility/StringExtractor.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 /// Move the decoder forward to the next synchronization point (i.e. next PSB
 /// packet).

 static int ProcessPTEvents(pt_insn_decoder &decoder, int errcode) {
   while (errcode & pts_event_pending) {
     pt_event event;
     errcode = pt_insn_event(&decoder, &event, sizeof(event));
     if (errcode < 0)
       return errcode;
   }
   return 0;
-};
+}
 
 /// Decode all the instructions from a configured decoder.
 /// The decoding flow is based on
 /// https://github.com/intel/libipt/blob/master/doc/howto_libipt.md#the-instruction-flow-decode-loop
 /// but with some relaxation to allow for gaps in the trace.
 ///
 /// Error codes returned by libipt while decoding are:
 /// - negative: actual errors
static int ReadProcessMemory(uint8_t *buffer, size_t size,
 
   Status error;
   int bytes_read = process->ReadMemory(pc, buffer, size, error);
   if (error.Fail())
     return -pte_nomap;
   return bytes_read;
 }
 
-static std::vector<IntelPTInstruction> makeInstructionListFromError(Error err) {
-  std::vector<IntelPTInstruction> instructions;
-  instructions.emplace_back(std::move(err));
-  return instructions;
-}
-
-static std::vector<IntelPTInstruction>
-CreateDecoderAndDecode(Process &process, const pt_cpu &pt_cpu,
-                       const FileSpec &trace_file) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> trace_or_error =
-      MemoryBuffer::getFile(trace_file.GetPath());
-  if (std::error_code err = trace_or_error.getError())
-    return makeInstructionListFromError(errorCodeToError(err));
-
-  MemoryBuffer &trace = **trace_or_error;
+static Expected<std::vector<IntelPTInstruction>>
+DecodeInMemoryTrace(Process &process, TraceIntelPT &trace_intel_pt,
+                    MutableArrayRef<uint8_t> buffer) {
+  Expected<pt_cpu> cpu_info = trace_intel_pt.GetCPUInfo();
+  if (!cpu_info)
+    return cpu_info.takeError();
 
   pt_config config;
   pt_config_init(&config);
-  config.cpu = pt_cpu;
+  config.cpu = *cpu_info;
 
   if (int errcode = pt_cpu_errata(&config.errata, &config.cpu))
-    return makeInstructionListFromError(make_error<IntelPTError>(errcode));
+    return make_error<IntelPTError>(errcode);
 
-  // The libipt library does not modify the trace buffer, hence the following
-  // cast is safe.
-  config.begin =
-      reinterpret_cast<uint8_t *>(const_cast<char *>(trace.getBufferStart()));
-  config.end =
-      reinterpret_cast<uint8_t *>(const_cast<char *>(trace.getBufferEnd()));
+  config.begin = buffer.data();
+  config.end = buffer.data() + buffer.size();
 
   pt_insn_decoder *decoder = pt_insn_alloc_decoder(&config);
   if (!decoder)
-    return makeInstructionListFromError(make_error<IntelPTError>(-pte_nomem));
+    return make_error<IntelPTError>(-pte_nomem);
 
   pt_image *image = pt_insn_get_image(decoder);
 
   int errcode = pt_image_set_callback(image, ReadProcessMemory, &process);
   assert(errcode == 0);
   (void)errcode;
 
   std::vector<IntelPTInstruction> instructions = DecodeInstructions(*decoder);
 
   pt_insn_free_decoder(decoder);
   return instructions;
 }
 
-const DecodedThread &ThreadTraceDecoder::Decode() {
-  if (!m_decoded_thread.hasValue()) {
-    m_decoded_thread = DecodedThread(
-        CreateDecoderAndDecode(*m_trace_thread->GetProcess(), m_pt_cpu,
-                               m_trace_thread->GetTraceFile()));
-  }
+static Expected<std::vector<IntelPTInstruction>>
+DecodeTraceFile(Process &process, TraceIntelPT &trace_intel_pt,
+                const FileSpec &trace_file) {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> trace_or_error =
+      MemoryBuffer::getFile(trace_file.GetPath());
+  if (std::error_code err = trace_or_error.getError())
+    return errorCodeToError(err);
 
+  MemoryBuffer &trace = **trace_or_error;
+  MutableArrayRef<uint8_t> trace_data(
+      // The libipt library does not modify the trace buffer, hence the
+      // following cast is safe.
+      reinterpret_cast<uint8_t *>(const_cast<char *>(trace.getBufferStart())),
+      trace.getBufferSize());
+  return DecodeInMemoryTrace(process, trace_intel_pt, trace_data);
+}
+
+static Expected<std::vector<IntelPTInstruction>>
+DecodeLiveThread(Thread &thread, TraceIntelPT &trace) {
+  Expected<std::vector<uint8_t>> buffer =
+      trace.GetLiveThreadBuffer(thread.GetID());
+  if (!buffer)
+    return buffer.takeError();
+  if (Expected<pt_cpu> cpu_info = trace.GetCPUInfo())
+    return DecodeInMemoryTrace(*thread.GetProcess(), trace,
+                               MutableArrayRef<uint8_t>(*buffer));
+  else
+    return cpu_info.takeError();
+}
+
+const DecodedThread &ThreadDecoder::Decode() {
+  if (!m_decoded_thread.hasValue())
+    m_decoded_thread = DoDecode();
   return *m_decoded_thread;
 }
+
+PostMortemThreadDecoder::PostMortemThreadDecoder(
+    const lldb::ThreadPostMortemTraceSP &trace_thread, TraceIntelPT &trace)
+    : m_trace_thread(trace_thread), m_trace(trace) {}
+
+DecodedThread PostMortemThreadDecoder::DoDecode() {
+  if (Expected<std::vector<IntelPTInstruction>> instructions =
+          DecodeTraceFile(*m_trace_thread->GetProcess(), m_trace,
+                          m_trace_thread->GetTraceFile()))
+    return DecodedThread(std::move(*instructions));
+  else
+    return DecodedThread(instructions.takeError());
+}
+
+LiveThreadDecoder::LiveThreadDecoder(Thread &thread, TraceIntelPT &trace)
+    : m_thread_sp(thread.shared_from_this()), m_trace(trace) {}
+
+DecodedThread LiveThreadDecoder::DoDecode() {
+  if (Expected<std::vector<IntelPTInstruction>> instructions =
+          DecodeLiveThread(*m_thread_sp, m_trace))
+    return DecodedThread(std::move(*instructions));
+  else
+    return DecodedThread(instructions.takeError());
+}

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

public:
   ///
   /// \param[in] debugger
   ///     The debugger instance where new Targets will be created as part of the
   ///     JSON data parsing.
   ///
   /// \return
   ///     A trace instance or an error in case of failures.
   static llvm::Expected<lldb::TraceSP>
-  CreateInstance(const llvm::json::Value &trace_session_file,
-                 llvm::StringRef session_file_dir, Debugger &debugger);
+  CreateInstanceForSessionFile(const llvm::json::Value &trace_session_file,
+                               llvm::StringRef session_file_dir,
+                               Debugger &debugger);
+
+  static llvm::Expected<lldb::TraceSP>
+  CreateInstanceForLiveProcess(Process &process);
 
   static ConstString GetPluginNameStatic();
 
   uint32_t GetPluginVersion() override;
   /// \}
 
+  lldb::CommandObjectSP
+  GetProcessTraceStartCommand(CommandInterpreter &interpreter) override;
+
+  lldb::CommandObjectSP
+  GetThreadTraceStartCommand(CommandInterpreter &interpreter) override;
+
   llvm::StringRef GetSchema() override;
 
   void TraverseInstructions(
-      const Thread &thread, size_t position, TraceDirection direction,
+      Thread &thread, size_t position, TraceDirection direction,
       std::function<bool(size_t index, llvm::Expected<lldb::addr_t> load_addr)>
           callback) override;
 
-  size_t GetInstructionCount(const Thread &thread) override;
+  size_t GetInstructionCount(Thread &thread) override;
+
+  size_t GetCursorPosition(Thread &thread) override;
+
+  void DoRefreshLiveProcessState(
+      llvm::Expected<TraceGetStateResponse> state) override;
+
+  bool IsTraced(const Thread &thread) override;
+
+  /// Start tracing a live process.
+  ///
+  /// \param[in] thread_buffer_size
+  ///     Trace size per thread in bytes.
+  ///
+  /// \param[in] total_buffer_size_limit
+  ///     Maximum total trace size per process in bytes. This limit applies to
+  ///     the sum of the sizes of all thread traces of this process, excluding
+  ///     the threads traced explicitly.
+  ///
+  ///     Whenever a thread is attempted to be traced due to this operation and
+  ///     the limit would be reached, the process is stopped with a "tracing"
+  ///     reason, so that the user can retrace the process if needed.
+  ///
+  /// \return
+  ///     \a llvm::Error::success if the operation was successful, or
+  ///     \a llvm::Error otherwise.
+  llvm::Error Start(size_t thread_buffer_size, size_t total_buffer_size_limit);
+
+  /// Start tracing a live threads.
+  ///
+  /// \param[in] tids
+  ///     Threads to trace.
+  ///
+  /// \param[in] thread_buffer_size
+  ///     Trace size per thread in bytes.
+  ///
+  /// \return
+  ///     \a llvm::Error::success if the operation was successful, or
+  ///     \a llvm::Error otherwise.
+  llvm::Error Start(const std::vector<lldb::tid_t> &tids,
+                    size_t thread_buffer_size);
+
+  /// Get the thread buffer content for a live thread
+  llvm::Expected<std::vector<uint8_t>> GetLiveThreadBuffer(lldb::tid_t tid);
 
-  size_t GetCursorPosition(const Thread &thread) override;
+  llvm::Expected<pt_cpu> GetCPUInfo();
 
 private:
   friend class TraceIntelPTSessionFileParser;
 
+  llvm::Expected<pt_cpu> GetCPUInfoForLiveProcess();
+
   /// \param[in] trace_threads
   ///     ThreadTrace instances, which are not live-processes and whose trace
   ///     files are fixed.
-  TraceIntelPT(const pt_cpu &pt_cpu,
-               const std::vector<std::shared_ptr<ThreadTrace>> &traced_threads);
+  TraceIntelPT(
+      const pt_cpu &cpu_info,
+      const std::vector<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. That trace must be managed by this class.
   ///
   /// \param[in] thread
   ///     If \a thread is a \a ThreadTrace, then its internal trace file will be
   ///     decoded. Live threads are not currently supported.
   ///
   /// \return
   ///     A \a DecodedThread instance if decoding was successful, or a \b
   ///     nullptr if the thread's trace is not managed by this class.
-  const DecodedThread *Decode(const Thread &thread);
+  const DecodedThread *Decode(Thread &thread);
 
-  pt_cpu m_pt_cpu;
-  std::map<std::pair<lldb::pid_t, lldb::tid_t>, ThreadTraceDecoder>
-      m_trace_threads;
+  /// It is provided by either a session file or a live process' "cpuInfo"
+  /// binary data.
+  llvm::Optional<pt_cpu> m_cpu_info;
+  std::map<const Thread *, std::unique_ptr<ThreadDecoder>> m_thread_decoders;
+  /// Dummy DecodedThread used when decoding threads after there were errors
+  /// when refreshing the live process state.
+  llvm::Optional<DecodedThread> m_failed_live_threads_decoder;
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPT_H

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

 //===-- TraceIntelPT.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 "TraceIntelPT.h"
 
 #include "CommandObjectTraceStartIntelPT.h"
 #include "TraceIntelPTSessionFileParser.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Target/ThreadTrace.h"
+#include "lldb/Target/ThreadPostMortemTrace.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 LLDB_PLUGIN_DEFINE(TraceIntelPT)
 
-CommandObjectSP GetStartCommand(CommandInterpreter &interpreter) {
-  return CommandObjectSP(new CommandObjectTraceStartIntelPT(interpreter));
+lldb::CommandObjectSP
+TraceIntelPT::GetProcessTraceStartCommand(CommandInterpreter &interpreter) {
+  return CommandObjectSP(
+      new CommandObjectProcessTraceStartIntelPT(*this, interpreter));
+}
+
+lldb::CommandObjectSP
+TraceIntelPT::GetThreadTraceStartCommand(CommandInterpreter &interpreter) {
+  return CommandObjectSP(
+      new CommandObjectThreadTraceStartIntelPT(*this, interpreter));
 }
 
 void TraceIntelPT::Initialize() {
-  PluginManager::RegisterPlugin(
-      GetPluginNameStatic(), "Intel Processor Trace", CreateInstance,
-      TraceIntelPTSessionFileParser::GetSchema(), GetStartCommand);
+  PluginManager::RegisterPlugin(GetPluginNameStatic(), "Intel Processor Trace",
+                                CreateInstanceForSessionFile,
+                                CreateInstanceForLiveProcess,
+                                TraceIntelPTSessionFileParser::GetSchema());
 }
 
 void TraceIntelPT::Terminate() {
-  PluginManager::UnregisterPlugin(CreateInstance);
+  PluginManager::UnregisterPlugin(CreateInstanceForSessionFile);
 }
 
 ConstString TraceIntelPT::GetPluginNameStatic() {
   static ConstString g_name("intel-pt");
   return g_name;
 }
 
 StringRef TraceIntelPT::GetSchema() {
   return TraceIntelPTSessionFileParser::GetSchema();
 }
 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 
 ConstString TraceIntelPT::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t TraceIntelPT::GetPluginVersion() { return 1; }
 
 void TraceIntelPT::Dump(Stream *s) const {}
 
-Expected<TraceSP>
-TraceIntelPT::CreateInstance(const json::Value &trace_session_file,
-                             StringRef session_file_dir, Debugger &debugger) {
+Expected<TraceSP> TraceIntelPT::CreateInstanceForSessionFile(
+    const json::Value &trace_session_file, StringRef session_file_dir,
+    Debugger &debugger) {
   return TraceIntelPTSessionFileParser(debugger, trace_session_file,
                                        session_file_dir)
       .Parse();
 }
 
+Expected<TraceSP> TraceIntelPT::CreateInstanceForLiveProcess(Process &process) {
+  TraceSP instance(new TraceIntelPT(process));
+  process.GetTarget().SetTrace(instance);
+  return instance;
+}
+
 TraceIntelPT::TraceIntelPT(
-    const pt_cpu &pt_cpu,
-    const std::vector<std::shared_ptr<ThreadTrace>> &traced_threads)
-    : m_pt_cpu(pt_cpu) {
-  for (const std::shared_ptr<ThreadTrace> &thread : traced_threads)
-    m_trace_threads.emplace(
-        std::piecewise_construct,
-        std::forward_as_tuple(thread->GetProcess()->GetID(), thread->GetID()),
-        std::forward_as_tuple(thread, pt_cpu));
+    const pt_cpu &cpu_info,
+    const std::vector<ThreadPostMortemTraceSP> &traced_threads)
+    : m_cpu_info(cpu_info) {
+  for (const ThreadPostMortemTraceSP &thread : traced_threads)
+    m_thread_decoders.emplace(
+        thread.get(), std::make_unique<PostMortemThreadDecoder>(thread, *this));
 }
 
-const DecodedThread *TraceIntelPT::Decode(const Thread &thread) {
-  auto it = m_trace_threads.find(
-      std::make_pair(thread.GetProcess()->GetID(), thread.GetID()));
-  if (it == m_trace_threads.end())
+const DecodedThread *TraceIntelPT::Decode(Thread &thread) {
+  RefreshLiveProcessState();
+  if (m_failed_live_threads_decoder.hasValue())
+    return &*m_failed_live_threads_decoder;
+
+  auto it = m_thread_decoders.find(&thread);
+  if (it == m_thread_decoders.end())
     return nullptr;
-  return &it->second.Decode();
+  return &it->second->Decode();
 }
 
-size_t TraceIntelPT::GetCursorPosition(const Thread &thread) {
+size_t TraceIntelPT::GetCursorPosition(Thread &thread) {
   const DecodedThread *decoded_thread = Decode(thread);
   if (!decoded_thread)
     return 0;
   return decoded_thread->GetCursorPosition();
 }
 
 void TraceIntelPT::TraverseInstructions(
-    const Thread &thread, size_t position, TraceDirection direction,
+    Thread &thread, size_t position, TraceDirection direction,
     std::function<bool(size_t index, Expected<lldb::addr_t> load_addr)>
         callback) {
   const DecodedThread *decoded_thread = Decode(thread);
   if (!decoded_thread)
     return;
 
   ArrayRef<IntelPTInstruction> instructions = decoded_thread->GetInstructions();
 
   ssize_t delta = direction == TraceDirection::Forwards ? 1 : -1;
   for (ssize_t i = position; i < (ssize_t)instructions.size() && i >= 0;
        i += delta)
     if (!callback(i, instructions[i].GetLoadAddress()))
       break;
 }
 
-size_t TraceIntelPT::GetInstructionCount(const Thread &thread) {
+size_t TraceIntelPT::GetInstructionCount(Thread &thread) {
   if (const DecodedThread *decoded_thread = Decode(thread))
     return decoded_thread->GetInstructions().size();
   else
     return 0;
 }
+
+Expected<pt_cpu> TraceIntelPT::GetCPUInfoForLiveProcess() {
+  Expected<std::vector<uint8_t>> cpu_info = GetLiveProcessBinaryData("cpuInfo");
+  if (!cpu_info)
+    return cpu_info.takeError();
+
+  int64_t cpu_family = -1;
+  int64_t model = -1;
+  int64_t stepping = -1;
+  std::string vendor_id;
+
+  StringRef rest(reinterpret_cast<const char *>(cpu_info->data()),
+                 cpu_info->size());
+  while (!rest.empty()) {
+    StringRef line;
+    std::tie(line, rest) = rest.split('\n');
+
+    SmallVector<StringRef, 2> columns;
+    line.split(columns, StringRef(":"), -1, false);
+
+    if (columns.size() < 2)
+      continue; // continue searching
+
+    columns[1] = columns[1].trim(" ");
+    if (columns[0].contains("cpu family") &&
+        columns[1].getAsInteger(10, cpu_family))
+      continue;
+
+    else if (columns[0].contains("model") && columns[1].getAsInteger(10, model))
+      continue;
+
+    else if (columns[0].contains("stepping") &&
+             columns[1].getAsInteger(10, stepping))
+      continue;
+
+    else if (columns[0].contains("vendor_id")) {
+      vendor_id = columns[1].str();
+      if (!vendor_id.empty())
+        continue;
+    }
+
+    if ((cpu_family != -1) && (model != -1) && (stepping != -1) &&
+        (!vendor_id.empty())) {
+      return pt_cpu{vendor_id == "GenuineIntel" ? pcv_intel : pcv_unknown,
+                    static_cast<uint16_t>(cpu_family),
+                    static_cast<uint8_t>(model),
+                    static_cast<uint8_t>(stepping)};
+    }
+  }
+  return createStringError(inconvertibleErrorCode(),
+                           "Failed parsing the target's /proc/cpuinfo file");
+}
+
+Expected<pt_cpu> TraceIntelPT::GetCPUInfo() {
+  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;
+}
+
+void TraceIntelPT::DoRefreshLiveProcessState(
+    Expected<TraceGetStateResponse> state) {
+  m_thread_decoders.clear();
+
+  if (!state) {
+    m_failed_live_threads_decoder = DecodedThread(state.takeError());
+    return;
+  }
+
+  for (const TraceThreadState &thread_state : state->tracedThreads) {
+    Thread &thread =
+        *m_live_process->GetThreadList().FindThreadByID(thread_state.tid);
+    m_thread_decoders.emplace(
+        &thread, std::make_unique<LiveThreadDecoder>(thread, *this));
+  }
+}
+
+bool TraceIntelPT::IsTraced(const Thread &thread) {
+  return m_thread_decoders.count(&thread);
+}
+
+Error TraceIntelPT::Start(size_t thread_buffer_size,
+                          size_t total_buffer_size_limit) {
+  TraceIntelPTStartRequest request;
+  request.threadBufferSize = thread_buffer_size;
+  request.processBufferSizeLimit = total_buffer_size_limit;
+  request.type = GetPluginName().AsCString();
+  return Trace::Start(toJSON(request));
+}
+
+llvm::Error TraceIntelPT::Start(const std::vector<lldb::tid_t> &tids,
+                                size_t thread_buffer_size) {
+  TraceIntelPTStartRequest request;
+  request.threadBufferSize = thread_buffer_size;
+  request.type = GetPluginName().AsCString();
+  request.tids.emplace();
+  for (lldb::tid_t tid : tids)
+    request.tids->push_back(tid);
+  return Trace::Start(toJSON(request));
+}
+
+Expected<std::vector<uint8_t>>
+TraceIntelPT::GetLiveThreadBuffer(lldb::tid_t tid) {
+  return Trace::GetLiveThreadBinaryData(tid, "threadTraceBuffer");
+}

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTOptions.td

 include "../../../../source/Commands/OptionsBase.td"
 
 let Command = "thread trace start intel pt" in {
   def thread_trace_start_intel_pt_size: Option<"size", "s">,
     Group<1>,
     Arg<"Value">,
-    Desc<"The size of the trace in KB. The kernel rounds it down to the nearest"
-         " multiple of 4. Defaults to 4.">;
-  def thread_trace_start_intel_pt_custom_config: Option<"custom-config", "c">,
+    Desc<"Trace size in bytes per thread. It must be a power of 2 greater "
+         "than or equal to 4096 (2^12). The trace is circular keeping "
+         "the most recent data. Defaults to 4096 bytes.">;
+}
+
+let Command = "process trace start intel pt" in {
+  def process_trace_start_intel_pt_thread_size: Option<"thread-size", "s">,
+    Group<1>,
+    Arg<"Value">,
+    Desc<"Trace size in bytes per thread. It must be a power of 2 greater "
+         "than or equal to 4096 (2^12). The trace is circular keeping "
+         "the most recent data. Defaults to 4096 bytes.">;
+  def process_trace_start_intel_pt_process_size_limit: Option<"total-size-limit", "l">,
     Group<1>,
     Arg<"Value">,
-    Desc<"Low level bitmask configuration for the kernel based on the values "
-         "in `grep -H  /sys/bus/event_source/devices/intel_pt/format/*`. "
-         "See https://github.com/torvalds/linux/blob/master/tools/perf/Documentation/perf-intel-pt.txt"
-         " for more information. Defaults to 0.">;
+    Desc<"Maximum total trace size per process in bytes. This limit applies to "
+         "the sum of the sizes of all thread traces of this process, excluding "
+         "the ones created with the \"thread trace start\" command. "
+         "Whenever a thread is attempted to be traced due to this command and "
+         "the limit would be reached, the process is stopped with a \"tracing\" "
+         "reason, so that the user can retrace the process if needed.">;
 }

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

 
 namespace lldb_private {
 namespace trace_intel_pt {
 
 class TraceIntelPT;
 
 class TraceIntelPTSessionFileParser : public TraceSessionFileParser {
 public:
-  struct JSONPTCPU {
-    std::string vendor;
+  struct JSONTraceIntelPTCPUInfo {
     int64_t family;
     int64_t model;
     int64_t stepping;
+    std::string vendor;
   };
 
   struct JSONTraceIntelPTSettings
       : TraceSessionFileParser::JSONTracePluginSettings {
-    JSONPTCPU pt_cpu;
+    JSONTraceIntelPTCPUInfo cpuInfo;
   };
 
   /// See \a TraceSessionFileParser::TraceSessionFileParser for the description
   /// of these fields.
   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) {}
 
   /// \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 &pt_cpu,
+  CreateTraceIntelPTInstance(const pt_cpu &cpu_info,
                              std::vector<ParsedProcess> &parsed_processes);
 
 private:
-  pt_cpu ParsePTCPU(const JSONPTCPU &pt_cpu);
+  static pt_cpu ParsePTCPU(const JSONTraceIntelPTCPUInfo &cpu_info);
 
   const llvm::json::Value &m_trace_session_file;
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 namespace llvm {
 namespace json {
 
-bool fromJSON(
-    const Value &value,
-    lldb_private::trace_intel_pt::TraceIntelPTSessionFileParser::JSONPTCPU
-        &pt_cpu,
-    Path path);
-
 bool fromJSON(const Value &value,
               lldb_private::trace_intel_pt::TraceIntelPTSessionFileParser::
                   JSONTraceIntelPTSettings &plugin_settings,
               Path path);
 
+bool fromJSON(const llvm::json::Value &value,
+              lldb_private::trace_intel_pt::TraceIntelPTSessionFileParser::
+                  JSONTraceIntelPTCPUInfo &packet,
+              llvm::json::Path path);
+
+llvm::json::Value
+toJSON(const lldb_private::trace_intel_pt::TraceIntelPTSessionFileParser::
+           JSONTraceIntelPTCPUInfo &packet);
+
 } // namespace json
 } // namespace llvm
 
 #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 "lldb/Core/Debugger.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadList.h"
-#include "lldb/Target/ThreadTrace.h"
+#include "lldb/Target/ThreadPostMortemTrace.h"
+#include "lldb/Utility/TraceOptions.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 StringRef TraceIntelPTSessionFileParser::GetSchema() {
   static std::string schema;
   if (schema.empty()) {
     schema = TraceSessionFileParser::BuildSchema(R"({
     "type": "intel-pt",
-    "pt_cpu": {
+    "cpuInfo": {
       "vendor": "intel" | "unknown",
       "family": integer,
       "model": integer,
       "stepping": integer
     }
   })");
   }
   return schema;
 }
 
-pt_cpu TraceIntelPTSessionFileParser::ParsePTCPU(const JSONPTCPU &pt_cpu) {
-  return {pt_cpu.vendor.compare("intel") == 0 ? pcv_intel : pcv_unknown,
-          static_cast<uint16_t>(pt_cpu.family),
-          static_cast<uint8_t>(pt_cpu.model),
-          static_cast<uint8_t>(pt_cpu.stepping)};
+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)};
 }
 
 TraceSP TraceIntelPTSessionFileParser::CreateTraceIntelPTInstance(
-    const pt_cpu &pt_cpu, std::vector<ParsedProcess> &parsed_processes) {
-  std::vector<ThreadTraceSP> threads;
+    const pt_cpu &cpu_info, std::vector<ParsedProcess> &parsed_processes) {
+  std::vector<ThreadPostMortemTraceSP> threads;
   for (const ParsedProcess &parsed_process : parsed_processes)
     threads.insert(threads.end(), parsed_process.threads.begin(),
                    parsed_process.threads.end());
 
-  TraceSP trace_instance(new TraceIntelPT(pt_cpu, threads));
+  TraceSP trace_instance(new TraceIntelPT(cpu_info, 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");
   TraceSessionFileParser::JSONTraceSession<JSONTraceIntelPTSettings> session;
   if (!json::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.pt_cpu),
+    return CreateTraceIntelPTInstance(ParsePTCPU(session.trace.cpuInfo),
                                       *parsed_processes);
   else
     return parsed_processes.takeError();
 }
 
 namespace llvm {
 namespace json {
 
-bool fromJSON(const Value &value,
-              TraceIntelPTSessionFileParser::JSONPTCPU &pt_cpu, Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("vendor", pt_cpu.vendor) &&
-         o.map("family", pt_cpu.family) && o.map("model", pt_cpu.model) &&
-         o.map("stepping", pt_cpu.stepping);
-}
-
 bool fromJSON(
     const Value &value,
     TraceIntelPTSessionFileParser::JSONTraceIntelPTSettings &plugin_settings,
     Path path) {
   ObjectMapper o(value, path);
-  return o && o.map("pt_cpu", plugin_settings.pt_cpu) &&
+  return o && o.map("cpuInfo", plugin_settings.cpuInfo) &&
          fromJSON(
              value,
              (TraceSessionFileParser::JSONTracePluginSettings &)plugin_settings,
              path);
 }
 
+bool fromJSON(const json::Value &value,
+              TraceIntelPTSessionFileParser::JSONTraceIntelPTCPUInfo &cpu_info,
+              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);
+}
+
+Value toJSON(
+    const TraceIntelPTSessionFileParser::JSONTraceIntelPTCPUInfo &cpu_info) {
+  return Value(Object{{"family", cpu_info.family},
+                      {"model", cpu_info.model},
+                      {"stepping", cpu_info.stepping},
+                      {"vendor", cpu_info.vendor}});
+}
+
 } // namespace json
 } // namespace llvm

lldb/source/Plugins/Trace/intel-pt/forward-declarations.h

+//===-- forward-declarations.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_FORWARD_DECLARATIONS_H
+#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_FORWARD_DECLARATIONS_H
+
+namespace lldb_private {
+namespace trace_intel_pt {
+
+class TraceIntelPT;
+class ThreadDecoder;
+
+} // namespace trace_intel_pt
+} // namespace lldb_private
+#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_FORWARD_DECLARATIONS_H

lldb/source/Target/CMakeLists.txt

add_lldb_library(lldbTarget
   ThreadPlanStepOverBreakpoint.cpp
   ThreadPlanStepOverRange.cpp
   ThreadPlanStepRange.cpp
   ThreadPlanStepThrough.cpp
   ThreadPlanStepUntil.cpp
   ThreadPlanTracer.cpp
   ThreadPlanStack.cpp
   ThreadSpec.cpp
-  ThreadTrace.cpp
+  ThreadPostMortemTrace.cpp
   Trace.cpp
   TraceSessionFileParser.cpp
   UnixSignals.cpp
   UnwindAssembly.cpp
   UnwindLLDB.cpp
 
   LINK_LIBS
     lldbBreakpoint

lldb/source/Target/Process.cpp

if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
             }
             case eStopReasonTrace:
             case eStopReasonBreakpoint:
             case eStopReasonWatchpoint:
             case eStopReasonException:
             case eStopReasonExec:
             case eStopReasonThreadExiting:
             case eStopReasonInstrumentation:
+            case eStopReasonProcessorTrace:
               if (!other_thread)
                 other_thread = thread;
               break;
             case eStopReasonPlanComplete:
               if (!plan_thread)
                 plan_thread = thread;
               break;
             }
UtilityFunction *Process::GetLoadImageUtilityFunction(
     llvm::function_ref<std::unique_ptr<UtilityFunction>()> factory) {
   if (platform != GetTarget().GetPlatform().get())
     return nullptr;
   llvm::call_once(m_dlopen_utility_func_flag_once,
                   [&] { m_dlopen_utility_func_up = factory(); });
   return m_dlopen_utility_func_up.get();
 }
 
-llvm::Expected<TraceTypeInfo> Process::GetSupportedTraceType() {
+llvm::Expected<TraceSupportedResponse> Process::TraceSupported() {
   if (!IsLiveDebugSession())
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Can't trace a non-live process.");
   return llvm::make_error<UnimplementedError>();
 }
 
 bool Process::CallVoidArgVoidPtrReturn(const Address *address,
                                        addr_t &returned_func,

lldb/source/Target/ProcessTrace.cpp

bool ProcessTrace::DoUpdateThreadList(ThreadList &old_thread_list,
                                       ThreadList &new_thread_list) {
   return false;
 }
 
 void ProcessTrace::RefreshStateAfterStop() {}
 
 Status ProcessTrace::DoDestroy() { return Status(); }
 
-bool ProcessTrace::IsAlive() { return true; }
-
 size_t ProcessTrace::ReadMemory(addr_t addr, void *buf, size_t size,
                                 Status &error) {
   // Don't allow the caching that lldb_private::Process::ReadMemory does since
   // we have it all cached in the trace files.
   return DoReadMemory(addr, buf, size, error);
 }
 
 void ProcessTrace::Clear() { m_thread_list.Clear(); }

lldb/source/Target/StopInfo.cpp

public:
   const char *GetDescription() override {
     if (m_description.empty())
       return "exception";
     else
       return m_description.c_str();
   }
 };
 
+// StopInfoProcessorTrace
+
+class StopInfoProcessorTrace : public StopInfo {
+public:
+  StopInfoProcessorTrace(Thread &thread, const char *description)
+      : StopInfo(thread, LLDB_INVALID_UID) {
+    if (description)
+      SetDescription(description);
+  }
+
+  ~StopInfoProcessorTrace() override = default;
+
+  StopReason GetStopReason() const override {
+    return eStopReasonProcessorTrace;
+  }
+
+  const char *GetDescription() override {
+    if (m_description.empty())
+      return "processor trace event";
+    else
+      return m_description.c_str();
+  }
+};
+
 // StopInfoThreadPlan
 
 class StopInfoThreadPlan : public StopInfo {
 public:
   StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp,
                      ExpressionVariableSP &expression_variable_sp)
       : StopInfo(plan_sp->GetThread(), LLDB_INVALID_UID), m_plan_sp(plan_sp),
         m_return_valobj_sp(return_valobj_sp),
return StopInfoSP(new StopInfoThreadPlan(plan_sp, return_valobj_sp,
                                            expression_variable_sp));
 }
 
 StopInfoSP StopInfo::CreateStopReasonWithException(Thread &thread,
                                                    const char *description) {
   return StopInfoSP(new StopInfoException(thread, description));
 }
 
+StopInfoSP StopInfo::CreateStopReasonProcessorTrace(Thread &thread,
+                                                    const char *description) {
+  return StopInfoSP(new StopInfoProcessorTrace(thread, description));
+}
+
 StopInfoSP StopInfo::CreateStopReasonWithExec(Thread &thread) {
   return StopInfoSP(new StopInfoExec(thread));
 }
 
 ValueObjectSP StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp) {
   if (stop_info_sp &&
       stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
     StopInfoThreadPlan *plan_stop_info =

lldb/source/Target/Target.cpp

error.SetErrorStringWithFormat("initial process state wasn't stopped: %s",
                                    StateAsCString(state));
     break;
   }
   return error;
 }
 
 void Target::SetTrace(const TraceSP &trace_sp) { m_trace_sp = trace_sp; }
 
-const TraceSP &Target::GetTrace() { return m_trace_sp; }
+TraceSP &Target::GetTrace() { return m_trace_sp; }
+
+llvm::Expected<TraceSP &> Target::GetTraceOrCreate() {
+  if (!m_trace_sp && m_process_sp) {
+    llvm::Expected<TraceSupportedResponse> trace_type =
+        m_process_sp->TraceSupported();
+    if (!trace_type)
+      return llvm::createStringError(
+          llvm::inconvertibleErrorCode(), "Tracing is not supported. %s",
+          llvm::toString(trace_type.takeError()).c_str());
+    if (llvm::Expected<TraceSP> trace_sp =
+            Trace::FindPluginForLiveProcess(trace_type->name, *m_process_sp))
+      m_trace_sp = *trace_sp;
+    else
+      return llvm::createStringError(
+          llvm::inconvertibleErrorCode(),
+          "Couldn't start tracing the process. %s",
+          llvm::toString(trace_type.takeError()).c_str());
+  }
+  return m_trace_sp;
+}
 
 Status Target::Attach(ProcessAttachInfo &attach_info, Stream *stream) {
   auto state = eStateInvalid;
   auto process_sp = GetProcessSP();
   if (process_sp) {
     state = process_sp->GetState();
     if (process_sp->IsAlive() && state != eStateConnected) {
       if (state == eStateAttaching)

lldb/source/Target/Thread.cpp

std::string Thread::StopReasonAsString(lldb::StopReason reason) {
   case eStopReasonExec:
     return "exec";
   case eStopReasonPlanComplete:
     return "plan complete";
   case eStopReasonThreadExiting:
     return "thread exiting";
   case eStopReasonInstrumentation:
     return "instrumentation break";
+  case eStopReasonProcessorTrace:
+    return "processor trace";
   }
 
   return "StopReason = " + std::to_string(reason);
 }
 
 std::string Thread::RunModeAsString(lldb::RunMode mode) {
   switch (mode) {
   case eOnlyThisThread:

lldb/source/Target/ThreadPostMortemTrace.cpp

-//===-- ThreadTrace.cpp ---------------------------------------------------===//
+//===-- ThreadPostMortemTrace.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 "lldb/Target/ThreadTrace.h"
+#include "lldb/Target/ThreadPostMortemTrace.h"
 
 #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;
 
-void ThreadTrace::RefreshStateAfterStop() {}
+void ThreadPostMortemTrace::RefreshStateAfterStop() {}
 
-RegisterContextSP ThreadTrace::GetRegisterContext() {
+RegisterContextSP ThreadPostMortemTrace::GetRegisterContext() {
   if (!m_reg_context_sp)
     m_reg_context_sp = CreateRegisterContextForFrame(nullptr);
 
   return m_reg_context_sp;
 }
 
 RegisterContextSP
-ThreadTrace::CreateRegisterContextForFrame(StackFrame *frame) {
+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 ThreadTrace::CalculateStopInfo() { return false; }
+bool ThreadPostMortemTrace::CalculateStopInfo() { return false; }
 
-const FileSpec &ThreadTrace::GetTraceFile() const { return m_trace_file; }
+const FileSpec &ThreadPostMortemTrace::GetTraceFile() const {
+  return m_trace_file;
+}

lldb/source/Target/Trace.cpp

 #include "llvm/Support/Format.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Target/ThreadPostMortemTrace.h"
 #include "lldb/Utility/Stream.h"
 
 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.

 
 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::FindPlugin(Debugger &debugger,
-                                          const json::Value &trace_session_file,
-                                          StringRef session_file_dir) {
+Expected<lldb::TraceSP>
+Trace::FindPluginForPostMortemProcess(Debugger &debugger,
   JSONSimpleTraceSession json_session;
   json::Path::Root root("traceSession");
   if (!json::fromJSON(trace_session_file, json_session, root))
     return root.getError();
 
   ConstString plugin_name(json_session.trace.type);
   if (auto create_callback = PluginManager::GetTraceCreateCallback(plugin_name))
     return create_callback(trace_session_file, session_file_dir, debugger);
 
   return createInvalidPlugInError(json_session.trace.type);
 }
 
+Expected<lldb::TraceSP>
+Trace::FindPluginForLiveProcess(llvm::StringRef plugin_name, Process &process) {
+  if (!process.IsLiveDebugSession())
+    return createStringError(inconvertibleErrorCode(),
+                             "Can't trace non-live processes");
+
+  ConstString name(plugin_name);
+  if (auto create_callback =
+          PluginManager::GetTraceCreateCallbackForLiveProcess(name))
+    return create_callback(process);
+
+  return createInvalidPlugInError(plugin_name);
+}
+
 Expected<StringRef> Trace::FindPluginSchema(StringRef name) {
   ConstString plugin_name(name);
   StringRef schema = PluginManager::GetTraceSchema(plugin_name);
   if (!schema.empty())
     return schema;
 
   return createInvalidPlugInError(name);
 }
DisassemblerSP disassembler = Disassembler::DisassembleRange(
       /*flavor*/ nullptr, target, range, /*prefer_file_cache*/ true);
   if (TryDumpInstructionInfo(s, disassembler, exe_ctx, address))
     return disassembler;
   return nullptr;
 }
 
 void Trace::DumpTraceInstructions(Thread &thread, Stream &s, size_t count,
                                   size_t end_position, bool raw) {
+  if (!IsTraced(thread)) {
+    s.Printf("thread #%u: tid = %" PRIu64 ", not traced\n", thread.GetIndexID(),
+             thread.GetID());
+    return;
+  }
+
   size_t instructions_count = GetInstructionCount(thread);
   s.Printf("thread #%u: tid = %" PRIu64 ", total instructions = %zu\n",
            thread.GetIndexID(), thread.GetID(), instructions_count);
 
   if (count == 0 || end_position >= instructions_count)
     return;
 
   size_t start_position =
TraverseInstructions(
             sc = SymbolContext();
         }
 
         s.Printf("\n");
 
         return index < end_position;
       });
 }
+
+Error Trace::Start(const llvm::json::Value &request) {
+  if (!m_live_process)
+    return createStringError(inconvertibleErrorCode(),
+                             "Tracing requires a live process.");
+  return m_live_process->TraceStart(request);
+}
+
+Error Trace::StopProcess() {
+  if (!m_live_process)
+    return createStringError(inconvertibleErrorCode(),
+                             "Tracing requires a live process.");
+  return m_live_process->TraceStop(
+      TraceStopRequest(GetPluginName().AsCString()));
+}
+
+Error Trace::StopThreads(const std::vector<lldb::tid_t> &tids) {
+  if (!m_live_process)
+    return createStringError(inconvertibleErrorCode(),
+                             "Tracing requires a live process.");
+  return m_live_process->TraceStop(
+      TraceStopRequest(GetPluginName().AsCString(), tids));
+}
+
+Expected<std::string> Trace::GetLiveProcessState() {
+  if (!m_live_process)
+    return createStringError(inconvertibleErrorCode(),
+                             "Tracing requires a live process.");
+  return m_live_process->TraceGetState(GetPluginName().AsCString());
+}
+
+Optional<size_t> Trace::GetLiveThreadBinaryDataSize(lldb::tid_t tid,
+                                                    llvm::StringRef kind) {
+  auto it = m_live_thread_data.find(tid);
+  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::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().AsCString(), kind.str(),
+                                    static_cast<int64_t>(tid), 0,
+                                    static_cast<int64_t>(*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().AsCString(), kind.str(),
+                                    None, 0, static_cast<int64_t>(*size)};
+  return m_live_process->TraceGetBinaryData(request);
+}
+
+void Trace::RefreshLiveProcessState() {
+  if (!m_live_process)
+    return;
+
+  uint32_t new_stop_id = m_live_process->GetStopID();
+  if (new_stop_id == m_stop_id)
+    return;
+
+  m_stop_id = new_stop_id;
+  m_live_thread_data.clear();
+
+  Expected<std::string> json_string = GetLiveProcessState();
+  if (!json_string) {
+    DoRefreshLiveProcessState(json_string.takeError());
+    return;
+  }
+  Expected<TraceGetStateResponse> live_process_state =
+      json::parse<TraceGetStateResponse>(*json_string, "TraceGetStateResponse");
+  if (!live_process_state) {
+    DoRefreshLiveProcessState(live_process_state.takeError());
+    return;
+  }
+
+  for (const TraceThreadState &thread_state :
+       live_process_state->tracedThreads) {
+    for (const TraceBinaryData &item : thread_state.binaryData)
+      m_live_thread_data[thread_state.tid][item.kind] = item.size;
+  }
+
+  for (const TraceBinaryData &item : live_process_state->processBinaryData)
+    m_live_process_data[item.kind] = item.size;
+
+  DoRefreshLiveProcessState(std::move(live_process_state));
+}

lldb/source/Target/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 "lldb/Target/TraceSessionFileParser.h"
 
 #include <sstream>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Target/ThreadTrace.h"
+#include "lldb/Target/ThreadPostMortemTrace.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);
std::string TraceSessionFileParser::BuildSchema(StringRef plugin_schema) {
   ]
   // Notes:
   // All paths are either absolute or relative to the session file.
 }
 )";
   return schema_builder.str();
 }
 
-ThreadTraceSP TraceSessionFileParser::ParseThread(ProcessSP &process_sp,
-                                                  const JSONThread &thread) {
+ThreadPostMortemTraceSP
+TraceSessionFileParser::ParseThread(ProcessSP &process_sp,
   lldb::tid_t tid = static_cast<lldb::tid_t>(thread.tid);
 
   FileSpec trace_file(thread.trace_file);
   NormalizePath(trace_file);
 
-  ThreadTraceSP thread_sp =
-      std::make_shared<ThreadTrace>(*process_sp, tid, 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(

lldb/source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility
   StreamString.cpp
   StringExtractor.cpp
   StringExtractorGDBRemote.cpp
   StringLexer.cpp
   StringList.cpp
   StructuredData.cpp
   TildeExpressionResolver.cpp
   Timer.cpp
-  TraceOptions.cpp
+  TraceGDBRemotePackets.cpp
+  TraceIntelPTGDBRemotePackets.cpp
   UnimplementedError.cpp
   UUID.cpp
   UriParser.cpp
   UserID.cpp
   UserIDResolver.cpp
   VASprintf.cpp
   VMRange.cpp
   XcodeSDK.cpp

lldb/source/Utility/StringExtractorGDBRemote.cpp

#define PACKET_STARTS_WITH(s)                                                  \
 
   case 'j':
     if (PACKET_STARTS_WITH("jModulesInfo:"))
       return eServerPacketType_jModulesInfo;
     if (PACKET_MATCHES("jSignalsInfo"))
       return eServerPacketType_jSignalsInfo;
     if (PACKET_MATCHES("jThreadsInfo"))
       return eServerPacketType_jThreadsInfo;
-    if (PACKET_STARTS_WITH("jTraceBufferRead:"))
-      return eServerPacketType_jTraceBufferRead;
-    if (PACKET_STARTS_WITH("jTraceConfigRead:"))
-      return eServerPacketType_jTraceConfigRead;
-    if (PACKET_STARTS_WITH("jTraceMetaRead:"))
-      return eServerPacketType_jTraceMetaRead;
-    if (PACKET_STARTS_WITH("jTraceStart:"))
-      return eServerPacketType_jTraceStart;
-    if (PACKET_STARTS_WITH("jTraceStop:"))
-      return eServerPacketType_jTraceStop;
-    if (PACKET_MATCHES("jLLDBTraceSupportedType"))
-      return eServerPacketType_jLLDBTraceSupportedType;
+
+    if (PACKET_MATCHES("jLLDBTraceSupported"))
+      return eServerPacketType_jLLDBTraceSupported;
+    if (PACKET_STARTS_WITH("jLLDBTraceStop:"))
+      return eServerPacketType_jLLDBTraceStop;
+    if (PACKET_STARTS_WITH("jLLDBTraceStart:"))
+      return eServerPacketType_jLLDBTraceStart;
+    if (PACKET_STARTS_WITH("jLLDBTraceGetState:"))
+      return eServerPacketType_jLLDBTraceGetState;
+    if (PACKET_STARTS_WITH("jLLDBTraceGetBinaryData:"))
+      return eServerPacketType_jLLDBTraceGetBinaryData;
     break;
 
   case 'v':
     if (PACKET_STARTS_WITH("vFile:")) {
       if (PACKET_STARTS_WITH("vFile:open:"))
         return eServerPacketType_vFile_open;
       else if (PACKET_STARTS_WITH("vFile:close:"))
         return eServerPacketType_vFile_close;

lldb/source/Utility/TraceGDBRemotePackets.cpp

+//===-- TraceGDBRemotePackets.cpp -------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/TraceGDBRemotePackets.h"
+
+using namespace llvm;
+using namespace llvm::json;
+
+namespace lldb_private {
+/// jLLDBTraceSupported
+/// \{
+bool fromJSON(const json::Value &value, TraceSupportedResponse &packet,
+              Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("description", packet.description) &&
+         o.map("name", packet.name);
+}
+
+json::Value toJSON(const TraceSupportedResponse &packet) {
+  return json::Value(
+      Object{{"description", packet.description}, {"name", packet.name}});
+}
+/// \}
+
+/// jLLDBTraceStart
+/// \{
+bool TraceStartRequest::IsProcessTracing() const { return !(bool)tids; }
+
+bool fromJSON(const json::Value &value, TraceStartRequest &packet, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("type", packet.type) && o.map("tids", packet.tids);
+}
+
+json::Value toJSON(const TraceStartRequest &packet) {
+  return json::Value(Object{{"tids", packet.tids}, {"type", packet.type}});
+}
+/// \}
+
+/// jLLDBTraceStop
+/// \{
+TraceStopRequest::TraceStopRequest(llvm::StringRef type,
+                                   const std::vector<lldb::tid_t> &tids_)
+    : type(type) {
+  tids.emplace();
+  for (lldb::tid_t tid : tids_)
+    tids->push_back(static_cast<int64_t>(tid));
+}
+
+bool TraceStopRequest::IsProcessTracing() const { return !(bool)tids; }
+
+bool fromJSON(const json::Value &value, TraceStopRequest &packet, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("type", packet.type) && o.map("tids", packet.tids);
+}
+
+json::Value toJSON(const TraceStopRequest &packet) {
+  return json::Value(Object{{"type", packet.type}, {"tids", packet.tids}});
+}
+/// \}
+
+/// jLLDBTraceGetState
+/// \{
+bool fromJSON(const json::Value &value, TraceGetStateRequest &packet,
+              Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("type", packet.type);
+}
+
+json::Value toJSON(const TraceGetStateRequest &packet) {
+  return json::Value(Object{{"type", packet.type}});
+}
+
+bool fromJSON(const json::Value &value, TraceBinaryData &packet, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("kind", packet.kind) && o.map("size", packet.size);
+}
+
+json::Value toJSON(const TraceBinaryData &packet) {
+  return json::Value(Object{{"kind", packet.kind}, {"size", packet.size}});
+}
+
+bool fromJSON(const json::Value &value, TraceThreadState &packet, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("tid", packet.tid) &&
+         o.map("binaryData", packet.binaryData);
+}
+
+json::Value toJSON(const TraceThreadState &packet) {
+  return json::Value(
+      Object{{"tid", packet.tid}, {"binaryData", packet.binaryData}});
+}
+
+bool fromJSON(const json::Value &value, TraceGetStateResponse &packet,
+              Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("tracedThreads", packet.tracedThreads) &&
+         o.map("processBinaryData", packet.processBinaryData);
+}
+
+json::Value toJSON(const TraceGetStateResponse &packet) {
+  return json::Value(Object{{"tracedThreads", packet.tracedThreads},
+                            {"processBinaryData", packet.processBinaryData}});
+}
+/// \}
+
+/// jLLDBTraceGetBinaryData
+/// \{
+json::Value toJSON(const TraceGetBinaryDataRequest &packet) {
+  return json::Value(Object{{"type", packet.type},
+                            {"kind", packet.kind},
+                            {"offset", packet.offset},
+                            {"tid", packet.tid},
+                            {"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);
+}
+/// \}
+
+} // namespace lldb_private

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

+//===-- TraceIntelPTGDBRemotePackets.cpp ------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
+
+using namespace llvm;
+using namespace llvm::json;
+
+namespace lldb_private {
+
+bool fromJSON(const json::Value &value, TraceIntelPTStartRequest &packet,
+              Path path) {
+  ObjectMapper o(value, path);
+  if (!o || !fromJSON(value, (TraceStartRequest &)packet, path) ||
+      !o.map("threadBufferSize", packet.threadBufferSize) ||
+      !o.map("processBufferSizeLimit", packet.processBufferSizeLimit))
+    return false;
+  if (packet.tids && packet.processBufferSizeLimit) {
+    path.report("processBufferSizeLimit must be provided");
+    return false;
+  }
+  if (!packet.tids && !packet.processBufferSizeLimit) {
+    path.report("processBufferSizeLimit must not be provided");
+    return false;
+  }
+  return true;
+}
+
+json::Value toJSON(const TraceIntelPTStartRequest &packet) {
+  json::Value base = toJSON((const TraceStartRequest &)packet);
+  base.getAsObject()->try_emplace("threadBufferSize", packet.threadBufferSize);
+  base.getAsObject()->try_emplace("processBufferSizeLimit",
+                                  packet.processBufferSizeLimit);
+  return base;
+}
+
+} // namespace lldb_private

lldb/source/Utility/TraceOptions.cpp

-//===-- TraceOptions.cpp ----------------------------------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Utility/TraceOptions.h"
-
-using namespace lldb_private;
-
-namespace llvm {
-namespace json {
-
-bool fromJSON(const Value &value, TraceTypeInfo &info, Path path) {
-  ObjectMapper o(value, path);
-  if (!o)
-    return false;
-  o.map("description", info.description);
-  return o.map("name", info.name);
-}
-
-} // namespace json
-} // namespace llvm

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

Context:
   ],
   "trace": { ... }
 }
 
 Schema:
 {
   "trace": {
     "type": "intel-pt",
-    "pt_cpu": {
+    "cpuInfo": {
       "vendor": "intel" | "unknown",
       "family": integer,
       "model": integer,
       "stepping": integer
     }
   },'''])
 
         # 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.pt_cpu.family
+            substrs=['''error: missing value at traceSession.trace.cpuInfo.family
 
 Context:
 {
   "processes": [],
   "trace": {
-    "pt_cpu": /* error: missing value */ {
+    "cpuInfo": /* error: missing value */ {
       "model": 79,
       "stepping": 1,
       "vendor": "intel"
     },
     "type": "intel-pt"
   }
 }''', "Schema"])
 

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

class TestTraceLoad(TestBase):
     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",
-    "pt_cpu": {
+    "cpuInfo": {
       "vendor": "intel" | "unknown",
       "family": integer,
       "model": integer,
       "stepping": integer
     }
   },'''])

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

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 from lldbsuite.test.decorators import *
 
-class TestTraceLoad(TestBase):
+ADDRESS_REGEX = '0x[0-9a-fA-F]*'
+
+class TestTraceStartStop(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         TestBase.setUp(self)
         if 'intel-pt' not in configuration.enabled_plugins:
             self.skipTest("The intel-pt test plugin is not enabled")
 
     def expectGenericHelpMessageForStartCommand(self):
         self.expect("help thread trace start",
             substrs=["Syntax: thread trace start [<trace-options>]"])
 
     def testStartStopSessionFileThreads(self):
         # it should fail for processes from json session files
         self.expect("trace load -v " + os.path.join(self.getSourceDir(), "intelpt-trace", "trace.json"))
         self.expect("thread trace start", error=True,
-            substrs=["error: Tracing is not supported. Can't trace a non-live process"])
+            substrs=["error: Process must be alive"])
 
         # the help command should be the generic one, as it's not a live process
         self.expectGenericHelpMessageForStartCommand()
 
-        # this should fail because 'trace stop' is not yet implemented
-        self.expect("thread trace stop", error=True,
-            substrs=["error: Failed stopping thread 3842849"])
+        self.expect("thread trace stop", error=True)
+
+    def testStartWithNoProcess(self):
+        self.expect("thread trace start", error=True, 
+            substrs=["error: Process not available."])
+
+
+    def testStartSessionWithWrongSize(self):
+        self.expect("file " + os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
+        self.expect("b main")
+        self.expect("r")
+        self.expect("thread trace start -s 2000", error=True, 
+            substrs=["The trace buffer size must be a power of 2", "It was 2000"])
+        self.expect("thread trace start -s 5000", error=True,
+            substrs=["The trace buffer size must be a power of 2", "It was 5000"])
+        self.expect("thread trace start -s 0", error=True,
+            substrs=["The trace buffer size must be a power of 2", "It was 0"])
+        self.expect("thread trace start -s 1048576")
+        
 
     @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
     def testStartStopLiveThreads(self):
         # The help command should be the generic one if there's no process running
         self.expectGenericHelpMessageForStartCommand()
 
         self.expect("thread trace start", error=True,
             substrs=["error: Process not available"])
 
         self.expect("file " + os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
         self.expect("b main")
 
         self.expect("thread trace start", error=True,
             substrs=["error: Process not available"])
 
         # The help command should be the generic one if there's still no process running
         self.expectGenericHelpMessageForStartCommand()
 
         self.expect("r")
 
+        # This fails because "trace start" hasn't been called yet
+        self.expect("thread trace stop", error=True,
+            substrs=["error: Process is not being traced"])
+
+
         # the help command should be the intel-pt one now
         self.expect("help thread trace start",
             substrs=["Start tracing one or more threads with intel-pt.",
                      "Syntax: thread trace start [<thread-index> <thread-index> ...] [<intel-pt-options>]"])
 
-        self.expect("thread trace start",
-            patterns=["would trace tid .* with size_in_kb 4 and custom_config 0"])
+        # We start tracing with a small buffer size
+        self.expect("thread trace start 1 --size 4096")
         
-        self.expect("thread trace start --size 20 --custom-config 1",
-            patterns=["would trace tid .* with size_in_kb 20 and custom_config 1"])
+        # We fail if we try to trace again
+        self.expect("thread trace start", error=True, 
+            substrs=["error: Thread ", "already traced"])
 
-        # This fails because "trace stop" is not yet implemented.
+        # We can reconstruct the single instruction executed in the first line
+        self.expect("n")
+        self.expect("thread trace dump instructions", 
+            patterns=[f'''thread #1: tid = .*, total instructions = 1
+  a.out`main \+ 4 at main.cpp:2
+    \[0\] {ADDRESS_REGEX}    movl'''])
+
+        # We can reconstruct the instructions up to the second line
+        self.expect("n")
+        self.expect("thread trace dump instructions", 
+            patterns=[f'''thread #1: tid = .*, total instructions = 5
+  a.out`main \+ 4 at main.cpp:2
+    \[0\] {ADDRESS_REGEX}    movl .*
+  a.out`main \+ 11 at main.cpp:4
+    \[1\] {ADDRESS_REGEX}    movl .*
+    \[2\] {ADDRESS_REGEX}    jmp  .* ; <\+28> at main.cpp:4
+  a.out`main \+ 28 at main.cpp:4
+    \[3\] {ADDRESS_REGEX}    cmpl .*
+    \[4\] {ADDRESS_REGEX}    jle  .* ; <\+20> at main.cpp:5'''])
+
+        # We stop tracing
+        self.expect("thread trace stop")
+
+        # We can't stop twice
         self.expect("thread trace stop", error=True,
-            substrs=["error: Process is not being traced"])
+            substrs=["error: Thread ", "not currently traced"])
+
+        # We trace again from scratch, this time letting LLDB to pick the current
+        # thread
+        self.expect("thread trace start")
+        self.expect("n")
+        self.expect("thread trace dump instructions", 
+            patterns=[f'''thread #1: tid = .*, total instructions = 1
+  a.out`main \+ 20 at main.cpp:5
+    \[0\] {ADDRESS_REGEX}    xorl'''])
 
         self.expect("c")
         # Now the process has finished, so the commands should fail
         self.expect("thread trace start", error=True,
             substrs=["error: Process must be launched"])
 
         self.expect("thread trace stop", error=True,
             substrs=["error: Process must be launched"])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 {
   "trace": {
     "type": "intel-pt",
-    "pt_cpu": {
+    "cpuInfo": {
       "vendor": "intel",
       "family": 2123123,
       "model": 12123123,
       "stepping": 1231231
     }
   },
   "processes": [
     {

lldb/test/API/commands/trace/multiple-threads/Makefile

+CXX_SOURCES := main.cpp
+ENABLE_THREADS = YES
+
+include Makefile.rules

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

+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+from lldbsuite.test.decorators import *
+
+ADDRESS_REGEX = '0x[0-9a-fA-F]*'
+
+class TestTraceStartStopMultipleThreads(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def setUp(self):
+        TestBase.setUp(self)
+        if 'intel-pt' not in configuration.enabled_plugins:
+            self.skipTest("The intel-pt test plugin is not enabled")
+
+    @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
+    def testStartMultipleLiveThreads(self):
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        self.expect("b main")
+        self.expect("b 6")
+        self.expect("b 11")
+
+        self.expect("r")
+        self.expect("proce trace start")
+
+
+        # We'll see here the first thread
+        self.expect("continue")
+        self.expect("thread trace dump instructions", substrs=['main.cpp:9'])
+        
+        # We'll see here the second thread
+        self.expect("continue")
+        self.expect("thread trace dump instructions", substrs=['main.cpp:4'])
+
+    @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
+    def testStartMultipleLiveThreadsWithStops(self):
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        self.expect("b main")
+        self.expect("b 6")
+        self.expect("b 11")
+
+        self.expect("r")
+        self.expect("process trace start")
+
+
+        # We'll see here the first thread
+        self.expect("continue")
+
+        # We are in thread 2
+        self.expect("thread trace dump instructions", substrs=['main.cpp:9'])
+        self.expect("thread trace dump instructions 2", substrs=['main.cpp:9'])
+
+        # We stop tracing it
+        self.expect("thread trace stop 2")
+
+        # The trace is still in memory
+        self.expect("thread trace dump instructions 2", substrs=['main.cpp:9'])
+        
+        # We'll stop at the next breakpoint, thread 2 will be still alive, but not traced. Thread 3 will be traced
+        self.expect("continue")
+        self.expect("thread trace dump instructions", substrs=['main.cpp:4'])
+        self.expect("thread trace dump instructions 3", substrs=['main.cpp:4'])
+
+        self.expect("thread trace dump instructions 2", substrs=['not traced'])
+
+    @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
+    def testStartMultipleLiveThreadsWithStops(self):
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        self.expect("b main")
+        self.expect("b 6")
+        self.expect("b 11")
+
+        self.expect("r")
+        self.expect("process trace start")
+
+        # We'll see here the first thread
+        self.expect("continue")
+
+        # We are in thread 2
+        self.expect("thread trace dump instructions", substrs=['main.cpp:9'])
+        self.expect("thread trace dump instructions 2", substrs=['main.cpp:9'])
+
+        # We stop tracing all
+        self.expect("thread trace stop all")
+
+        # The trace is still in memory
+        self.expect("thread trace dump instructions 2", substrs=['main.cpp:9'])
+        
+        # We'll stop at the next breakpoint in thread 3, thread 2 and 3 will be alive, but only 3 traced.
+        self.expect("continue")
+        self.expect("thread trace dump instructions", substrs=['main.cpp:4'])
+        self.expect("thread trace dump instructions 3", substrs=['main.cpp:4'])
+        self.expect("thread trace dump instructions 1", substrs=['not traced'])
+        self.expect("thread trace dump instructions 2", substrs=['not traced'])
+
+    @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
+    def testStartMultipleLiveThreadsWithThreadStartAll(self):
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        self.expect("b main")
+        self.expect("b 6")
+        self.expect("b 11")
+
+        self.expect("r")
+
+        self.expect("continue")
+        # We are in thread 2
+        self.expect("thread trace start all")
+        # Now we have instructions in thread's 2 trace
+        self.expect("n")
+
+        self.expect("thread trace dump instructions 2", substrs=['main.cpp:11'])
+
+        # We stop tracing all
+        self.runCmd("thread trace stop all")
+
+        # The trace is still in memory
+        self.expect("thread trace dump instructions 2", substrs=['main.cpp:11'])
+        
+        # We'll stop at the next breakpoint in thread 3, and nothing should be traced
+        self.expect("continue")
+        self.expect("thread trace dump instructions 3", substrs=['not traced'])
+        self.expect("thread trace dump instructions 1", substrs=['not traced'])
+        self.expect("thread trace dump instructions 2", substrs=['not traced'])
+
+    @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
+    def testStartMultipleLiveThreadsWithSmallTotalLimit(self):
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        self.expect("b main")
+        self.expect("r")
+        # trace the entire process with enough total size for 1 thread trace
+        self.expect("process trace start -l 5000")
+        # we get the stop event when trace 2 appears and can't be traced
+        self.expect("c", substrs=['Thread', "can't be traced"])
+        # we get the stop event when trace 3 appears and can't be traced
+        self.expect("c", substrs=['Thread', "can't be traced"])

lldb/test/API/commands/trace/multiple-threads/main.cpp

+#include <chrono>
+#include <thread>
+
+void f3() {
+  int m;
+  m = 2; // thread 3
+}
+
+void f2() {
+  int n;
+  n = 1; // thread 2
+  std::thread t3(f3);
+  t3.join();
+}
+
+int main() { // main
+  std::thread t2(f2);
+  t2.join();
+  return 0;
+}

lldb/tools/lldb-vscode/JSONUtils.cpp

if (exc_bp) {
                bp_id, bp_loc_id);
       EmplaceSafeString(body, "description", desc_str);
     }
   } break;
   case lldb::eStopReasonWatchpoint:
   case lldb::eStopReasonInstrumentation:
     body.try_emplace("reason", "breakpoint");
     break;
-  case lldb::eStopReasonSignal:
-    body.try_emplace("reason", "exception");
+  case lldb::eStopReasonProcessorTrace:
+    body.try_emplace("reason", "processor trace");
     break;
+  case lldb::eStopReasonSignal:
   case lldb::eStopReasonException:
     body.try_emplace("reason", "exception");
     break;
   case lldb::eStopReasonExec:
     body.try_emplace("reason", "entry");
     break;
   case lldb::eStopReasonThreadExiting:
   case lldb::eStopReasonInvalid:

lldb/tools/lldb-vscode/LLDBUtils.cpp

bool ThreadHasStopReason(lldb::SBThread &thread) {
   case lldb::eStopReasonTrace:
   case lldb::eStopReasonPlanComplete:
   case lldb::eStopReasonBreakpoint:
   case lldb::eStopReasonWatchpoint:
   case lldb::eStopReasonInstrumentation:
   case lldb::eStopReasonSignal:
   case lldb::eStopReasonException:
   case lldb::eStopReasonExec:
+  case lldb::eStopReasonProcessorTrace:
     return true;
   case lldb::eStopReasonThreadExiting:
   case lldb::eStopReasonInvalid:
   case lldb::eStopReasonNone:
     break;
   }
   return false;
 }

lldb/unittests/Process/Linux/CMakeLists.txt

-add_lldb_unittest(ProcessorTraceTests
-  ProcessorTraceTest.cpp
+add_lldb_unittest(TraceIntelPTTests
+  IntelPTManagerTests.cpp
 
   LINK_LIBS
     lldbPluginProcessLinux
   )
 
-target_include_directories(ProcessorTraceTests PRIVATE
+target_include_directories(TraceIntelPTTests PRIVATE
   ${LLDB_SOURCE_DIR}/source/Plugins/Process/Linux)

lldb/unittests/Process/Linux/IntelPTManagerTests.cpp

-//===-- ProcessorTraceMonitorTest.cpp -------------------------------------===//
+//===-- IntelPTManagerTests.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 "gtest/gtest.h"
 
-#include "ProcessorTrace.h"
+#include "IntelPTManager.h"
 #include "llvm/ADT/ArrayRef.h"
 
 
 using namespace lldb_private;
 using namespace process_linux;
 
 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::MutableArrayRef<uint8_t> src(reinterpret_cast<uint8_t *>(cyc_buf),
                                      cyc_buf_size);
-  ProcessorTraceMonitor::ReadCyclicBuffer(dst, src, cyc_start, offset);
+  IntelPTThreadTrace::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

lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

if (XMLDocument::XMLEnabled()) {
     // In case we have XML support, this will also do a "qXfer:memory-map".
     // Preceeded by a query for supported extensions. Pretend we don't support
     // that.
     HandlePacket(server, testing::StartsWith("qSupported:"), "");
   }
   EXPECT_FALSE(result.get().Success());
 }
 
-TEST_F(GDBRemoteCommunicationClientTest, SendTraceSupportedTypePacket) {
-  TraceTypeInfo trace_type;
+TEST_F(GDBRemoteCommunicationClientTest, SendTraceSupportedPacket) {
+  TraceSupportedResponse trace_type;
   std::string error_message;
   auto callback = [&] {
-    if (llvm::Expected<TraceTypeInfo> trace_type_or_err =
-            client.SendGetSupportedTraceType()) {
+    if (llvm::Expected<TraceSupportedResponse> trace_type_or_err =
+            client.SendTraceSupported()) {
       trace_type = *trace_type_or_err;
       error_message = "";
       return true;
     } else {
       trace_type = {};
       error_message = llvm::toString(trace_type_or_err.takeError());
       return false;
     }
   };
 
   // Success response
   {
     std::future<bool> result = std::async(std::launch::async, callback);
 
     HandlePacket(
-        server, "jLLDBTraceSupportedType",
+        server, "jLLDBTraceSupported",
         R"({"name":"intel-pt","description":"Intel Processor Trace"}])");
 
     EXPECT_TRUE(result.get());
     ASSERT_STREQ(trace_type.name.c_str(), "intel-pt");
     ASSERT_STREQ(trace_type.description.c_str(), "Intel Processor Trace");
   }
 
   // Error response - wrong json
   {
     std::future<bool> result = std::async(std::launch::async, callback);
 
-    HandlePacket(server, "jLLDBTraceSupportedType", R"({"type":"intel-pt"}])");
+    HandlePacket(server, "jLLDBTraceSupported", R"({"type":"intel-pt"}])");
 
     EXPECT_FALSE(result.get());
-    ASSERT_STREQ(error_message.c_str(), "missing value at (root).name");
+    ASSERT_STREQ(error_message.c_str(), "missing value at (root).description");
   }
 
   // Error response
   {
     std::future<bool> result = std::async(std::launch::async, callback);
 
-    HandlePacket(server, "jLLDBTraceSupportedType", "E23");
+    HandlePacket(server, "jLLDBTraceSupported", "E23");
 
     EXPECT_FALSE(result.get());
   }
 
   // Error response with error message
   {
     std::future<bool> result = std::async(std::launch::async, callback);
 
-    HandlePacket(server, "jLLDBTraceSupportedType",
+    HandlePacket(server, "jLLDBTraceSupported",
                  "E23;50726F63657373206E6F742072756E6E696E672E");
 
     EXPECT_FALSE(result.get());
     ASSERT_STREQ(error_message.c_str(), "Process not running.");
   }
 }
 
-TEST_F(GDBRemoteCommunicationClientTest, SendStartTracePacket) {
-  TraceOptions options;
-  Status error;
-
-  options.setType(lldb::TraceType::eTraceTypeProcessorTrace);
-  options.setMetaDataBufferSize(8192);
-  options.setTraceBufferSize(8192);
-  options.setThreadID(0x23);
-
-  StructuredData::DictionarySP custom_params =
-      std::make_shared<StructuredData::Dictionary>();
-  custom_params->AddStringItem("tracetech", "intel-pt");
-  custom_params->AddIntegerItem("psb", 0x01);
-
-  options.setTraceParams(custom_params);
-
-  std::future<lldb::user_id_t> result = std::async(std::launch::async, [&] {
-    return client.SendStartTracePacket(options, error);
-  });
-
-  // Since the line is exceeding 80 characters.
-  std::string expected_packet1 =
-      R"(jTraceStart:{"buffersize":8192,"metabuffersize":8192,"params":)";
-  std::string expected_packet2 =
-      R"({"psb":1,"tracetech":"intel-pt"},"threadid":35,"type":1})";
-  HandlePacket(server, (expected_packet1 + expected_packet2), "1");
-  ASSERT_TRUE(error.Success());
-  ASSERT_EQ(result.get(), 1u);
-
-  error.Clear();
-  result = std::async(std::launch::async, [&] {
-    return client.SendStartTracePacket(options, error);
-  });
-
-  HandlePacket(server, (expected_packet1 + expected_packet2), "E23");
-  ASSERT_EQ(result.get(), LLDB_INVALID_UID);
-  ASSERT_FALSE(error.Success());
-}
-
-TEST_F(GDBRemoteCommunicationClientTest, SendStopTracePacket) {
-  lldb::tid_t thread_id = 0x23;
-  lldb::user_id_t trace_id = 3;
-
-  std::future<Status> result = std::async(std::launch::async, [&] {
-    return client.SendStopTracePacket(trace_id, thread_id);
-  });
-
-  const char *expected_packet = R"(jTraceStop:{"threadid":35,"traceid":3})";
-  HandlePacket(server, expected_packet, "OK");
-  ASSERT_TRUE(result.get().Success());
-
-  result = std::async(std::launch::async, [&] {
-    return client.SendStopTracePacket(trace_id, thread_id);
-  });
-
-  HandlePacket(server, expected_packet, "E23");
-  ASSERT_FALSE(result.get().Success());
-}
-
-TEST_F(GDBRemoteCommunicationClientTest, SendGetDataPacket) {
-  lldb::tid_t thread_id = 0x23;
-  lldb::user_id_t trace_id = 3;
-
-  uint8_t buf[32] = {};
-  llvm::MutableArrayRef<uint8_t> buffer(buf, 32);
-  size_t offset = 0;
-
-  std::future<Status> result = std::async(std::launch::async, [&] {
-    return client.SendGetDataPacket(trace_id, thread_id, buffer, offset);
-  });
-
-  std::string expected_packet1 =
-      R"(jTraceBufferRead:{"buffersize":32,"offset":0,"threadid":35,)";
-  std::string expected_packet2 = R"("traceid":3})";
-  HandlePacket(server, expected_packet1+expected_packet2, "123456");
-  ASSERT_TRUE(result.get().Success());
-  ASSERT_EQ(buffer.size(), 3u);
-  ASSERT_EQ(buf[0], 0x12);
-  ASSERT_EQ(buf[1], 0x34);
-  ASSERT_EQ(buf[2], 0x56);
-
-  llvm::MutableArrayRef<uint8_t> buffer2(buf, 32);
-  result = std::async(std::launch::async, [&] {
-    return client.SendGetDataPacket(trace_id, thread_id, buffer2, offset);
-  });
-
-  HandlePacket(server, expected_packet1+expected_packet2, "E23");
-  ASSERT_FALSE(result.get().Success());
-  ASSERT_EQ(buffer2.size(), 0u);
-}
-
-TEST_F(GDBRemoteCommunicationClientTest, SendGetMetaDataPacket) {
-  lldb::tid_t thread_id = 0x23;
-  lldb::user_id_t trace_id = 3;
-
-  uint8_t buf[32] = {};
-  llvm::MutableArrayRef<uint8_t> buffer(buf, 32);
-  size_t offset = 0;
-
-  std::future<Status> result = std::async(std::launch::async, [&] {
-    return client.SendGetMetaDataPacket(trace_id, thread_id, buffer, offset);
-  });
-
-  std::string expected_packet1 =
-      R"(jTraceMetaRead:{"buffersize":32,"offset":0,"threadid":35,)";
-  std::string expected_packet2 = R"("traceid":3})";
-  HandlePacket(server, expected_packet1+expected_packet2, "123456");
-  ASSERT_TRUE(result.get().Success());
-  ASSERT_EQ(buffer.size(), 3u);
-  ASSERT_EQ(buf[0], 0x12);
-  ASSERT_EQ(buf[1], 0x34);
-  ASSERT_EQ(buf[2], 0x56);
-
-  llvm::MutableArrayRef<uint8_t> buffer2(buf, 32);
-  result = std::async(std::launch::async, [&] {
-    return client.SendGetMetaDataPacket(trace_id, thread_id, buffer2, offset);
-  });
-
-  HandlePacket(server, expected_packet1+expected_packet2, "E23");
-  ASSERT_FALSE(result.get().Success());
-  ASSERT_EQ(buffer2.size(), 0u);
-}
-
-TEST_F(GDBRemoteCommunicationClientTest, SendGetTraceConfigPacket) {
-  lldb::tid_t thread_id = 0x23;
-  lldb::user_id_t trace_id = 3;
-  TraceOptions options;
-  options.setThreadID(thread_id);
-
-  std::future<Status> result = std::async(std::launch::async, [&] {
-    return client.SendGetTraceConfigPacket(trace_id, options);
-  });
-
-  const char *expected_packet =
-      R"(jTraceConfigRead:{"threadid":35,"traceid":3})";
-  std::string response1 =
-      R"({"buffersize":8192,"params":{"psb":1,"tracetech":"intel-pt"})";
-  std::string response2 = R"(],"metabuffersize":8192,"threadid":35,"type":1}])";
-  HandlePacket(server, expected_packet, response1+response2);
-  ASSERT_TRUE(result.get().Success());
-  ASSERT_EQ(options.getTraceBufferSize(), 8192u);
-  ASSERT_EQ(options.getMetaDataBufferSize(), 8192u);
-  ASSERT_EQ(options.getType(), 1);
-
-  auto custom_params = options.getTraceParams();
-
-  uint64_t psb_value;
-  llvm::StringRef trace_tech_value;
-
-  ASSERT_TRUE(custom_params);
-  ASSERT_EQ(custom_params->GetType(), eStructuredDataTypeDictionary);
-  ASSERT_TRUE(custom_params->GetValueForKeyAsInteger("psb", psb_value));
-  ASSERT_EQ(psb_value, 1u);
-  ASSERT_TRUE(
-      custom_params->GetValueForKeyAsString("tracetech", trace_tech_value));
-  ASSERT_STREQ(trace_tech_value.data(), "intel-pt");
-
-  // Checking error response.
-  std::future<Status> result2 = std::async(std::launch::async, [&] {
-    return client.SendGetTraceConfigPacket(trace_id, options);
-  });
-
-  HandlePacket(server, expected_packet, "E23");
-  ASSERT_FALSE(result2.get().Success());
-
-  // Wrong JSON as response.
-  std::future<Status> result3 = std::async(std::launch::async, [&] {
-    return client.SendGetTraceConfigPacket(trace_id, options);
-  });
-
-  std::string incorrect_json1 =
-      R"("buffersize" : 8192,"params" : {"psb" : 1,"tracetech" : "intel-pt"})";
-  std::string incorrect_json2 =
-      R"(],"metabuffersize" : 8192,"threadid" : 35,"type" : 1}])";
-  HandlePacket(server, expected_packet, incorrect_json1+incorrect_json2);
-  ASSERT_FALSE(result3.get().Success());
-
-  // Wrong JSON as custom_params.
-  std::future<Status> result4 = std::async(std::launch::async, [&] {
-    return client.SendGetTraceConfigPacket(trace_id, options);
-  });
-
-  std::string incorrect_custom_params1 =
-      R"({"buffersize" : 8192,"params" : "psb" : 1,"tracetech" : "intel-pt"})";
-  std::string incorrect_custom_params2 =
-      R"(],"metabuffersize" : 8192,"threadid" : 35,"type" : 1}])";
-  HandlePacket(server, expected_packet, incorrect_custom_params1+
-      incorrect_custom_params2);
-  ASSERT_FALSE(result4.get().Success());
-}
-
 TEST_F(GDBRemoteCommunicationClientTest, GetQOffsets) {
   const auto &GetQOffsets = [&](llvm::StringRef response) {
     std::future<Optional<QOffsets>> result = std::async(
         std::launch::async, [&] { return client.GetQOffsets(); });
 
     HandlePacket(server, "qOffsets", response);
     return result.get();
   };