[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

276

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.

277

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.

307

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

308

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

323–332

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

2528

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

2544

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

228

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

278

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.

298–299

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

310

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.

311

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

340

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?

403

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

138

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

192

Why no const?

lldb/include/lldb/Utility/TraceOptions.h

124–139

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

171–174

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

202–215

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

lldb/include/lldb/lldb-enumerations.h

772–783

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

lldb/source/Commands/CommandObjectThread.cpp

2048–2049

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

1690

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

278

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.

310

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

403

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

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

1690

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

278

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.

310

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.

311

more description on this please?

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

1690

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?

441–442

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".

452

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?

530–531

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

664

"process trace"?

lldb/source/Target/Target.cpp

3060–3061 ↗

(On Diff #333498)

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 ↗

(On Diff #333498)

"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 ↗

(On Diff #334275)

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

 // jLLDBTraceSupportedType
 //
 // 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>
 //  }
 //
 //  If no tracing technology is supported for the inferior, or no process is
 //  running, then an error should be 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
 
 //----------------------------------------------------------------------
+// jLLDBTraceStart
+//
+// BRIEF
+//  Start tracing a process or its threads using a provided tracing technology.
+//  The input is specified as a JSON object. If tracing started succesfully, an
+//  OK response is returned, or an error otherwise.
+//
+// SCHEMA
+//  The schema for the input is
+//
+//   {
+//     "type": <tracing technology name, e.g. intel-pt, arm-coresight>,
+//     "tids": [<thread ids in decimal>],
+//     "variant": "specificThreads" | "currentAndFutureThreads" | "process",
+//     "params": {
+//       <JSON object with parameters specific to the selected tracing technology>
+//     }
+//   }
+//
+//  Notes:
+//   - "tids" is only used when "variant" is "specificThreads".
+//   - Tracing a thread for a second time will stop the first trace and start a
+//     new one. This is done to allow the user to easily change tracing params
+//     without requiring to stop it first.
+//
+// VARIANTS
+//
+//  If "variant" is "specificThreads", then "tids" is required and each
+//  specified thread will be traced using the same "params".
+//
+//  If "variant" is "currentAndFutureThreads", then all threads including future
+//  threads, will be individually traced using the same "params".
+//
+//  If "variant" is "process", then the process will be traced as a single
+//  trace instance instead of tracing each individual thread.
+//
+//  Note:
+//   Each trace technology can have different levels of support for each
+//   variant.
+//
+// INTEL-PT
+//
+//  The schema for the "params" field for the "intel-pt" tracing technology is
+//
+//  {
+//    "bufferSizeInKB": <trace buffer size in KB in decimal>
+//    "perfConfig": <custom low-level perf event intel-pt config in decimal>
+//  }
+//
+//  intel-pt only supports the variants "specificThreads" and
+//  "currentAndFutureThreads".
+//----------------------------------------------------------------------
+
+send packet: jLLDBTraceStart:{"type":<type>,"variant":<variant>,"tids",<tids>,"params":<params>}]
+read packet: OK/E<error code>;AAAAAAAAA
+
+//----------------------------------------------------------------------
+// jLLDBTraceStop
+//
+// BRIEF
+//  Stop tracing a process or its threads using a provided tracing technology.
+//  The input is specified as a JSON object similar to the jLLDBTraceStart input.
+//  If tracing was stopped succesfully, an OK response is returned, or an error
+//  otherwise.
+//
+//  Note:
+//   When stopping multiple threads, it will try to stop as many threads as
+//   many threads as possible and then returning an error in case of failures.
+//
+// SCHEMA
+//  The schema for the input is
+//
+//  {
+//    "type": <tracing technology name, e.g. intel-pt, arm-coresight>,
+//    "tids": [<thread ids in decimal>],
+//    "variant": "specificThreads" | "currentAndFutureThreads" | "process",
+//  }
+//
+//  Notes:
+//   - "tids" is only used when "variant" is "specificThreads".
+//   - Stopping threads with "specificThreads" won't stop tracing of future
+//     threads if "currentAndFutureThreads" is enabled.
+//   - "currentAndFutureThreads" effectively stops thread traces started with
+//     "specificThreads".
+//----------------------------------------------------------------------
+
+send packet: jLLDBTraceStop:{"type":<type>,"variant":<variant>,"tids",<tids>,"params":<params>}]
+read packet: OK/E<error code>;AAAAAAAAA
+
+//----------------------------------------------------------------------
+// jLLDBTraceGetState
+//
+// BRIEF
+//  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.
+//
+// SCHEMA
+//  The schema for the input is
+//
+//  {
+//    "type": <tracing technology name, e.g. intel-pt, arm-coresight>
+//  }
+//
+// INTEL-PT
+//
+//  The schema for the output is
+//
+//  {
+//    "threads": [
+//      "tid": <thread id in decimal>
+//      "bufferSizeInBytes": <decimal>
+//    ],
+//    "pt_cpu": {
+//      "vendor": "intel" | "unknown",
+//      "family": <decimal>,
+//      "model": <decimal>,
+//      "stepping": <decimal>
+//    }
+//  }
+//----------------------------------------------------------------------
+
+send packet: jLLDBTraceGetState:{"type":<type>}]
+read packet: {return object}/E<error code>;AAAAAAAAA
+
+//----------------------------------------------------------------------
+// jLLDBTraceGetBinaryData
+//
+// BRIEF
+//  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.
+//
+// SCHEMA
+//  The schema for the input is
+//
+//  {
+//    "type": <tracing technology name, e.g. intel-pt, arm-coresight>
+//    "label": <identifier for the data>
+//    "tid": <tid in decimal if the data is related to a thread, 0 otherwise>
+//    "offset": <offset of the data in decimal>
+//    "size": <number of bytes in decimal to read starting from the offset>
+//  }
+//
+// SUPPORTED DATA OBJECTS
+//
+//  - intel-pt "thread_trace_buffer": trace buffer for a given thread
+//----------------------------------------------------------------------
+
+send packet: jLLDBTraceGetBinaryData:{"type":<type>,"label":<query>,"tid":<tid>,"offset":<offset>,"size":<size>}]
+read packet: <binary data>/E<error code>;AAAAAAAAA
+
+//----------------------------------------------------------------------
 // jTraceStart:
 //
 // This packet is deprecated.
 //
 // 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.
 //
 //  Following is the list of parameters -
 //
 //  Key             Value (Integer)                         (O)Optional/
 //                  (except params which should be a        (M)Mandatory
 //                  JSON dictionary)
 //  ==========      ====================================================
 //
 //  type            The type of trace to start (see          M
 //                  lldb-enumerations for TraceType)
 //
 //  buffersize      The size of the buffer to allocate       M
 //                  for trace gathering.
 //
 //  threadid        The id of the thread to start tracing    O
 //                  on.
 //
 //  metabuffersize  The size of buffer to hold meta data     O
 //                  used for decoding the trace data.
 //
 //  params          Any parameters that are specific to      O
 //                  certain trace technologies should be
 //                  collectively specified as a JSON
 //                  dictionary
 //  ==========      ====================================================
 //
 //  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

 //
 //  offset          The offset to start reading the data    M
 //                  from.
 //
 //  buffersize      The size of the data intended to read.  M
 //
 //  threadid        The id of the thread to retrieve data   O
 //                  from.
 //  ==========      ====================================================
 //
 //  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.
 //----------------------------------------------------------------------
 
 send packet: jTraceBufferRead:{"traceid":<trace id>,"offset":<byteoffset>,"buffersize":<byte_count>}]
 read packet: <binary trace data>/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------

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, TraceGetStartCommand get_start_command);
+
+  static bool
+  UnregisterPlugin(TraceCreateInstanceForSessionFile create_callback);
 
-  static bool UnregisterPlugin(TraceCreateInstance create_callback);
+  static TraceCreateInstanceForSessionFile
+  GetTraceCreateCallback(ConstString plugin_name);
 
-  static TraceCreateInstance GetTraceCreateCallback(ConstString plugin_name);
+  static TraceCreateInstanceForLiveProcess
+  GetTraceCreateCallbackForLiveProcess(ConstString plugin_name);
 
   static lldb::CommandObjectSP
   GetTraceStartCommand(llvm::StringRef plugin_name,
                        CommandInterpreter &interpreter);
 
   /// Get the JSON schema for a trace session file corresponding to the given
   /// plugin.
   ///

lldb/include/lldb/Host/common/NativeProcessProtocol.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;
   };
 
+  /// Start tracing a process or its threads.
+  ///
+  /// \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.
+  ///
+  ///     This object should have a string entry called "type", which is the
+  ///     tracing technology name.
+  ///
+  /// \param[in] type
+  ///     Tracing technology type, as described in the \a json_params.
+  ///
+  /// \return
+  ///     \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());
+  }
+
+  /// Stop tracing a process or its threads.
+  ///
+  /// \param[in] params
+  ///     The information determining which threads or process to stop tracing.
+  ///
+  /// \return
+  ///     \a llvm::Error::success if stopping was successful, or an
+  ///     \a llvm::Error otherwise.
+  virtual llvm::Error TraceStop(const TraceStopPacket &params) {
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Unsupported tracing type '%s'",
+                                   params.type.data());
+  }
+
+  /// Get the current tracing state of the process and its threads.
+  ///
+  /// \param[in] type
+  ///     Tracing technology type to consider.
+  ///
+  /// \return
+  ///     A JSON object with custom data depending on the trace technology, or
+  ///     an \a llvm::Error in case of errors.
+  virtual llvm::Expected<llvm::json::Value>
+  TraceGetState(llvm::StringRef type) {
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Unsupported tracing type '%s'",
+                                   type.data());
+  }
+
+  /// Get binary data given a trace technology and a data identifier.
+  ///
+  /// \param[in] params
+  ///     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 TraceGetBinaryDataPacket &params) {
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        "Unsupported data type '%s' for the '%s' tracing technology",
+        params.label.c_str(), params.type.c_str());
+  }
+
+  /// \copydoc Process::GetSupportedTraceType()
+  virtual llvm::Expected<TraceTypeInfo> GetSupportedTraceType() {
+    return llvm::make_error<UnimplementedError>();
+  }
+
+  /// Deprecated
+  ///
   /// StartTracing API for starting a tracing instance with the
   /// TraceOptions on a specific thread or process.
   ///
   /// \param[in] config
   ///     The configuration to use when starting tracing.
   ///
   /// \param[out] error
   ///     Status indicates what went wrong.
   ///
   /// \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;
   }
 
+  /// Deprecated
+  ///
   /// 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.
   ///
   /// \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");
   }
 
+  /// Deprecated
+  ///
   /// 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
public:
   /// \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");
   }
 
+  /// Deprecated
+  ///
   /// 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");
   }
 
+  /// Deprecated
+  ///
   /// 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::GetSupportedTraceType()
-  virtual llvm::Expected<TraceTypeInfo> GetSupportedTraceType() {
-    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;
   };
 
   std::unordered_map<lldb::addr_t, SoftwareBreakpoint> m_software_breakpoints;

lldb/include/lldb/Target/Process.h

void PruneThreadPlans();
   ///  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();
 
+  /// 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 StartTracing(const llvm::json::Value &params) {
+    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> GetTracingState(llvm::StringRef type) {
+    return llvm::make_error<UnimplementedError>();
+  }
+
+  /// Stop tracing a live process or its threads.
+  ///
+  /// \param[in] process
+  ///     Process that will be affected.
+  ///
+  /// \param[in] params
+  ///     The information determining which threads or process to stop tracing.
+  ///
+  /// \return
+  ///     An \a llvm::Error if stopping tracing failed, or an \b
+  ///     llvm::Error::success() otherwise.
+  virtual llvm::Error StopTracing(const TraceStopPacket &params) {
+    return llvm::make_error<UnimplementedError>();
+  }
+
+  /// Get binary data given a trace technology and a data identifier.
+  ///
+  /// \param[in] params
+  ///     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 TraceGetBinaryDataPacket &params) {
+    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.
   ///

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 "llvm/Support/JSON.h"
 
 #include "lldb/Core/PluginInterface.h"
+#include "lldb/Target/Thread.h"
 #include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/TraceOptions.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.
 ///
public:
   ///
   /// \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,
              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> FindPlugin(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);
 
   /// \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;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_TRACE_H

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

enum ServerPacketType {
 
     eServerPacketType_jTraceStart,      // deprecated
     eServerPacketType_jTraceBufferRead, // deprecated
     eServerPacketType_jTraceMetaRead,   // deprecated
     eServerPacketType_jTraceStop,       // deprecated
     eServerPacketType_jTraceConfigRead, // deprecated
 
     eServerPacketType_jLLDBTraceSupportedType,
+    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/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;
 };
-}
+
+/// jLLDBTraceGetSupportedType gdb-remote packet structures
+/// \{
+/// 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;
+  /// An optional description for the technology.
+  std::string description;
+};
+/// \}
+
+/// jLLDBTraceStop gdb-remote packet structures
+/// \{
+struct TraceStopPacket {
+  std::string type;
+  lldb::TraceOperationVariant variant;
+  std::vector<lldb::tid_t> tids;
+};
+///}
+
+/// jLLDBTraceStart gdb-remote packet structures
+/// \{
+struct TraceStartBasePacket {
+  TraceStartBasePacket() {}
+
+  TraceStartBasePacket(llvm::StringRef type,
+                       lldb::TraceOperationVariant variant,
+                       const std::vector<lldb::tid_t> &tids)
+      : type(type), variant(variant), tids(tids) {}
+
+  std::string type;
+  lldb::TraceOperationVariant variant;
+  std::vector<lldb::tid_t> tids;
+};
+
+template <typename TParams> struct TraceStartPacket : TraceStartBasePacket {
+  TraceStartPacket() {}
+
+  TraceStartPacket(llvm::StringRef type, lldb::TraceOperationVariant variant,
+                   const std::vector<lldb::tid_t> &tids, const TParams &params)
+      : TraceStartBasePacket(type, variant, tids), params(params) {}
+
+  TParams params;
+};
+
+struct TraceIntelPTStartPacketParams {
+  size_t buffer_size_in_kb;
+  uint32_t perf_config;
+};
+
+using TraceIntelPTStartPacket = TraceStartPacket<TraceIntelPTStartPacketParams>;
+/// \}
+
+/// jLLDBTraceGetState gdb-remote packet structures
+/// \{
+struct TraceGetStatePacket {
+  std::string type;
+};
+
+struct TraceIntelPTThreadState {
+  lldb::tid_t tid;
+  size_t buffer_size_in_bytes;
+};
+
+struct TraceIntelPTCPUConfig {
+  uint16_t family;
+  uint8_t model;
+  uint8_t stepping;
+  std::string vendor;
+};
+
+struct TraceIntelPTState {
+  std::vector<TraceIntelPTThreadState> threads;
+  TraceIntelPTCPUConfig cpu_config;
+};
+/// \}
+
+/// jLLDBTraceGetBinaryData gdb-remote packet structures
+/// \{
+struct TraceGetBinaryDataPacket {
+  std::string type;
+  std::string label;
+  lldb::tid_t tid;
+  size_t offset;
+  size_t size;
+};
+/// \}
+
+} // namespace lldb_private
 
 namespace llvm {
 namespace json {
 
+/// jLLDBTraceStop
+/// \{
+bool fromJSON(const Value &value, lldb_private::TraceStopPacket &packet,
+              Path path);
+
+Value toJSON(const lldb_private::TraceStopPacket &packet);
+///}
+
+/// jLLDBTraceStart
+/// \{
+bool fromJSON(const Value &value, lldb_private::TraceStartBasePacket &packet,
+              Path path);
+
+bool fromJSON(const Value &value,
+              lldb_private::TraceIntelPTStartPacketParams &packet, Path path);
+
+Value toJSON(const lldb_private::TraceIntelPTStartPacketParams &packet);
+
+template <typename TParams>
+bool fromJSON(const Value &value,
+              lldb_private::TraceStartPacket<TParams> &packet, Path path) {
+  ObjectMapper o(value, path);
+  return o &&
+         fromJSON(value, (lldb_private::TraceStartBasePacket &)packet, path) &&
+         o.map("params", packet.params);
+}
+
+Value toJSON(const lldb_private::TraceStartBasePacket &packet);
+
+template <typename TParams>
+Value toJSON(const lldb_private::TraceStartPacket<TParams> &packet) {
+  Value base_json = toJSON((const lldb_private::TraceStartBasePacket &)packet);
+  base_json.getAsObject()->try_emplace("params", toJSON(packet.params));
+  return base_json;
+}
+/// \}
+
+/// jLLDBTraceGetState
+/// \{
+bool fromJSON(const Value &value, lldb_private::TraceGetStatePacket &packet,
+              Path path);
+
+Value toJSON(const lldb_private::TraceGetStatePacket &packet);
+
+bool fromJSON(const Value &value, lldb_private::TraceIntelPTThreadState &state,
+              Path path);
+
+Value toJSON(const lldb_private::TraceIntelPTThreadState &state);
+
+bool fromJSON(const Value &value,
+              lldb_private::TraceIntelPTCPUConfig &cpu_config, Path path);
+
+Value toJSON(const lldb_private::TraceIntelPTCPUConfig &cpu_config);
+
+bool fromJSON(const Value &value, lldb_private::TraceIntelPTState &state,
+              Path path);
+
+Value toJSON(const lldb_private::TraceIntelPTState &state);
+/// \}
+
+/// jLLDBTraceGetBinaryData
+/// \{
+bool fromJSON(const Value &value,
+              lldb_private::TraceGetBinaryDataPacket &packet, Path path);
+
+Value toJSON(const lldb_private::TraceGetBinaryDataPacket &packet);
+/// \}
+
+/// jLLDBTraceGetSupportedType
+/// \{
 bool fromJSON(const Value &value, lldb_private::TraceTypeInfo &info, Path path);
+/// \}
 
 } // namespace json
 } // namespace llvm
 
 #endif // LLDB_UTILITY_TRACEOPTIONS_H

lldb/include/lldb/lldb-enumerations.h

enum StopReason {
   eStopReasonBreakpoint,
   eStopReasonWatchpoint,
   eStopReasonSignal,
   eStopReasonException,
   eStopReasonExec, ///< Program was re-exec'ed
   eStopReasonPlanComplete,
   eStopReasonThreadExiting,
   eStopReasonInstrumentation
 };
 
 /// Command Return Status Types.
 enum ReturnStatus {
   eReturnStatusInvalid,
   eReturnStatusSuccessFinishNoResult,
   eReturnStatusSuccessFinishResult,
   eReturnStatusSuccessContinuingNoResult,
   eReturnStatusSuccessContinuingResult,
enum BasicType {
   eBasicTypeLongDoubleComplex,
   eBasicTypeObjCID,
   eBasicTypeObjCClass,
   eBasicTypeObjCSel,
   eBasicTypeNullPtr,
   eBasicTypeOther
 };
 
+enum TraceOperationVariant {
+  /// Operate on specific existing threads, each one as an independent trace
+  /// instance.
+  eTraceOperationVariantSpecificThreads = 0,
+  /// Operate on all existing threads along with future threads, each one as an
+  /// independent trace instance.
+  eTraceOperationVariantCurrentAndFutureThreads,
+  /// Operate on a whole process as a single trace instance, instead of handling
+  /// each thread independently.
+  eTraceOperationVariantProcess,
+};
+
 /// Deprecated
 enum TraceType {
   eTraceTypeNone = 0,
 
   /// Intel Processor Trace
   eTraceTypeProcessorTrace
 };
 

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 llvm::Expected<lldb::TraceSP> (*TraceCreateInstanceForLiveProcess)(
+    Process &process);
 typedef lldb::CommandObjectSP (*TraceGetStartCommand)(
     CommandInterpreter &interpreter);
 
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 
 #endif // LLDB_LLDB_PRIVATE_INTERFACES_H

lldb/source/Commands/CommandObjectThread.cpp

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 CommandObjectThreadTraceLifeCycle {
 public:
   CommandObjectTraceStop(CommandInterpreter &interpreter)
-      : CommandObjectIterateOverThreads(
+      : CommandObjectThreadTraceLifeCycle(
             interpreter, "thread trace stop",
             "Stop tracing threads. "
             "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 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 HandleTraceCommand(Args &command, CommandReturnObject &result,
+                          TraceOperationVariant &variant,
+                          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;
+    TraceStopPacket params{trace_sp->GetPluginName().GetStringRef().str(),
+                           variant, tids};
+
+    if (llvm::Error err = process_sp->StopTracing(params))
+      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 that should be extended to provide life-cycle operations on traces,
+/// such as start and stop.
+///
+/// The arguments of this class have the following format
+///
+///     command [all | thread index 1, thread index 2, ...] --other_args
+///
+/// where "all" refers to all existing and future threads, as tracing can
+/// operate that way. Thread indices work the same way as other thread commands.
+class CommandObjectThreadTraceLifeCycle : 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] variant
+  ///     The trace variant depending on whether "all" was passed or not.
+  ///
+  /// \param[in] tids
+  ///     The thread ids passed as arguments.
+  ///
+  /// \return
+  ///     A boolean result similar to the one expected from \a DoExecute.
+  virtual bool HandleTraceCommand(Args &command, CommandReturnObject &result,
+                                  lldb::TraceOperationVariant &variant,
+                                  const std::vector<lldb::tid_t> &tids) = 0;
+};
+
+class CommandObjecThreadTraceStart : public CommandObjectThreadTraceLifeCycle {
+public:
+  CommandObjecThreadTraceStart(llvm::StringRef trace_plugin_name,
+                               CommandInterpreter &interpreter,
+                               const char *name, const char *help,
+                               const char *syntax, uint32_t flags)
+      : CommandObjectThreadTraceLifeCycle(interpreter, name, help, syntax,
+                                          flags),
+        m_trace_plugin_name(trace_plugin_name) {}
+
+protected:
+  bool HandleTraceCommand(Args &command, CommandReturnObject &result,
+                          lldb::TraceOperationVariant &variant,
+                          const std::vector<lldb::tid_t> &tids);
+
+  /// Create a JSON params object readable by \a Process::StartTracing.
+  ///
+  /// \param[in] variant
+  ///     Trace start variant.
+  ///
+  /// \param[in] tids
+  ///     Threads to trace.
+  ///
+  /// \return
+  ///     The JSON params, or an \a llvm::Error in case of failures.
+  virtual llvm::Expected<llvm::json::Value>
+  CreateTraceStartParams(lldb::TraceOperationVariant variant,
+                         const std::vector<lldb::tid_t> &tids) = 0;
+
+  std::string m_trace_plugin_name;
+};
+
 } // 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 CommandObjectThreadTraceLifeCycle::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());
+
+  TraceOperationVariant variant = eTraceOperationVariantSpecificThreads;
+
+  if (num_args > 0 && ::strcmp(command.GetArgumentAtIndex(0), "all") == 0)
+    variant = eTraceOperationVariantCurrentAndFutureThreads;
+  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 HandleTraceCommand(command, result, variant, tids);
+}
+
+bool CommandObjecThreadTraceStart::HandleTraceCommand(
+    Args &command, CommandReturnObject &result, TraceOperationVariant &variant,
+    const std::vector<lldb::tid_t> &tids) {
+  ProcessSP process_sp = m_exe_ctx.GetProcessSP();
+  TraceSP trace_sp = process_sp->GetTarget().GetTrace();
+  /// We create a new Trace instance so that plug-ins can assume it exists.
+  if (!trace_sp) {
+    Expected<TraceSP> trace_or_err =
+        Trace::FindPlugin(m_trace_plugin_name, *process_sp);
+    if (!trace_or_err) {
+      result.SetStatus(eReturnStatusFailed);
+      result.AppendErrorWithFormat("couldn't start tracing the process. %s",
+                                   toString(trace_or_err.takeError()).c_str());
+      return false;
+    }
+    trace_sp = *trace_or_err;
+  }
+
+  if (Expected<json::Value> params = CreateTraceStartParams(variant, tids)) {
+    if (Error err = process_sp->StartTracing(*params))
+      result.SetError(toString(std::move(err)));
+    else
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+  } else {
+    result.SetError(toString(params.takeError()));
+  }
+
+  return result.Succeeded();
+}

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, TraceGetStartCommand get_start_command)
+      : PluginInstance<TraceCreateInstanceForSessionFile>(
+            name, std::move(description), create_callback_for_session_file),
+        schema(schema), get_start_command(get_start_command),
+        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, TraceGetStartCommand get_start_command) {
   return GetTracePluginInstances().RegisterPlugin(
-      name, description, create_callback, schema, get_start_command);
+      name, description, create_callback_for_session_file,
+      create_callback_for_live_process, schema, get_start_command);
 }
 
-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);
 }
 
+TraceCreateInstanceForLiveProcess
+PluginManager::GetTraceCreateCallbackForLiveProcess(ConstString plugin_name) {
+  for (const TraceInstance &instance : GetTracePluginInstances().GetInstances())
+    if (instance.name == plugin_name)
+      return instance.create_callback_for_live_process;
+  return nullptr;
+}
+
 llvm::StringRef PluginManager::GetTraceSchema(ConstString plugin_name) {
   for (const TraceInstance &instance : GetTracePluginInstances().GetInstances())
     if (instance.name == plugin_name)
       return instance.schema;
   return llvm::StringRef();
 }
 
 CommandObjectSP

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

public:
   NativeThreadLinux *GetThreadByID(lldb::tid_t id);
   NativeThreadLinux *GetCurrentThread();
 
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
   GetAuxvData() const override {
     return getProcFile(GetID(), "auxv");
   }
 
+  llvm::Error TraceStart(llvm::StringRef json_params,
+                         llvm::StringRef type) override;
+
+  /// Start tracing a thread with Intel PT.
+  ///
+  /// \param[in] tid
+  ///     The thread id to start tracing.
+  ///
+  /// \param[in] buffer_size_in_kb
+  ///     The size of the circular trace buffer. It is rounded up to the nearest
+  ///     power of 2.
+  ///
+  /// \param[in] perf_config
+  ///     Low level perf event config. See
+  ///     https://github.com/torvalds/linux/blob/master/tools/perf/Documentation/perf-intel-pt.txt
+  ///     for more information
+  ///
+  /// \return
+  ///     \a llvm::Error::success if the operation was successful, or an
+  ///     \a llvm::Error otherwise.
+  llvm::Error StartIntelPTTrace(lldb::tid_t tid, size_t buffer_size_in_kb,
+                                uint32_t perf_config);
+
+  /// Start tracing a process or its threads with Intel PT.
+  ///
+  /// \param[in] params
+  ///     The params that specify how to start tracing.
+  ///
+  /// \return
+  ///     \a llvm::Error::success if the operation was successful, or an
+  ///     \a llvm::Error otherwise.
+  llvm::Error StartIntelPTTrace(const TraceIntelPTStartPacket &params);
+
+  llvm::Error TraceStop(const TraceStopPacket &params) override;
+
+  /// Stop tracing a process or its threads traced with Intel PT.
+  ///
+  /// \param[in] params
+  ///     The params that specify what to stop tracing.
+  ///
+  /// \return
+  ///     \a llvm::Error::success if the operation was successful, or an
+  ///     \a llvm::Error otherwise.
+  llvm::Error StopIntelPTTrace(const TraceStopPacket &params);
+
+  llvm::Expected<llvm::json::Value>
+  TraceGetState(llvm::StringRef type) override;
+
+  llvm::Expected<llvm::json::Value> GetIntelPTTraceState();
+
+  llvm::Expected<std::vector<uint8_t>>
+  TraceGetBinaryData(const TraceGetBinaryDataPacket &params) override;
+
   lldb::user_id_t StartTrace(const TraceOptions &config,
                              Status &error) override;
 
   Status StopTrace(lldb::user_id_t traceid,
                    lldb::tid_t thread) override;
 
   Status GetData(lldb::user_id_t traceid, lldb::tid_t thread,
                  llvm::MutableArrayRef<uint8_t> &buffer,
private:
   Status SetupSoftwareSingleStepping(NativeThreadLinux &thread);
 
   bool HasThreadNoLock(lldb::tid_t thread_id);
 
   bool StopTrackingThread(lldb::tid_t thread_id);
 
   NativeThreadLinux &AddThread(lldb::tid_t thread_id);
 
+  /// Start tracing a new thread if possible.
+  ///
+  /// Trace mechanisms should modify this method to provide automatic tracing
+  /// for new threads.
+  void TryTraceNewThread(lldb::tid_t thread_id);
+
   /// 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 GetEventMessage(lldb::tid_t tid, unsigned long *message);
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;
+  /// Params to use when automatically tracing new threads with Intel PT.
+  /// When \a llvm::None, then no automatic tracing will be performed.
+  llvm::Optional<TraceIntelPTStartPacket> m_intel_pt_trace_new_threads_params =
+      llvm::None;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessLinux_H_

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

bool NativeProcessLinux::StopTrackingThread(lldb::tid_t thread_id) {
   }
 
   if (found)
     StopTracingForThread(thread_id);
   SignalIfAllThreadsStopped();
   return found;
 }
 
+void NativeProcessLinux::TryTraceNewThread(lldb::tid_t thread_id) {
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
+
+  if (m_intel_pt_trace_new_threads_params) {
+    if (Error err = StartIntelPTTrace(
+            thread_id,
+            m_intel_pt_trace_new_threads_params->params.buffer_size_in_kb,
+            m_intel_pt_trace_new_threads_params->params.perf_config)) {
+      LLDB_LOG(log, "failed to start intel pt trace on thread {0}", thread_id);
+      Status error(std::move(err));
+      LLDB_LOG(log, "error {0}", error);
+    }
+  }
+}
+
 NativeThreadLinux &NativeProcessLinux::AddThread(lldb::tid_t thread_id) {
   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));
-
-  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);
-    }
-  }
+  TryTraceNewThread(thread_id);
 
   return static_cast<NativeThreadLinux &>(*m_threads.back());
 }
 
 Status NativeProcessLinux::GetLoadedModuleFileSpec(const char *module_path,
                                                    FileSpec &file_spec) {
   Status error = PopulateMemoryRegionCache();
   if (error.Fail())
NativeProcessLinux::StartTraceGroup(const TraceOptions &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;
 }
 
+Error NativeProcessLinux::TraceStop(const TraceStopPacket &params) {
+  if (params.type == "intel-pt")
+    return StopIntelPTTrace(params);
+  return NativeProcessProtocol::TraceStop(params);
+}
+
+Error NativeProcessLinux::StopIntelPTTrace(const TraceStopPacket &params) {
+  switch (params.variant) {
+  case lldb::eTraceOperationVariantProcess:
+    return createStringError(
+        inconvertibleErrorCode(),
+        "whole process (non-thread) tracing is not supported");
+  case lldb::eTraceOperationVariantSpecificThreads: {
+    Error result = Error::success();
+    for (lldb::tid_t tid : params.tids) {
+      const auto &trace_instance = m_processor_trace_monitor.find(tid);
+      if (trace_instance == m_processor_trace_monitor.end())
+        result = joinErrors(
+            std::move(result),
+            createStringError(inconvertibleErrorCode(), "thread not traced"));
+      else
+        result = joinErrors(std::move(result),
+                            StopProcessorTracingOnThread(
+                                trace_instance->second->GetTraceID(), tid)
+                                .ToError());
+    }
+    return result;
+  }
+  case lldb::eTraceOperationVariantCurrentAndFutureThreads:
+    m_intel_pt_trace_new_threads_params = llvm::None;
+    m_processor_trace_monitor.clear();
+    return Error::success();
+  }
+}
+
+Error NativeProcessLinux::TraceStart(StringRef json_params, StringRef type) {
+  if (type == "intel-pt") {
+    if (Expected<TraceIntelPTStartPacket> params =
+            json::parse<TraceIntelPTStartPacket>(json_params))
+      return StartIntelPTTrace(*params);
+    else
+      return params.takeError();
+  }
+
+  return NativeProcessProtocol::TraceStart(json_params, type);
+}
+
+Error NativeProcessLinux::StartIntelPTTrace(
+    const TraceIntelPTStartPacket &params) {
+  switch (params.variant) {
+  case lldb::eTraceOperationVariantProcess:
+    return createStringError(
+        inconvertibleErrorCode(),
+        "whole process (non-thread) tracing is not supported");
+  case lldb::eTraceOperationVariantSpecificThreads: {
+    Error result = Error::success();
+    for (lldb::tid_t tid : params.tids) {
+      if (Error err = StartIntelPTTrace(tid, params.params.buffer_size_in_kb,
+                                        params.params.perf_config))
+        result = joinErrors(std::move(result), std::move(err));
+    }
+    return result;
+  }
+  case lldb::eTraceOperationVariantCurrentAndFutureThreads: {
+    m_intel_pt_trace_new_threads_params = params;
+    Error result = Error::success();
+    for (const auto &thread : m_threads) {
+      if (Error err = StartIntelPTTrace(thread->GetID(),
+                                        params.params.buffer_size_in_kb,
+                                        params.params.perf_config))
+        result = joinErrors(std::move(result), std::move(err));
+    }
+    return result;
+  }
+  }
+}
+
+Error NativeProcessLinux::StartIntelPTTrace(lldb::tid_t tid,
+                                            size_t buffer_size_in_kb,
+                                            uint32_t perf_config) {
+  if (!GetThreadByID(tid))
+    return createStringError(inconvertibleErrorCode(), "invalid thread id");
+
+  // We clear the previous trace if we are tracing the thread for a second time.
+  const auto &trace_instance = m_processor_trace_monitor.find(tid);
+  if (trace_instance != m_processor_trace_monitor.end())
+    m_processor_trace_monitor.erase(trace_instance);
+
+  Expected<ProcessorTraceMonitorUP> trace_monitor =
+      ProcessorTraceMonitor::Create(GetID(), tid, buffer_size_in_kb,
+                                    perf_config);
+  if (!trace_monitor)
+    return trace_monitor.takeError();
+
+  m_processor_trace_monitor.try_emplace(tid, std::move(*trace_monitor));
+  return Error::success();
+}
+
+Expected<json::Value> NativeProcessLinux::TraceGetState(StringRef type) {
+  if (type == "intel-pt")
+    return GetIntelPTTraceState();
+  return NativeProcessProtocol::TraceGetState(type);
+}
+
+Expected<json::Value> NativeProcessLinux::GetIntelPTTraceState() {
+  Expected<TraceIntelPTCPUConfig> cpu_config =
+      ProcessorTraceMonitor::GetIntelPTCPUConfig();
+  if (!cpu_config)
+    return cpu_config.takeError();
+
+  TraceIntelPTState state;
+  state.cpu_config = *cpu_config;
+
+  state.threads.reserve(m_processor_trace_monitor.size());
+  for (const auto &tid_monitor_pair : m_processor_trace_monitor) {
+    lldb::tid_t tid = tid_monitor_pair.first;
+    size_t size_in_bytes = tid_monitor_pair.second->GetTraceBufferSizeInBytes();
+    state.threads.push_back(TraceIntelPTThreadState{tid, size_in_bytes});
+  }
+  return json::toJSON(state);
+}
+
+Expected<std::vector<uint8_t>>
+NativeProcessLinux::TraceGetBinaryData(const TraceGetBinaryDataPacket &params) {
+  if (params.type == "intel-pt" && params.label == "thread_trace_buffer") {
+    const auto &trace_instance = m_processor_trace_monitor.find(params.tid);
+    if (trace_instance == m_processor_trace_monitor.end())
+      return createStringError(inconvertibleErrorCode(),
+                               "thread not currently traced");
+    return trace_instance->second->GetIntelPTBuffer(params.offset, params.size);
+  }
+  return NativeProcessProtocol::TraceGetBinaryData(params);
+}
+
 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();

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

class ProcessorTraceMonitor {
   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);
+  /// Start tracing a thread
+  ///
+  /// \param[in] pid
+  ///     The pid of the process whose thread will be traced.
+  ///
+  /// \param[in] tid
+  ///     The tid of the thread to trace.
+  ///
+  /// \param[in] buffer_size_in_kb
+  ///     See \a NativeProcessProtocol::StartIntelPTTrace.
+  ///
+  /// \param[in] perf_config
+  ///     See \a NativeProcessProtocol::StartIntelPTTrace.
+  ///
+  /// \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,
+                         size_t buffer_size_in_kb, uint32_t perf_config = 0);
 
   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<TraceIntelPTCPUConfig> GetIntelPTCPUConfig();
+
   static llvm::Expected<ProcessorTraceMonitorUP>
   Create(lldb::pid_t pid, lldb::tid_t tid, const TraceOptions &config,
          bool useProcessSettings);
 
+  /// Start tracing a thread.
+  ///
+  /// See \a StartTrace.
+  ///
+  /// \return
+  ///   A \a ProcessorTraceMonitorUP instance if tracing was successful, or
+  ///   an \a llvm::Error otherwise.
+  static llvm::Expected<ProcessorTraceMonitorUP>
+  Create(lldb::pid_t pid, lldb::tid_t tid, size_t buffer_size_in_kb,
+         uint32_t perf_config);
+
+  /// 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);
+
   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;
 
+  /// Get the size in bytes of the aux section of the thread or process traced
+  /// by this object.
+  size_t GetTraceBufferSizeInBytes() 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.
   ///

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

 
 #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 "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;
#else
   config.setTraceBufferSize(m_mmap_meta->aux_size);
 
   error = GetCPUType(config);
 
   return error;
 #endif
 }
 
+size_t ProcessorTraceMonitor::GetTraceBufferSizeInBytes() const {
+  return m_mmap_meta->aux_size;
+}
+
 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) {
+Error ProcessorTraceMonitor::StartTrace(lldb::pid_t pid, lldb::tid_t tid,
+                                        size_t buffer_size_in_kb,
+                                        uint32_t perf_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 buffer_size = buffer_size_in_kb * 1024;
   uint64_t numpages = static_cast<uint64_t>(
-      llvm::PowerOf2Floor((bufsize + page_size - 1) / page_size));
+      llvm::PowerOf2Floor((buffer_size + 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;
+  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 = perf_config;
 
   Expected<uint32_t> intel_pt_type = GetOSEventType();
 
-  if (!intel_pt_type) {
-    error = intel_pt_type.takeError();
-    return error;
-  }
+  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, "meta buffer size {0}", metabufsize);
-  LLDB_LOG(log, "buffer size {0} ", bufsize);
-
-  if (error.Fail()) {
-    LLDB_LOG(log, "Status in custom config");
-
-    return error;
-  }
+  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);
-    error.SetErrorString("perf event syscall Failed");
-    return error;
+    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, (metabufsize + page_size), PROT_WRITE, MAP_SHARED, fd, 0);
+      mmap(nullptr, (buffer_size + 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;
+    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(metabufsize + page_size));
+      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 = bufsize;
+  m_mmap_meta->aux_size = buffer_size;
 
   errno = 0;
-  auto mmap_aux = mmap(nullptr, bufsize, PROT_READ, MAP_SHARED, fd,
+  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);
-    error.SetErrorString("Trace buffer allocation failed");
-    return error;
+    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(bufsize));
-  return error;
+      reinterpret_cast<uint8_t *>(mmap_aux), munmap_delete(buffer_size));
+  return Error::success();
 #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;
+Expected<TraceIntelPTCPUConfig> ProcessorTraceMonitor::GetIntelPTCPUConfig() {
+  int64_t cpu_family = -1;
+  int64_t model = -1;
+  int64_t stepping = -1;
   std::string vendor_id;
 
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
 
   auto BufferOrError = getProcFile("cpuinfo");
   if (!BufferOrError)
-    return BufferOrError.getError();
+    return Status(BufferOrError.getError()).ToError();
 
   LLDB_LOG(log, "GetCPUType Function");
 
   StringRef Rest = BufferOrError.get()->getBuffer();
   while (!Rest.empty()) {
     StringRef Line;
     std::tie(Line, Rest) = Rest.split('\n');
 
while (!Rest.empty()) {
 
     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);
+    if ((cpu_family != -1) && (model != -1) && (stepping != -1) &&
+        (!vendor_id.empty())) {
+      return TraceIntelPTCPUConfig{
+          static_cast<uint16_t>(cpu_family), static_cast<uint8_t>(model),
+          static_cast<uint8_t>(stepping),
+          vendor_id == "GenuineIntel" ? "intel" : "unknown"};
+    }
+  }
+  return createStringError(inconvertibleErrorCode(), "cpu info not found");
+}
+
+Status ProcessorTraceMonitor::GetCPUType(TraceOptions &config) {
+  Expected<TraceIntelPTCPUConfig> cpu_info_or_err = GetIntelPTCPUConfig();
+  if (!cpu_info_or_err)
+    return Status(cpu_info_or_err.takeError());
+  TraceIntelPTCPUConfig &cpu_info = *cpu_info_or_err;
+
+  params_dict->AddIntegerItem("cpu_family", cpu_info.family);
+  params_dict->AddIntegerItem("cpu_model", cpu_info.model);
+  params_dict->AddIntegerItem("cpu_stepping", cpu_info.stepping);
+  params_dict->AddStringItem("cpu_vendor", cpu_info.vendor);
 
-      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
-    }
-  }
+  return Status();
 
-  error.SetErrorString("cpu info not found");
-  return error;
+llvm::Expected<ProcessorTraceMonitorUP>
+ProcessorTraceMonitor::Create(lldb::pid_t pid, lldb::tid_t tid,
+                              size_t buffer_size_in_kb, uint32_t config) {
+  ProcessorTraceMonitorUP pt_monitor_up(new ProcessorTraceMonitor);
+
+  if (llvm::Error err =
+          pt_monitor_up->StartTrace(pid, tid, buffer_size_in_kb, config))
+    return std::move(err);
+
+  pt_monitor_up->SetThreadID(tid);
+  pt_monitor_up->SetTraceID(m_trace_num++);
+  return std::move(pt_monitor_up);
 }
 
 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);
+  error = pt_monitor_up->StartTrace(pid, tid, config.getTraceBufferSize());
   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);
 }
 
+Expected<std::vector<uint8_t>>
+ProcessorTraceMonitor::GetIntelPTBuffer(size_t offset, size_t size) {
+  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
 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

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

public:
   Status SendGetMetaDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id,
                                llvm::MutableArrayRef<uint8_t> &buffer,
                                size_t offset = 0);
 
   Status SendGetTraceConfigPacket(lldb::user_id_t uid, TraceOptions &options);
 
   llvm::Expected<TraceTypeInfo> SendGetSupportedTraceType();
 
+  llvm::Error SendTraceStart(const llvm::json::Value &options);
+
+  llvm::Error SendTraceStop(const TraceStopPacket &params);
+
+  llvm::Expected<std::string> SendTraceGetState(llvm::StringRef type);
+
+  llvm::Expected<std::vector<uint8_t>>
+  SendTraceGetBinaryData(const TraceGetBinaryDataPacket &params);
+
 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;
   LazyBool m_supports_vCont_C;

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

else
       return type.takeError();
   }
   LLDB_LOG(log, "failed to send packet: jLLDBTraceSupportedType");
   return llvm::createStringError(
       llvm::inconvertibleErrorCode(),
       "failed to send packet: jLLDBTraceSupportedType");
 }
 
+llvm::Error
+GDBRemoteCommunicationClient::SendTraceStop(const TraceStopPacket &params) {
+  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+
+  StreamGDBRemote escaped_packet;
+  escaped_packet.PutCString("jLLDBTraceStop:");
+
+  std::string json_string;
+  llvm::raw_string_ostream os(json_string);
+  os << llvm::json::toJSON(params);
+  os.flush();
+
+  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(),
+                                     "jLLDBTraceStop is unsupported");
+    if (response.IsOKResponse())
+      return llvm::Error::success();
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Invalid jLLDBTraceStop response");
+  }
+  LLDB_LOG(log, "failed to send packet: jLLDBTraceStop");
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "failed to send packet: jLLDBTraceStop '%s'",
+                                 escaped_packet.GetData());
+}
+
+llvm::Error
+GDBRemoteCommunicationClient::SendTraceStart(const llvm::json::Value &params) {
+  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+
+  StreamGDBRemote escaped_packet;
+  escaped_packet.PutCString("jLLDBTraceStart:");
+
+  std::string json_string;
+  llvm::raw_string_ostream os(json_string);
+  os << params;
+  os.flush();
+
+  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(),
+                                     "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: jLLDBTraceStart");
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "failed to send packet: jLLDBTraceStart '%s'",
+                                 escaped_packet.GetData());
+}
+
+llvm::Expected<std::string>
+GDBRemoteCommunicationClient::SendTraceGetState(llvm::StringRef type) {
+  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+
+  StreamGDBRemote escaped_packet;
+  escaped_packet.PutCString("jLLDBTraceGetState:");
+
+  std::string json_string;
+  llvm::raw_string_ostream os(json_string);
+  os << llvm::json::toJSON(TraceGetStatePacket{type.str()});
+  os.flush();
+
+  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(),
+                                     "jLLDBTraceGetState is unsupported");
+    return std::string(response.Peek());
+  }
+
+  LLDB_LOG(log, "failed to send packet: jLLDBTraceGetState");
+  return llvm::createStringError(
+      llvm::inconvertibleErrorCode(),
+      "failed to send packet: jLLDBTraceGetState '%s'",
+      escaped_packet.GetData());
+}
+
+llvm::Expected<std::vector<uint8_t>>
+GDBRemoteCommunicationClient::SendTraceGetBinaryData(
+    const TraceGetBinaryDataPacket &params) {
+  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+
+  StreamGDBRemote escaped_packet;
+  escaped_packet.PutCString("jLLDBTraceGetBinaryData:");
+
+  std::string json_string;
+  llvm::raw_string_ostream os(json_string);
+  os << llvm::json::toJSON(params);
+  os.flush();
+
+  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(),
+                                     "jLLDBTraceGetBinaryData is unsupported");
+    std::string data;
+    response.GetEscapedBinaryData(data);
+    return std::vector<uint8_t>(data.begin(), data.end());
+  }
+  LLDB_LOG(log, "failed to send packet: jLLDBTraceGetBinaryData");
+  return llvm::createStringError(
+      llvm::inconvertibleErrorCode(),
+      "failed to send packet: jLLDBTraceGetBinaryData '%s'",
+      escaped_packet.GetData());
+}
+
 Status
 GDBRemoteCommunicationClient::SendGetTraceConfigPacket(lldb::user_id_t uid,
                                                        TraceOptions &options) {
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
   StringExtractorGDBRemote response;
   Status error;
 
   StreamString json_string;

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_jTraceRead(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_jTraceStop(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_jTraceConfigRead(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_jLLDBTraceSupportedType(StringExtractorGDBRemote &packet);
 
+  PacketResult Handle_jLLDBTraceStart(StringExtractorGDBRemote &packet);
+
+  PacketResult Handle_jLLDBTraceStop(StringExtractorGDBRemote &packet);
+
+  PacketResult Handle_jLLDBTraceGetState(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_jTraceStop,
       &GDBRemoteCommunicationServerLLGS::Handle_jTraceStop);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_jTraceConfigRead,
       &GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_jLLDBTraceSupportedType,
       &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupportedType);
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_jLLDBTraceStart,
+      &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStart);
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_jLLDBTraceStop,
+      &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStop);
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_jLLDBTraceGetState,
+      &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetState);
+  RegisterMemberFunctionHandler(
+      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;
case eStopReasonWatchpoint:
     return "watchpoint";
   case eStopReasonSignal:
     return "signal";
   case eStopReasonException:
     return "exception";
   case eStopReasonExec:
     return "exec";
   case eStopReasonInstrumentation:
   case eStopReasonInvalid:
   case eStopReasonPlanComplete:
   case eStopReasonThreadExiting:
   case eStopReasonNone:
     break; // ignored
   }
   return nullptr;
 }
 
GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupportedType(
   StreamString json_string;
   json_packet.Dump(json_string, false);
   escaped_response.PutEscapedBytes(json_string.GetData(),
                                    json_string.GetSize());
   return SendPacketNoLock(escaped_response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
+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(Status("Process not running."));
+
+  packet.ConsumeFront("jLLDBTraceStop:");
+  Expected<TraceStopPacket> stop_packet =
+      json::parse<TraceStopPacket>(packet.Peek());
+  if (!stop_packet)
+    return SendErrorResponse(stop_packet.takeError());
+
+  if (Error err = m_debugged_process_up->TraceStop(*stop_packet))
+    return SendErrorResponse(std::move(err));
+
+  return SendOKResponse();
+}
+
+GDBRemoteCommunication::PacketResult
+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."));
+
+  packet.ConsumeFront("jLLDBTraceStart:");
+  Expected<TraceStartBasePacket> start_packet =
+      json::parse<TraceStartBasePacket>(packet.Peek());
+  if (!start_packet)
+    return SendErrorResponse(start_packet.takeError());
+
+  if (Error err =
+          m_debugged_process_up->TraceStart(packet.Peek(), start_packet->type))
+    return SendErrorResponse(std::move(err));
+
+  return SendOKResponse();
+}
+
+GDBRemoteCommunication::PacketResult
+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(Status("Process not running."));
+
+  packet.ConsumeFront("jLLDBTraceGetState:");
+  Expected<TraceGetStatePacket> get_state_packet =
+      json::parse<TraceGetStatePacket>(packet.Peek());
+  if (!get_state_packet)
+    return SendErrorResponse(get_state_packet.takeError());
+
+  if (Expected<json::Value> response_or_err =
+          m_debugged_process_up->TraceGetState(get_state_packet->type))
+    return SendJSONResponse(*response_or_err);
+  else
+    return SendErrorResponse(response_or_err.takeError());
+}
+
+GDBRemoteCommunication::PacketResult
+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(Status("Process not running."));
+
+  packet.ConsumeFront("jLLDBTraceGetBinaryData:");
+  llvm::Expected<TraceGetBinaryDataPacket> get_data_packet =
+      llvm::json::parse<TraceGetBinaryDataPacket>(packet.Peek());
+  if (!get_data_packet)
+    return SendErrorResponse(Status(get_data_packet.takeError()));
+
+  if (Expected<std::vector<uint8_t>> bytes =
+          m_debugged_process_up->TraceGetBinaryData(*get_data_packet)) {
+    StreamGDBRemote response;
+    response.PutEscapedBytes(bytes->data(), bytes->size());
+    return SendPacketNoLock(response.GetString());
+  } else
+    return SendErrorResponse(bytes.takeError());
+}
+
+GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead(
     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);
 

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

Status GetData(lldb::user_id_t uid, lldb::tid_t thread_id,
                  size_t offset = 0) override;
 
   Status GetMetaData(lldb::user_id_t uid, lldb::tid_t thread_id,
                      llvm::MutableArrayRef<uint8_t> &buffer,
                      size_t offset = 0) override;
 
   llvm::Expected<TraceTypeInfo> GetSupportedTraceType() override;
 
+  llvm::Error StopTracing(const TraceStopPacket &request) override;
+
+  llvm::Error StartTracing(const llvm::json::Value &request) override;
+
+  llvm::Expected<std::string> GetTracingState(llvm::StringRef type) override;
+
+  llvm::Expected<std::vector<uint8_t>>
+  TraceGetBinaryData(const TraceGetBinaryDataPacket &params) override;
+
   Status GetTraceConfig(lldb::user_id_t uid, TraceOptions &options) override;
 
   Status GetWatchpointSupportInfo(uint32_t &num, bool &after) override;
 
   bool StartNoticingNewThreads() override;
 
   bool StopNoticingNewThreads() override;
 

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

Status ProcessGDBRemote::GetTraceConfig(lldb::user_id_t uid,
                                         TraceOptions &options) {
   return m_gdb_comm.SendGetTraceConfigPacket(uid, options);
 }
 
 llvm::Expected<TraceTypeInfo> ProcessGDBRemote::GetSupportedTraceType() {
   return m_gdb_comm.SendGetSupportedTraceType();
 }
 
+llvm::Error ProcessGDBRemote::StopTracing(const TraceStopPacket &request) {
+  return m_gdb_comm.SendTraceStop(request);
+}
+
+llvm::Error ProcessGDBRemote::StartTracing(const llvm::json::Value &request) {
+  return m_gdb_comm.SendTraceStart(request);
+}
+
+llvm::Expected<std::string>
+ProcessGDBRemote::GetTracingState(llvm::StringRef type) {
+  return m_gdb_comm.SendTraceGetState(type);
+}
+
+llvm::Expected<std::vector<uint8_t>>
+ProcessGDBRemote::TraceGetBinaryData(const TraceGetBinaryDataPacket &params) {
+  return m_gdb_comm.SendTraceGetBinaryData(params);
+}
+
 void ProcessGDBRemote::DidExit() {
   // When we exit, disconnect from the GDB server communications
   m_gdb_comm.Disconnect();
 }
 
 void ProcessGDBRemote::DidAttach(ArchSpec &process_arch) {
   // If you can figure out what the architecture is, fill it in here.
   process_arch.Clear();

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

 
 #include "../../../../source/Commands/CommandObjectThreadUtil.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
-class CommandObjectTraceStartIntelPT : public CommandObjectIterateOverThreads {
+class CommandObjectTraceStartIntelPT : public CommandObjecThreadTraceStart {
 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_buffer_size_in_kb;
+    uint32_t m_perf_config;
   };
 
   CommandObjectTraceStartIntelPT(CommandInterpreter &interpreter)
-      : CommandObjectIterateOverThreads(
-            interpreter, "thread trace start",
+      : CommandObjecThreadTraceStart(
+            "intel-pt", 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() {}
 
   ~CommandObjectTraceStartIntelPT() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
-  bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override;
+  llvm::Expected<llvm::json::Value>
+  CreateTraceStartParams(lldb::TraceOperationVariant variant,
+                         const std::vector<lldb::tid_t> &tids) override;
 
   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;
 
 #define LLDB_OPTIONS_thread_trace_start_intel_pt
 #include "TraceIntelPTCommandOptions.inc"
 
 Status CommandObjectTraceStartIntelPT::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)
       error.SetErrorStringWithFormat("invalid integer value for option '%s'",
                                      option_arg.str().c_str());
     else
-      m_size_in_kb = size_in_kb;
+      m_buffer_size_in_kb = size_in_kb;
     break;
   }
   case 'c': {
-    int32_t custom_config;
-    if (option_arg.empty() || option_arg.getAsInteger(0, custom_config) ||
-        custom_config < 0)
+    int32_t perf_config;
+    if (option_arg.empty() || option_arg.getAsInteger(0, perf_config) ||
+        perf_config < 0)
       error.SetErrorStringWithFormat("invalid integer value for option '%s'",
                                      option_arg.str().c_str());
     else
-      m_custom_config = custom_config;
+      m_perf_config = perf_config;
     break;
   }
   default:
     llvm_unreachable("Unimplemented option");
   }
   return error;
 }
 
 void CommandObjectTraceStartIntelPT::CommandOptions::OptionParsingStarting(
     ExecutionContext *execution_context) {
-  m_size_in_kb = 4;
-  m_custom_config = 0;
+  m_buffer_size_in_kb = 4;
+  m_perf_config = 0;
 }
 
 llvm::ArrayRef<OptionDefinition>
 CommandObjectTraceStartIntelPT::CommandOptions::GetDefinitions() {
   return llvm::makeArrayRef(g_thread_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);
-  result.SetStatus(eReturnStatusSuccessFinishResult);
-  return result.Succeeded();
+Expected<json::Value> CommandObjectTraceStartIntelPT::CreateTraceStartParams(
+    TraceOperationVariant variant, const std::vector<lldb::tid_t> &tids) {
+
+  TraceIntelPTStartPacketParams params;
+  params.buffer_size_in_kb = m_options.m_buffer_size_in_kb;
+  params.perf_config = m_options.m_perf_config;
+
+  TraceIntelPTStartPacket packet("intel-pt", variant, tids, params);
+
+  return json::toJSON(packet);
 }

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

 /// 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

 
 #include "DecodedThread.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 its trace buffer /
+/// file.
+class ThreadDecoder {
+public:
+  virtual ~ThreadDecoder() = default;
+
+  ThreadDecoder(const pt_cpu &pt_cpu) : m_pt_cpu(pt_cpu) {}
+
+  /// Decode the thread and store the result internally, to avoid
+  /// recomputations.
+  ///
+  /// \return
+  ///     A \a DecodedThread instance.
+  const DecodedThread &Decode();
+
+  virtual size_t GetBufferSizeInBytes() = 0;
+
+  ThreadDecoder(const ThreadDecoder &other) = delete;
+  ThreadDecoder &operator=(const ThreadDecoder &other) = delete;
+
+protected:
+  /// Decode the thread.
+  ///
+  /// \return
+  ///     A \a DecodedThread instance.
+  virtual DecodedThread DoDecode() = 0;
+
+  pt_cpu m_pt_cpu;
+  llvm::Optional<DecodedThread> m_decoded_thread;
+};
+
+/// Decoder implementation for \a lldb_private::ThreadTrace, which are non-live
+/// processes that come trace session files.
+class ThreadTraceDecoder : public 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.
+  ///     The libipt cpu used when decoding 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() {}
+      : ThreadDecoder(pt_cpu), m_trace_thread(trace_thread) {}
 
-  /// Decode the thread and store the result internally.
-  ///
-  /// \return
-  ///     A \a DecodedThread instance.
-  const DecodedThread &Decode();
+  size_t GetBufferSizeInBytes() override;
 
 private:
-  ThreadTraceDecoder(const ThreadTraceDecoder &other) = delete;
-  ThreadTraceDecoder &operator=(const ThreadTraceDecoder &other) = delete;
+  DecodedThread DoDecode() override;
 
   std::shared_ptr<ThreadTrace> m_trace_thread;
-  pt_cpu m_pt_cpu;
-  llvm::Optional<DecodedThread> m_decoded_thread;
+};
+
+class LiveThreadDecoder : public ThreadDecoder {
+public:
+  /// \param[in] thread
+  ///     The thread whose traces will be decoded.
+  ///
+  /// \param[in] pt_cpu
+  ///     The libipt cpu used when decoding the trace.
+  LiveThreadDecoder(Thread &thread, const pt_cpu &pt_cpu,
+                    size_t buffer_size_in_bytes);
+
+  size_t GetBufferSizeInBytes() override;
+
+private:
+  DecodedThread DoDecode() override;
+
+  lldb::ThreadSP m_thread_sp;
+  size_t m_buffer_size_in_bytes;
 };
 
 } // 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++ -*-===//
 //
 // 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/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 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>
+static Expected<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;
-
+                       MutableArrayRef<uint8_t> buffer) {
   pt_config config;
   pt_config_init(&config);
   config.cpu = pt_cpu;
 
   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>>
+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 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 CreateDecoderAndDecode(process, pt_cpu, trace_data);
+}
+
+static Expected<std::vector<IntelPTInstruction>>
+CreateDecoderAndDecode(Thread &thread, const pt_cpu &pt_cpu,
+                       size_t size_in_bytes) {
+  Expected<std::vector<uint8_t>> buffer =
+      thread.GetProcess()->TraceGetBinaryData(TraceGetBinaryDataPacket{
+          "intel-pt", "thread_trace_buffer", thread.GetID(), 0, size_in_bytes});
+  if (!buffer)
+    return buffer.takeError();
+  return CreateDecoderAndDecode(*thread.GetProcess(), pt_cpu,
+                                MutableArrayRef<uint8_t>(*buffer));
 
+DecodedThread ThreadTraceDecoder::DoDecode() {
+  if (Expected<std::vector<IntelPTInstruction>> instructions =
+          CreateDecoderAndDecode(*m_trace_thread->GetProcess(), m_pt_cpu,
+                                 m_trace_thread->GetTraceFile()))
+    return DecodedThread(std::move(*instructions));
+  else
+    return DecodedThread(instructions.takeError());
+}
+
+LiveThreadDecoder::LiveThreadDecoder(Thread &thread, const pt_cpu &pt_cpu,
+                                     size_t buffer_size_in_bytes)
+    : ThreadDecoder(pt_cpu), m_thread_sp(thread.shared_from_this()),
+      m_buffer_size_in_bytes(buffer_size_in_bytes) {}
+
+DecodedThread LiveThreadDecoder::DoDecode() {
+  if (Expected<std::vector<IntelPTInstruction>> instructions =
+          CreateDecoderAndDecode(*m_thread_sp, m_pt_cpu,
+                                 GetBufferSizeInBytes()))
+    return DecodedThread(std::move(*instructions));
+  else
+    return DecodedThread(instructions.takeError());
+}
+
+const DecodedThread &ThreadDecoder::Decode() {
+  if (!m_decoded_thread.hasValue())
+    m_decoded_thread = DoDecode();
   return *m_decoded_thread;
 }
+
+size_t LiveThreadDecoder::GetBufferSizeInBytes() {
+  return m_buffer_size_in_bytes;
+}
+
+size_t ThreadTraceDecoder::GetBufferSizeInBytes() {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> trace_or_error =
+      MemoryBuffer::getFile(m_trace_thread->GetTraceFile().GetPath());
+  if (std::error_code err = trace_or_error.getError())
+    return 0;
+
+  MemoryBuffer &trace = **trace_or_error;
+  return trace.getBufferSize();
+}

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;
   /// \}
 
   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;
 
-  size_t GetCursorPosition(const Thread &thread) override;
+  void RefreshLiveProcessState(Process &process);
+
+  bool IsTraced(const Thread &thread) override;
 
 private:
   friend class TraceIntelPTSessionFileParser;
 
   /// \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);
 
+  /// Constructor for live processes
+  TraceIntelPT() : m_pt_cpu(), 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;
+  std::map<const Thread *, std::unique_ptr<ThreadDecoder>> m_thread_decoders;
+  int64_t m_stop_id = -1;
+  /// 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

 LLDB_PLUGIN_DEFINE(TraceIntelPT)
 
 CommandObjectSP GetStartCommand(CommandInterpreter &interpreter) {
   return CommandObjectSP(new CommandObjectTraceStartIntelPT(interpreter));
 }
 
 void TraceIntelPT::Initialize() {
   PluginManager::RegisterPlugin(
-      GetPluginNameStatic(), "Intel Processor Trace", CreateInstance,
+      GetPluginNameStatic(), "Intel Processor Trace",
+      CreateInstanceForSessionFile, CreateInstanceForLiveProcess,
       TraceIntelPTSessionFileParser::GetSchema(), GetStartCommand);
 }
 
 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.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));
+    m_thread_decoders.emplace(
+        thread.get(), std::make_unique<ThreadTraceDecoder>(thread, pt_cpu));
 }
 
-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(*thread.GetProcess());
+  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;
 }
+
+void TraceIntelPT::RefreshLiveProcessState(Process &process) {
+  if (!process.IsLiveDebugSession())
+    return;
+
+  uint32_t new_stop_id = process.GetStopID();
+  if (new_stop_id == m_stop_id)
+    return;
+
+  m_thread_decoders.clear();
+  m_stop_id = new_stop_id;
+
+  Expected<std::string> json_string = process.GetTracingState("intel-pt");
+  if (!json_string) {
+    m_failed_live_threads_decoder = DecodedThread(json_string.takeError());
+    return;
+  }
+
+  Expected<TraceIntelPTState> state =
+      json::parse<TraceIntelPTState>(*json_string);
+  if (!state) {
+    std::vector<IntelPTInstruction> instructions;
+    instructions.emplace_back(state.takeError());
+    m_failed_live_threads_decoder = DecodedThread(state.takeError());
+    return;
+  }
+
+  m_pt_cpu = TraceIntelPTSessionFileParser::ParsePTCPU(state->cpu_config);
+
+  for (const TraceIntelPTThreadState &thread_state : state->threads) {
+    Thread &thread = *process.GetThreadList().FindThreadByID(thread_state.tid);
+    m_thread_decoders.emplace(
+        &thread, std::make_unique<LiveThreadDecoder>(
+                     thread, m_pt_cpu, thread_state.buffer_size_in_bytes));
+  }
+}
+
+bool TraceIntelPT::IsTraced(const Thread &thread) {
+  return m_thread_decoders.count(&thread);
+}

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<"The size of the trace in KB. It is rounded up to the nearest pwoer of"
+         " 2. Defaults to 4.">;
+  def thread_trace_start_intel_pt_custom_config: Option<"perf-config", "c">,
     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/*`. "
+    Desc<"Custom low level perf event 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.">;
 }

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;
-    int64_t family;
-    int64_t model;
-    int64_t stepping;
-  };
-
   struct JSONTraceIntelPTSettings
       : TraceSessionFileParser::JSONTracePluginSettings {
-    JSONPTCPU pt_cpu;
+    TraceIntelPTCPUConfig pt_cpu;
   };
 
   /// 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()),
public:
   ///   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,
                              std::vector<ParsedProcess> &parsed_processes);
 
-private:
-  pt_cpu ParsePTCPU(const JSONPTCPU &pt_cpu);
+  static pt_cpu ParsePTCPU(const TraceIntelPTCPUConfig &pt_cpu);
 
+private:
   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);
 
 } // 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/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": {
       "vendor": "intel" | "unknown",
       "family": integer,
       "model": integer,
       "stepping": integer
     }
   })");
   }
   return schema;
 }
 
-pt_cpu TraceIntelPTSessionFileParser::ParsePTCPU(const JSONPTCPU &pt_cpu) {
+pt_cpu
+TraceIntelPTSessionFileParser::ParsePTCPU(const TraceIntelPTCPUConfig &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)};
 }
 
 TraceSP TraceIntelPTSessionFileParser::CreateTraceIntelPTInstance(
     const pt_cpu &pt_cpu, std::vector<ParsedProcess> &parsed_processes) {
return CreateTraceIntelPTInstance(ParsePTCPU(session.trace.pt_cpu),
                                       *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) &&
          fromJSON(
              value,
              (TraceSessionFileParser::JSONTracePluginSettings &)plugin_settings,
              path);
 }
 
 } // namespace json
 } // namespace llvm

lldb/source/Target/Trace.cpp

Expected<lldb::TraceSP> Trace::FindPlugin(Debugger &debugger,
 
   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::FindPlugin(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 =

lldb/source/Utility/StringExtractorGDBRemote.cpp

case 'j':
     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_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/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"
 
+#include <type_traits>
+
+#include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/StringExtractor.h"
+
 using namespace lldb_private;
 
 namespace llvm {
 namespace json {
 
+template <
+    typename T,
+    typename std::enable_if<
+        std::is_same<T, size_t>::value || std::is_same<T, uint64_t>::value ||
+        std::is_same<T, uint32_t>::value || std::is_same<T, uint16_t>::value ||
+        std::is_same<T, uint8_t>::value>::type * = nullptr>
+static bool fromJSON(const Value &value, T &out, Path path) {
+  if (auto number = value.getAsInteger()) {
+    out = *number;
+    return true;
+  }
+  path.report("expected integer");
+  return false;
+}
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
+static Value toJSON(T number) {
+  return Value(static_cast<int64_t>(number));
+}
+
+template <typename T> static Value toJSON(const std::vector<T> &elements) {
+  Array array;
+  array.reserve(elements.size());
+
+  for (const T &element : elements)
+    array.push_back(toJSON(element));
+
+  return array;
+}
+
+static bool fromJSON(const Value &value, lldb::TraceOperationVariant &variant,
+                     Path path) {
+  std::string string_variant;
+  if (!fromJSON(value, string_variant, path))
+    return false;
+  if (string_variant == "specificThreads")
+    variant = lldb::eTraceOperationVariantSpecificThreads;
+  else if (string_variant == "currentAndFutureThreads")
+    variant = lldb::eTraceOperationVariantCurrentAndFutureThreads;
+  else if (string_variant == "process")
+    variant = lldb::eTraceOperationVariantProcess;
+  else {
+    path.report("invalid TraceOperationVariant");
+    return false;
+  }
+  return true;
+}
+
+static std::string toJSON(lldb::TraceOperationVariant variant) {
+  switch (variant) {
+  case lldb::eTraceOperationVariantSpecificThreads:
+    return "specificThreads";
+  case lldb::eTraceOperationVariantCurrentAndFutureThreads:
+    return "currentAndFutureThreads";
+  case lldb::eTraceOperationVariantProcess:
+    return "process";
+  }
+};
+
+// jLLDBTraceGetSupportedType
 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);
 }
 
+// jLLDBTraceStop
+bool fromJSON(const Value &value, TraceStopPacket &packet, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("type", packet.type) && o.map("tids", packet.tids) &&
+         o.map("variant", packet.variant);
+}
+
+Value toJSON(const TraceStopPacket &packet) {
+  return Object{{"type", packet.type},
+                {"tids", toJSON(packet.tids)},
+                {"variant", toJSON(packet.variant)}};
+}
+
+// jLLDBTraceStart
+
+bool fromJSON(const Value &value, TraceStartBasePacket &packet, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("type", packet.type) && o.map("tids", packet.tids) &&
+         o.map("variant", packet.variant);
+}
+
+Value toJSON(const lldb_private::TraceStartBasePacket &packet) {
+  return Object{{"tids", toJSON(packet.tids)},
+                {"variant", toJSON(packet.variant)},
+                {"type", packet.type}};
+}
+
+bool fromJSON(const Value &value, TraceIntelPTStartPacketParams &packet,
+              Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("bufferSizeInKB", packet.buffer_size_in_kb) &&
+         o.map("perfConfig", packet.perf_config);
+}
+
+Value toJSON(const TraceIntelPTStartPacketParams &packet) {
+  return Object{
+      {"bufferSizeInKB", static_cast<int64_t>(packet.buffer_size_in_kb)},
+      {"perfConfig", static_cast<int64_t>(packet.perf_config)}};
+}
+
+// jLLDBTraceGetState
+
+bool fromJSON(const Value &value, TraceGetStatePacket &packet, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("type", packet.type);
+}
+
+Value toJSON(const TraceGetStatePacket &packet) {
+  return Object{{"type", packet.type}};
+}
+
+bool fromJSON(const Value &value, TraceIntelPTThreadState &state, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("tid", state.tid) &&
+         o.map("bufferSizeInBytes", state.buffer_size_in_bytes);
+}
+
+Value toJSON(const lldb_private::TraceIntelPTThreadState &state) {
+  return Object{
+      {"tid", static_cast<int64_t>(state.tid)},
+      {"bufferSizeInBytes", static_cast<int64_t>(state.buffer_size_in_bytes)}};
+}
+
+bool fromJSON(const Value &value, TraceIntelPTCPUConfig &cpu_config,
+              Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("vendor", cpu_config.vendor) &&
+         o.map("family", cpu_config.family) &&
+         o.map("model", cpu_config.model) &&
+         o.map("stepping", cpu_config.stepping);
+}
+
+Value toJSON(const TraceIntelPTCPUConfig &cpu_config) {
+  return Object{{"family", cpu_config.family},
+                {"model", cpu_config.model},
+                {"stepping", cpu_config.stepping},
+                {"vendor", cpu_config.vendor}};
+}
+
+bool fromJSON(const Value &value, TraceIntelPTState &state, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("threads", state.threads) &&
+         o.map("cpu_config", state.cpu_config);
+}
+
+Value toJSON(const TraceIntelPTState &state) {
+  return Object{{"threads", toJSON(state.threads)},
+                {"cpu_config", toJSON(state.cpu_config)}};
+}
+
+// jLLDBTraceGetBinaryData
+
+Value toJSON(const TraceGetBinaryDataPacket &packet) {
+  return Object{{"type", packet.type},
+                {"label", packet.label},
+                {"tid", static_cast<int64_t>(packet.tid)},
+                {"offset", static_cast<int64_t>(packet.offset)},
+                {"size", static_cast<int64_t>(packet.size)}};
+}
+
+bool fromJSON(const Value &value, TraceGetBinaryDataPacket &packet, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("type", packet.type) && o.map("label", packet.label) &&
+         o.map("tid", packet.tid) && o.map("offset", packet.offset) &&
+         o.map("size", packet.size);
+}
+
 } // namespace json
 } // namespace llvm

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"])
 
         # 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)
 
     @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 1")
+        
+        # We fail if we try to trace again
+        #self.expect("thread trace start", error=True, 
+        #    substrs=["error: tracing already active on this thread"])
+
+        # 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'''])
 
-        self.expect("thread trace start --size 20 --custom-config 1",
-            patterns=["would trace tid .* with size_in_kb 20 and custom_config 1"])
+        # We stop tracing
+        self.expect("thread trace stop")
 
-        # This fails because "trace stop" is not yet implemented.
+        # We can't stop twice
         self.expect("thread trace stop", error=True,
-            substrs=["error: Process is not being traced"])
+            substrs=["error: thread not 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/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("thread trace start all")
+
+
+        # 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("thread trace start all")
+
+
+        # 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 testStartMultipleLiveThreadsWithAllStops(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("thread trace start all")
+
+
+        # 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, thread 2 and 3 will be alive, but not traced.
+        self.expect("continue")
+        self.expect("thread trace dump instructions", substrs=['not traced'])
+        self.expect("thread trace dump instructions 2", substrs=['not traced'])
+        self.expect("thread trace dump instructions 3", substrs=['not 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;
+}