Implementation of remote packets for Trace data.

[ravitheja]

Summary

The changes consist of new packets for trace manipulation and
trace collection. The new packets are also documented. The packets
are capable of providing custom trace specific parameters to start
tracing and also retrieve such configuration from the server.

[clayborg]

This patch does nicely follow the way other GDB remote packets are implemented. I wonder if we should just have a "jTrace" packet that is JSON from the start? This is more of a question to anyone that cares about the direction of the GDB remote protocol we are using. We might not multiple flavors of the qTrace packet in that case. Just add a key/value pair that say what the packet command is (start, stop, get trace data, get metadata, etc). I am curious to see what others think. I don't have any objections to this patch as is, but just wanted to check.

docs/lldb-gdb-remote.txt

212

Should we make all these new packets JSON based to start with? "jTrace"? If we have any need for JSON at all in this or the other new packets I would say lets just go with JSON packets. They are currently prefixed with "j". If we go this route we should specify the mandatory key/value pairs in the header doc. We should also allow a JSON dictionary from the trace config up at the SBTrace layer to make it into this packet?

[ravitheja]

docs/lldb-gdb-remote.txt

212

I am fine prefixing the packets with "j", I did not understand what you meant by the last sentence. At the moment I am waiting for Pavel or Tamas to reply or anyone else and based on the complete feedback, I will upload a new patch if needed.

[labath]

I am adding Zachary, as he usually has good ideas about APIs.

All in all, it's not a very controversal change, but I have a bunch of inline comments about the choice of API. They can be summed up as:

• use more ArrayRef
• use less shared pointers
• use LLDB_LOG

I quite like that you have added just the packet plumbing code without an concrete implementation. However, that is still a significant amount of parsing code that should be accompanied by a test. The test suite for the client side of the protocol is ready (TestGdbRemoteCommunicationClient), so I'd like to see at least that.

docs/lldb-gdb-remote.txt

212

I think Greg meant you should also change the packet format to take a json argument instead of key-value pairs (The packet should be JTrace if it modifies the state, right ?).

If there is a gdb equivalent which matches this functionality sufficiently closely, then I would prefer to stick to that. However, given that we already are attaching a json field to the packet, I think it would make sense to go json all the way.

236

The code seems to be sending some json dictionaries, but I see no mention of that here.

239

can we call this "trace id"? I'd like to avoid people confusing this with *real* UIDs.

244

You seem to be putting "arguments" here, and you also have "mandatory" arguments down below. This is mostly a style issue, but I propose you either go with "put all mandatory arguments in the summary and only list optional arguments below", or with "list all arguments in the table below" approach.

269

Empty response means "packet not supported". You should send OK in this case.

include/lldb/Host/common/NativeProcessProtocol.h

13

You are missing the traceOptions file from this patch.

333

Hard to say without seeing TraceOptions contents, but I would hope this argument can be const. If you want these functions to modify it, then maybe a different api would be called for.

370

return Error("Not implemented");

396

llvm::MutableArrayRef<uint8_t> instead of buf+size pair. Maybe we could even pass in a reference to the MutableArrayRef so that the function can truncate it to the actual size?

407

ditto

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

1144

There is a StringRef function which does this directly.

1156

There seems to be very little error handling in here. Do you want the tracing to proceed in this was not valid json? Do you want the tracing to proceed if buffersize was not specified (you list it as mandatory).

1172

If this is going to be a dumb struct, then do we need the getter/setter pairs?

1180

What do you think about adding tid to the "options" class and just having one "StartTracing" function?

1211

LLDB_LOG(log, "Illformed type") is a much more concise way to write this.

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

179

const TraceOptions &options ? Having a reference to a shared pointer seems like a huge overkill here.

186

MutableArrayRef

[clayborg]

docs/lldb-gdb-remote.txt

212

I think the entire packet should be:

$jTrace:XXXX

where XXXX is a JSON dictionary. Ravitheja had talked before about adding an implementation specific JSON dictionary into the JSON that comes in to configure the trace at the lldb::SB layer. I was just saying it would be nice if this implementation specific JSON was sent down as part of this packet so the GDB server can use it. Maybe we just send the entire thing that came in at the SB layer?

239

trace id would be nice

269

Agreed

include/lldb/Host/common/NativeProcessProtocol.h

396

This is ok for internal functions. If we use a reference to a llvm::MutableArrayRef<> then we can return Error as the in/out mutable array ref reference can be updated with the right size right?

[zturner]

docs/lldb-gdb-remote.txt

214

I just noticed that none of our documentation uses doxygen? Weird.

include/lldb/Host/common/NativeProcessProtocol.h

396

Agreed.

virtual Error GetTraceData(user_id_t uid, tid_t thread, MutableArrayRef<uint8_t> &Buffer, size_t offset=0);

429–430

virtual Error GetTraceConfig(user_id_t uid, tid_ threadid, TraceOptions &config)

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

1111–1112

Can you use LLDB_LOG() macros here (and everywhere else in this patch)?

1114–1117

Can you add a function to StringExtractor that looks like this:

bool consume_front(StringRef Str) {
  StringRef S = GetStringRef();
  if (!S.starts_with(Str))
    return false;
  m_index += Str.size();
  return true;
}

Then you can change these 3 lines to:

if (!packet.consume_front("QTrace:1:type:"))
  return SendIllFormedResponse(packet, "QTrace:1: Ill formed packet ");

1139

Please use auto custom_params = llvm::make_shared<StructuredData::Dictionary>();

as it is more efficient from a memory standpoint.

1162

Can you use !packet.empty()

1202–1204

Use the consume_front() function I proposed earlier.

1286–1288

consume_front()

1345–1353

consume_front

1392

!packet.empty()

1411–1412

If you make the change suggested earlier to convert this function to use array ref, then this line would be written:

MutableArrayRef<uint8_t> FilledData(buf);
if (tracetype == BufferData)
  error = m_debugged_process_sp->GetTraceData(uid, tid, FilledData, offset);
else
  error = m_debugged_process_sp->GetTraceMetaData(uid, tid, FilledData, offset);

[zturner]

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

182–183

Return the Error instead of taking it as an output parameter.

186

Also, return the Error as before.

189–198

Same in all of these cases. Try to return Error objects whenever possible.

Also remove the virtual keyword from all of these. They are already marked override, so virtual is redundant.

[ravitheja]

Changes for the feedback recieved in first round of review.

[ravitheja]

docs/lldb-gdb-remote.txt

212

Yes thats what is currently being done, the JSON Dictionary obtained at SB layer is being passed down to the server through the remote packets.

include/lldb/Host/common/NativeProcessProtocol.h

13

The traceOptions are already merged into lldb code, please refer to ->https://reviews.llvm.org/D29581

429–430

The threadid is already inside the TraceOptions, which needs to be set by the user, I will update the comments here.

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

1162

I think its not possible to use empty function coz it checks the size of m_packet string inside and not the current m_index.

1392

Not possible I think

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

179

Yes u are right my mistake.

[ravitheja]

In D32585#740632, @labath wrote:

I quite like that you have added just the packet plumbing code without an concrete implementation. However, that is still a significant amount of parsing code that should be accompanied by a test. The test suite for the client side of the protocol is ready (TestGdbRemoteCommunicationClient), so I'd like to see at least that.

@labath I was considering writing Unit tests for the remote packets but I thought then I have to write the mock implementation for the trace operations as well, which might end up being a bigger piece of code than the actual packet parsing code.

After this patch, I will upload the actual server side code doing the trace stuff for linux, that part of code has unit tests for some core functions.

[clayborg]

So my question is: if we go the jTrace packet route, I would like to not use GDB remote key/value pairs, and just go full JSON. You can make a new JSON dict and pass all of the GDB remote key/value pairs inside and then you can add a "jparams" key whose value is the JSON from the SB layer. JSON packets start with lower case j, not sure why some were upper cased?

docs/lldb-gdb-remote.txt

212

I think JSON packets start with lower case 'j'

217–218

Need to remove this bit about semicolon separates key/value pairs as everything is now in the JSON

239

Maybe state that all threads will be traced if this is not supplied?

256

So I am not sure why we are mixing GDB remote key:value; with JSON here? I was thinking the packet would be jTrace:XXXXX where XXXX is the JSON that contains all key value pairs and it also might have an extra jparams key whose value is the JSON from the SB interface.

If we need more than 1 jTrace command it could be "jTraceStart:XXXX" and "jTraceStop:XXXX"

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

187–188

lower case j

196–197

lower case j

199–200

lower case j

1111

lower case j

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

192

lower case j

196

lower case j

source/Utility/StringExtractorGDBRemote.cpp

282

lower case j

283

lower case j

285

lower case j

[zturner]

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

1126

Should you be checking the return value of getAsInteger here? What if it didn't parse as an integer? Confusingly, the function returns true if it failed and false if it suceeded, so watch out.

1201

Can you invert the conditional here and use an early exit from the loop if there's an error?

[labath]

In D32585#752115, @ravitheja wrote:

In D32585#740632, @labath wrote:

I quite like that you have added just the packet plumbing code without an concrete implementation. However, that is still a significant amount of parsing code that should be accompanied by a test. The test suite for the client side of the protocol is ready (TestGdbRemoteCommunicationClient), so I'd like to see at least that.

@labath I was considering writing Unit tests for the remote packets but I thought then I have to write the mock implementation for the trace operations as well, which might end up being a bigger piece of code than the actual packet parsing code.

I don't think that is the case. If you look at the tests in TestGdbRemoteCommunicationClient.cpp, all of them are quite simple. E.g. a test for TestGdbRemoteCommunicationClient could be something like:

TraceOptions opt;
opt.setType(...);
opt.setBufferSize(...);
opt.setMetaBufferSize(); // with an appropriate TraceOptions constructor, this could be a one-liner
  std::future<user_id_t> result = std::async(std::launch::async, [&] {
    return client.StartTrace(opt, error);
  });
HandlePacket(server, "JTrace:start:type:dead:buffersize:beef:metabuffersize:baad:threadid:f00d:jparams:...", "47");
ASSERT_EQ(47, result.get());
ASSERT_TRUE(error.Success());

This depends on the packet code being in GdbRemoteCommunicationClient and not ProcessGdbRemote as it is now, but moving it there is a good idea anyway -- ProcessGdbRemote should do higher level stuff, packet parsing should be left in the GDBRCClient.

The server side code unfortunately cannot be tested this way, but I believe I will get around to enabling that soon as well.

After this patch, I will upload the actual server side code doing the trace stuff for linux, that part of code has unit tests for some core functions.

The problem with that test vector is that the test will only run on linux, and only on processors that support the feature, which means there's a very high chance it will end up being dead code (my guesstimate is our bot does not have the required hardware feature). What is also quite difficult to test with that approach is the failure cases (what happens if the server sends a malformed packed or the response misses some data, etc.).

include/lldb/Utility/StringExtractor.h

114

The name looks wrong. Either use CamelCase or snake_case, don't try to mix the two. (I'd propose camel case).

[ravitheja]

TraceOptions opt;
opt.setType(...);
opt.setBufferSize(...);
opt.setMetaBufferSize(); // with an appropriate TraceOptions constructor, this could be a one-liner
  std::future<user_id_t> result = std::async(std::launch::async, [&] {
    return client.StartTrace(opt, error);
  });
HandlePacket(server, "JTrace:start:type:dead:buffersize:beef:metabuffersize:baad:threadid:f00d:jparams:...", "47");
ASSERT_EQ(47, result.get());
ASSERT_TRUE(error.Success());

This depends on the packet code being in GdbRemoteCommunicationClient and not ProcessGdbRemote as it is now, but moving it there is a good idea anyway -- ProcessGdbRemote should do higher level stuff, packet parsing should be left in the GDBRCClient.

The server side code unfortunately cannot be tested this way, but I believe I will get around to enabling that soon as well.

@labath Can I do the unit tests in a seperate patch after this patch ? It would be easier for me and perhaps also easier to review.

[labath]

llvm policy is to commit tests alongside the code under test. I also think it's easier to review as you have the code and the test on the same screen.

What's the reason that prevents you from doing that?

[ravitheja]

Well nothings preventing me from doing so, I have the changes for that were suggested to me for this revision. I thought I would first upload them, so that people can look at the parallel while I upload the linux server code and Unit tests.

Ok so I will upload what I have right now, and let the people review it in parallel, while I work on the unit tests and I will add them here in the next differential to this patch. I won't merge this patch until then.

[labath]

In D32585#758391, @ravitheja wrote:

Well nothings preventing me from doing so, I have the changes for that were suggested to me for this revision. I thought I would first upload them, so that people can look at the parallel while I upload the linux server code and Unit tests.

Ok so I will upload what I have right now, and let the people review it in parallel, while I work on the unit tests and I will add them here in the next differential to this patch. I won't merge this patch until then.

Uploading them to the phabricator is fine, of course. I would even say recommended. Feel free to do that.

[ravitheja]

Adding unit tests and making the packets fully JSON.

[ravitheja]

Sorry I had to update, since the Error class has been changed to Status.

[labath]

Thank you for taking the time to write the test. Just a couple of more comments on things I noticed when going through this again:

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

3172

I don't think we need the "j" in the "jparams" now that the whole packet is json.

3288

I'm wondering whether we should be sending the trace type as an opaque number -- it's much easier to allocate IDs and manage compatibility if this is a string field. Greg, what do you think?

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

1142

What if jparams isn't a dictionary?

1298

this is dead code. empty will never return true here. The process will just get killed if it fails to allocate.

However, you are right that we should check the allocation as we are allocating a buffer of user-provided size. I recommend explicitly allocating a uint8_t[] using nothrow new. It doesn't stop us from getting killed if the kernel overcommits, but it's better than nothing.

Alternatively you could also change the API to leave the memory allocation to the callee, which will be in a better position do determine whether the size is reasonable.

[krytarowski]

include/lldb/Host/common/NativeProcessProtocol.h

352

This is Linuxism. Not every OS can trace on per-thread basis.

[ravitheja]

include/lldb/Host/common/NativeProcessProtocol.h

352

Yes , the trace id (uid in the example u commented) could refer to a trace instance on a process or a thread. So the following two things can happen ->

1. uid corresponds to a trace instance on a process. In this case thread only needs to specified if the user wants to stop tracing on an individual thread inside a process. If thread level tracing is not supported then thread arg need not be specified.

2. uid corresponds to a trace instance on a thread. In which case the thread argument need not specified and the trace instance should be able to stop the trace.

So to summarize the thread argument only comes into picture when thread level tracing is supported and the user wants to stop tracing on an individual thread of a process being traced.

[clayborg]

Close, some minor fixes.

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

3293

Might be simpler to just do:

if (!custom_params_sp->GetAsDictionary())

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

188

Rename to match previous inline comments

191

Rename to match previous inline comments

194

Rename to match previous inline comments

197

Rename to match previous inline comments

200

Rename to match previous inline comments

1141

verify this is a dictionary first before the static cast below.

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

192

"Handle_jTraceStart" to make it match the packet name of "jTraceStart"

194

"Handle_jTraceRead"

196

Handle_jTraceStop

198

Handle_ jTraceConfigRead

unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

400

Use the R"( so you don't have to desensitize the double quotes and so you can format nicely:

const char *json = R"(
jTraceStart: {
  "buffersize" : 8192,
  "metabuffersize" : 8192,
  "threadid" : 35,
  "type" : 1,
  "jparams" : {
    "psb" : 1,
    "tracetech" : "intel-pt"
  }
})";
HandlePacket(server, json, "1");

409

Ditto

428

Ditto, but inline the R"(...)"

435

Ditto, but inline the R"(...)"

457

Ditto, but inline the R"(...)"

493

Ditto, but inline the R"(...)"

527

Use the R"(

551

Ditto, but inline the R"(...)"

560

Use the R"(

569

Use the R"(

[ravitheja]

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

3293

Yes that could be dangerous to do, coz it returns a pointer to the Dictionary , while setTraceParams needs a shared_pointer and I would have a to create a shared_pointer which is not really being shared.

unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

400

That won't match coz the new lines and extra spaces cause mismatch in the packet string produced. Also unfortunately the Dump Function in the StrucuturedData::Dictionary adds spaces around the colons between "Key" : Value , so removing all whitespaces won't work. Now I can still add some functions to format the expexted string according to the one printed by Dump function, but that would be more code.

[ravitheja]

Updates from last review.

[labath]

unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

400

I've been wanting to add make these tests smarter now that they are getting more use. I'll take a todo item here to add a smarter way to compare json fields here. For now you can at least do the R" thing Greg suggests.

[ravitheja]

unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

400

Yes I can do the R thing but then i can't format it nicely, as Greg suggested.

[labath]

unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

400

Yes, but it will still avoid the need for escaping quotes, which is an improvement in itself.

[ravitheja]

Modifying string literals in Unit tests.

[clayborg]

Looks like we are down to just running clang format on the code so the R"( strings don't go over 80 chars and this is good to go from me.

[ravitheja]

Running clang-format.

[labath]

Looks good as far as I am concerned (please wait for greg's ok though)

[clayborg]

If all R"( strings are under 80 characters, this is good to go. If not, just fix and submit, no extra review needed.

[labath]

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

1304

Hey, ravi. You're leaking memory here. Please put this in a std::unique_ptr<uint8_t[]> so we make sure it get's cleaned up. (No need to request formal review)

[clayborg]

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

1304

use std::vector, I agree with Zach

[ravitheja]

Hello, the reason I switched to allocating with new (std::nothrow) uint8_t[byte_count]; was because the byte_count is actually user defined and I do want to catch cases where lldb is not able to allocate the requested buffer size.

docs/lldb-gdb-remote.txt

 //  they are not provided to lldb, lldb will likely need to send one to
 //  two packets per thread to fetch the data at every private stop.
 //----------------------------------------------------------------------
 
 send packet: QListThreadsInStopReply
 read packet: OK
 
 //----------------------------------------------------------------------
+// jTraceStart:
+//
+// 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
+//  error code is returned instead.
+//----------------------------------------------------------------------
+
+send packet: jTraceStart:{"type":<type>,"buffersize":<buffersize>}]
+read packet: <trace id>/E<error code>
+
+//----------------------------------------------------------------------
+// jTraceStop:
+//
+// BRIEF
+//  Stop tracing instance with trace id <trace id>, of course trace
+//  needs to be started before. The following parameters should be
+//  formatted as a JSON dictionary to the packet. Since sending
+//  JSON data over gdb-remote protocol has certain limitations, binary
+//  escaping convention should be used.
+//
+//  Following is the list of parameters -
+//
+//  Key             Value (Integer)                         (O)Optional/
+//                                                          (M)Mandatory
+//  ==========      ====================================================
+//
+//  traceid         The trace id of the tracing instance    M
+//
+//  threadid        The id of the thread to stop tracing    O
+//                  on. Since <trace id> could map to
+//                  multiple trace instances (in case it
+//                  maps to the complete process), the
+//                  threadid of a particular thread could
+//                  be appended as "threadid:<thread id>;"
+//                  to stop tracing on that thread.
+//  ==========      ====================================================
+//
+//  An OK response is sent in case of success else an error code is
+//  returned.
+//----------------------------------------------------------------------
+
+send packet: jTraceStop:{"traceid":<trace id>}]
+read packet: <OK response>/E<error code>
+
+//----------------------------------------------------------------------
+// jTraceBufferRead:
+//
+// BRIEF
+//  Packet for reading the trace for tracing instance <trace id>, i.e the
+//  id obtained from StartTrace API. The following parameters should be
+//  formatted as a JSON dictionary to the packet. Since sending
+//  JSON data over gdb-remote protocol has certain limitations, binary
+//  escaping convention should be used.
+//
+//  Following is the list of parameters -
+//
+//  Key             Value (Integer)                         (O)Optional/
+//                                                          (M)Mandatory
+//  ==========      ====================================================
+//  traceid         The trace id of the tracing instance    M
+//
+//  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 is sent.
+//----------------------------------------------------------------------
+
+send packet: jTraceBufferRead:{"traceid":<trace id>,"offset":<byteoffset>,"buffersize":<byte_count>}]
+read packet: <binary trace data>/E<error code>
+
+//----------------------------------------------------------------------
+// jTraceMetaRead:
+//
+// BRIEF
+//  Similar Packet as above except it reads meta data.
+//----------------------------------------------------------------------
+
+/----------------------------------------------------------------------
+// jTraceConfigRead:
+//
+// BRIEF
+//  Request the trace configuration for the tracing instance with id
+//  <trace id>.
+//
+//  Following is the list of parameters -
+//
+//  Key             Value (Integer)                         (O)Optional/
+//                                                          (M)Mandatory
+//  ==========      ====================================================
+//  traceid         The trace id of the tracing instance    M
+//
+//  threadid        The id of the thread to obtain trace    O
+//                  configuration from. Since <trace id>
+//                  could map to multiple trace instances
+//                  (in case it maps to the complete
+//                  process), the threadid of a particular
+//                  thread could be appended as
+//                  "threadid:<thread id>;" to obtain the
+//                  trace configuration of that thread.
+//  ==========      ====================================================
+//
+//  In the response packet the trace configuration is sent as text,
+//  formatted as a JSON dictionary. Since sending JSON data over
+//  gdb-remote protocol has certain limitations, binary escaping
+//  convention is used.
+//  In case the trace instance with the <trace id> was not found, an
+//  error code is returned.
+//----------------------------------------------------------------------
+
+send packet: jTraceConfigRead:{"traceid":<trace id>}
+read packet: {"conf1":<conf1>,"conf2":<conf2>,"params":{"paramName":paramValue}]}];/E<error code>
+
+//----------------------------------------------------------------------
 // "qRegisterInfo<hex-reg-id>"
 //
 // BRIEF
 //  Discover register information from the remote GDB server.
 //
 // PRIORITY TO IMPLEMENT
 //  High. Any target that can self describe its registers, should do so.
 //  This means if new registers are ever added to a remote target, they

include/lldb/API/SBTrace.h

public:
   ///     possible to partially read the trace data for some trace
   ///     technologies by specifying a smaller buffer.
   ///
   /// @param[in] offset
   ///     The start offset to begin reading the trace data.
   ///
   /// @param[in] thread_id
   ///     Tracing could be started for the complete process or a
-  ///     single thread, in the first case the uid obtained would
+  ///     single thread, in the first case the traceid obtained would
   ///     map to all the threads existing within the process and the
   ///     ones spawning later. The thread_id parameter can be used in
   ///     such a scenario to select the trace data for a specific
   ///     thread.
   ///
   /// @return
   ///     The size of the trace data effectively read by the API call.
   //------------------------------------------------------------------
public:
   //------------------------------------------------------------------
   /// Stop the tracing instance. Stopping the trace will also
   /// lead to deletion of any gathered trace data.
   ///
   /// @param[out] error
   ///     An error explaining what went wrong.
   ///
   /// @param[in] thread_id
-  ///     The user id could map to a tracing instance for a thread
+  ///     The trace id could map to a tracing instance for a thread
   ///     or could also map to a group of threads being traced with
   ///     the same trace options. A thread_id is normally optional
   ///     except in the case of tracing a complete process and tracing
   ///     needs to switched off on a particular thread.
   ///     A situation could occur where initially a thread (lets say
-  ///     thread A) is being individually traced with a particular uid
-  ///     and then tracing is started on the complete process, in this
-  ///     case thread A will continue without any change. All newly
-  ///     spawned threads would be traced with the uid of the process.
+  ///     thread A) is being individually traced with a particular
+  ///     trace id and then tracing is started on the complete
+  ///     process, in this case thread A will continue without any
+  ///     change. All newly spawned threads would be traced with the
+  ///     trace id of the process.
   ///     Now if the StopTrace API is called for the whole process,
   ///     thread A will not be stopped and must be stopped separately.
   //------------------------------------------------------------------
   void StopTrace(SBError &error,
                  lldb::tid_t thread_id = LLDB_INVALID_THREAD_ID);
 
   //------------------------------------------------------------------
   /// Get the trace configuration being used for the trace instance.

include/lldb/Core/TraceOptions.h

 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "lldb/Core/StructuredData.h"
 
 namespace lldb_private {
 class TraceOptions {
 public:
-  TraceOptions()
-      : m_trace_params(new StructuredData::Dictionary()) {}
+  TraceOptions() : m_trace_params(new StructuredData::Dictionary()) {}
 
   const StructuredData::DictionarySP &getTraceParams() const {
     return m_trace_params;
   }
 
   lldb::TraceType getType() const { return m_type; }
 
   uint64_t getTraceBufferSize() const { return m_trace_buffer_size; }
 
   uint64_t getMetaDataBufferSize() const { return m_meta_data_buffer_size; }
 
   void setTraceParams(const StructuredData::DictionarySP &dict_obj) {
     m_trace_params = dict_obj;
   }
 
   void setType(lldb::TraceType type) { m_type = type; }
 
   void setTraceBufferSize(uint64_t size) { m_trace_buffer_size = size; }
 
   void setMetaDataBufferSize(uint64_t size) { m_meta_data_buffer_size = size; }
 
   void setThreadID(lldb::tid_t thread_id) { m_thread_id = thread_id; }
 
-  lldb::tid_t getThreadID() { return m_thread_id; }
+  lldb::tid_t getThreadID() const { return m_thread_id; }
 
 private:
   lldb::TraceType m_type;
   uint64_t m_trace_buffer_size;
   uint64_t m_meta_data_buffer_size;
   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;
 };
 }
 
 #endif // liblldb_TraceOptions_h_

include/lldb/Host/common/NativeProcessProtocol.h

 //===-- NativeProcessProtocol.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NativeProcessProtocol_h_
 #define liblldb_NativeProcessProtocol_h_
 
+#include "lldb/Core/TraceOptions.h"
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MemoryBuffer.h"
public:
   ///
   /// @return
   ///     An error object indicating if the operation succeeded,
   ///     and if not, what error occurred.
   //------------------------------------------------------------------
   static Status Attach(lldb::pid_t pid, NativeDelegate &native_delegate,
                        MainLoop &mainloop, NativeProcessProtocolSP &process_sp);
 
+  //------------------------------------------------------------------
+  /// 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;
+  }
+
+  //------------------------------------------------------------------
+  /// StopTracing API as the name suggests stops a tracing instance.
+  ///
+  /// @param[in] uid
+  ///     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 uid,
+                           lldb::tid_t thread = LLDB_INVALID_THREAD_ID) {
+    return Status("Not implemented");
+  }
+
+  //------------------------------------------------------------------
+  /// This API provides the trace data collected in the form of raw
+  /// data.
+  ///
+  /// @param[in] uid thread
+  ///     The uid and thread provide the context for the trace
+  ///     instance.
+  ///
+  /// @param[in] buffer
+  ///     The buffer provides the destination buffer where the trace
+  ///     data would be read to. The buffer should be truncated to the
+  ///     filled length by this function.
+  ///
+  /// @param[in] offset
+  ///     There is possibility to read partially the trace data from
+  ///     a specified offset where in such cases the buffer provided
+  ///     may be smaller than the internal trace collection container.
+  ///
+  /// @return
+  ///     The size of the data actually read.
+  //------------------------------------------------------------------
+  virtual Status GetData(lldb::user_id_t uid, lldb::tid_t thread,
+                         llvm::MutableArrayRef<uint8_t> &buffer,
+                         size_t offset = 0) {
+    return Status("Not implemented");
+  }
+
+  //------------------------------------------------------------------
+  /// 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 uid, lldb::tid_t thread,
+                             llvm::MutableArrayRef<uint8_t> &buffer,
+                             size_t offset = 0) {
+    return Status("Not implemented");
+  }
+
+  //------------------------------------------------------------------
+  /// API to query the TraceOptions for a given user id
+  ///
+  /// @param[in] uid
+  ///     The user id of the tracing instance.
+  ///
+  /// @param[in] config
+  ///     The thread id of the tracing instance, in case configuration
+  ///     for a specific thread is needed should be specified in the
+  ///     config.
+  ///
+  /// @param[out] error
+  ///     Status indicates what went wrong.
+  ///
+  /// @param[out] config
+  ///     The actual configuration being used for tracing.
+  //------------------------------------------------------------------
+  virtual Status GetTraceConfig(lldb::user_id_t uid, TraceOptions &config) {
+    return Status("Not implemented");
+  }
+
 protected:
   lldb::pid_t m_pid;
 
   std::vector<NativeThreadProtocolSP> m_threads;
   lldb::tid_t m_current_thread_id;
   mutable std::recursive_mutex m_threads_mutex;
 
   lldb::StateType m_state;
   mutable std::recursive_mutex m_state_mutex;
 
   lldb_private::ExitType m_exit_type;
   int m_exit_status;
   std::string m_exit_description;
   std::recursive_mutex m_delegates_mutex;
   std::vector<NativeDelegate *> m_delegates;
   NativeBreakpointList m_breakpoint_list;
   NativeWatchpointList m_watchpoint_list;
   HardwareBreakpointMap m_hw_breakpoints_map;
   int m_terminal_fd;
   uint32_t m_stop_id;
 
   // Set of signal numbers that LLDB directly injects back to inferior
   // without stopping it.
   llvm::DenseSet<int> m_signals_to_ignore;
 
protected:
   // -----------------------------------------------------------
   // Static helper methods for derived classes.
   // -----------------------------------------------------------
   static Status ResolveProcessArchitecture(lldb::pid_t pid, ArchSpec &arch);
 
 private:
   void SynchronouslyNotifyProcessStateChanged(lldb::StateType state);
 };
-}
+} // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessProtocol_h_

include/lldb/Target/Process.h

   /// trace instance.
   /// The handling of erroneous or unsupported configuration is left
   /// to the trace technology implementations in the server, as they
   /// could be returned as an error, or rounded to a valid
   /// configuration to start tracing. In the later case the
   /// GetTraceConfig should supply the actual used trace
   /// configuration.
   //------------------------------------------------------------------
-  virtual lldb::user_id_t StartTrace(lldb::TraceOptionsSP &options,
+  virtual lldb::user_id_t StartTrace(const TraceOptions &options,
                                      Status &error) {
     error.SetErrorString("Not implemented");
     return LLDB_INVALID_UID;
   }
 
   //------------------------------------------------------------------
   /// Stops the tracing instance leading to deletion of the trace
   /// data. The tracing instance is identified by the user_id which
   /// is obtained when tracing was started from the StartTrace.
   /// In case tracing of the complete process needs to be stopped
   /// the thread_id should be set to LLDB_INVALID_THREAD_ID.
   /// In the other case that tracing on an individual thread needs
   /// to be stopped a thread_id can be supplied.
   //------------------------------------------------------------------
-  virtual void StopTrace(lldb::user_id_t uid, lldb::tid_t thread_id,
-                         Status &error) {
-    error.SetErrorString("Not implemented");
+  virtual Status StopTrace(lldb::user_id_t uid, lldb::tid_t thread_id) {
+    return Status("Not implemented");
   }
 
   //------------------------------------------------------------------
   /// Provides the trace data as raw bytes. A buffer needs to be
   /// supplied to copy the trace data. The exact behavior of this API
   /// may vary across trace technology, as some may support partial
   /// reading of the trace data from a specified offset while some
   /// may not. The thread_id should be used to select a particular
   /// thread for trace extraction.
   //------------------------------------------------------------------
-  virtual size_t GetData(lldb::user_id_t uid, lldb::tid_t thread_id,
-                         Status &error, void *buf, size_t size,
+  virtual Status GetData(lldb::user_id_t uid, lldb::tid_t thread_id,
+                         llvm::MutableArrayRef<uint8_t> &buffer,
                          size_t offset = 0) {
-    error.SetErrorString("Not implemented");
-    return 0;
+    return Status("Not implemented");
   }
 
   //------------------------------------------------------------------
   /// Similar API as above except for obtaining meta data
   //------------------------------------------------------------------
-  virtual size_t GetMetaData(lldb::user_id_t uid, lldb::tid_t thread_id,
-                             Status &error, void *buf, size_t size,
+  virtual Status GetMetaData(lldb::user_id_t uid, lldb::tid_t thread_id,
+                             llvm::MutableArrayRef<uint8_t> &buffer,
                              size_t offset = 0) {
-    error.SetErrorString("Not implemented");
-    return 0;
+    return Status("Not implemented");
   }
 
   //------------------------------------------------------------------
   /// API to obtain the trace configuration used by a trace instance.
   /// Configurations that may be specific to some trace technology
   /// should be stored in the custom parameters. The options are
   /// transported to the server, which shall interpret accordingly.
   /// The thread_id can be specified in the options to obtain the
   /// configuration used by a specific thread. The thread_id specified
   /// should also match the uid otherwise an error will be returned.
   //------------------------------------------------------------------
-  virtual void GetTraceConfig(lldb::user_id_t uid, Status &error,
-                              lldb::TraceOptionsSP &options) {
-    error.SetErrorString("Not implemented");
-    return;
+  virtual Status GetTraceConfig(lldb::user_id_t uid, TraceOptions &options) {
+    return Status("Not implemented");
   }
 
 protected:
   void SetState(lldb::EventSP &event_sp);
 
   lldb::StateType GetPrivateState();
 
   //------------------------------------------------------------------

include/lldb/Utility/StringExtractor.h

uint64_t GetHexWithFixedSize(uint32_t byte_size, bool little_endian,
                                uint64_t fail_value);
 
   size_t GetHexByteString(std::string &str);
 
   size_t GetHexByteStringFixedLength(std::string &str, uint32_t nibble_length);
 
   size_t GetHexByteStringTerminatedBy(std::string &str, char terminator);
 
+  bool ConsumeFront(const llvm::StringRef &str);
+
   const char *Peek() {
     if (m_index < m_packet.size())
       return m_packet.c_str() + m_index;
     return nullptr;
   }
 
 protected:
   bool fail() {

source/API/SBProcess.cpp

lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options,
   error.Clear();
   SBTrace trace_instance;
   trace_instance.SetSP(process_sp);
   lldb::user_id_t uid = LLDB_INVALID_UID;
 
   if (!process_sp) {
     error.SetErrorString("invalid process");
   } else {
-
-    uid = process_sp->StartTrace(options.m_traceoptions_sp, error.ref());
+    uid = process_sp->StartTrace(*(options.m_traceoptions_sp), error.ref());
     trace_instance.SetTraceUID(uid);
-    LLDB_LOG(log, "SBProcess::returned uid - %" PRIx64, uid);
+    LLDB_LOG(log, "SBProcess::returned uid - {0}", uid);
   }
   return trace_instance;
 }
 
 void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
   if (out == NULL)
     return;
 

source/API/SBTrace.cpp

 //===-- SBTrace.cpp ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Utility/Log.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Utility/Log.h"
 
 #include "lldb/API/SBTrace.h"
 #include "lldb/API/SBTraceOptions.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 class TraceImpl {
 public:
   lldb::user_id_t uid;
 };
 
 lldb::ProcessSP SBTrace::GetSP() const { return m_opaque_wp.lock(); }
 
 size_t SBTrace::GetTraceData(SBError &error, void *buf, size_t size,
                              size_t offset, lldb::tid_t thread_id) {
-  size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size);
   error.Clear();
 
   if (!process_sp) {
     error.SetErrorString("invalid process");
   } else {
-    bytes_read = process_sp->GetData(GetTraceUID(), thread_id, error.ref(), buf,
-                                     size, offset);
-    LLDB_LOG(log, "SBTrace::bytes_read - %" PRIx64, bytes_read);
+    error.SetError(
+        process_sp->GetData(GetTraceUID(), thread_id, buffer, offset));
+    LLDB_LOG(log, "SBTrace::bytes_read - {0}", buffer.size());
   }
-  return bytes_read;
+  return buffer.size();
 }
 
 size_t SBTrace::GetMetaData(SBError &error, void *buf, size_t size,
                             size_t offset, lldb::tid_t thread_id) {
-  size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size);
   error.Clear();
 
   if (!process_sp) {
     error.SetErrorString("invalid process");
   } else {
 
-    bytes_read = process_sp->GetMetaData(GetTraceUID(), thread_id, error.ref(),
-                                         buf, size, offset);
-    LLDB_LOG(log, "SBTrace::bytes_read - %" PRIx64, bytes_read);
+    error.SetError(
+        process_sp->GetMetaData(GetTraceUID(), thread_id, buffer, offset));
+    LLDB_LOG(log, "SBTrace::bytes_read - {0}", buffer.size());
   }
-  return bytes_read;
+  return buffer.size();
 }
 
 void SBTrace::StopTrace(SBError &error, lldb::tid_t thread_id) {
   ProcessSP process_sp(GetSP());
   error.Clear();
 
   if (!process_sp) {
     error.SetErrorString("invalid process");
     return;
   }
-  process_sp->StopTrace(GetTraceUID(), thread_id, error.ref());
+  error.SetError(process_sp->StopTrace(GetTraceUID(), thread_id));
 }
 
 void SBTrace::GetTraceConfig(SBTraceOptions &options, SBError &error) {
   ProcessSP process_sp(GetSP());
   error.Clear();
 
   if (!process_sp) {
     error.SetErrorString("invalid process");
   } else {
-    process_sp->GetTraceConfig(GetTraceUID(), error.ref(),
-                               options.m_traceoptions_sp);
+    error.SetError(process_sp->GetTraceConfig(GetTraceUID(),
+                                              *(options.m_traceoptions_sp)));
   }
 }
 
 lldb::user_id_t SBTrace::GetTraceUID() {
   if (m_trace_impl_sp)
     return m_trace_impl_sp->uid;
   return LLDB_INVALID_UID;
 }

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

 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Utility/StreamGDBRemote.h"
 
 #include "llvm/ADT/Optional.h"
 
 namespace lldb_private {
 namespace process_gdb_remote {
 
 class GDBRemoteCommunicationClient : public GDBRemoteClientBase {
 public:
public:
   /// Configure a StructuredData feature on the remote end.
   ///
   /// @see \b Process::ConfigureStructuredData(...) for details.
   //------------------------------------------------------------------
   Status
   ConfigureRemoteStructuredData(const ConstString &type_name,
                                 const StructuredData::ObjectSP &config_sp);
 
+  lldb::user_id_t SendStartTracePacket(const TraceOptions &options,
+                                       Status &error);
+
+  Status SendStopTracePacket(lldb::user_id_t uid, lldb::tid_t thread_id);
+
+  Status SendGetDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id,
+                           llvm::MutableArrayRef<uint8_t> &buffer,
+                           size_t offset = 0);
+
+  Status SendGetMetaDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id,
+                               llvm::MutableArrayRef<uint8_t> &buffer,
+                               size_t offset = 0);
+
+  Status SendGetTraceConfigPacket(lldb::user_id_t uid, TraceOptions &options);
+
 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;
bool DecodeProcessInfoResponse(StringExtractorGDBRemote &response,
                                  ProcessInstanceInfo &process_info);
 
   void OnRunPacketSent(bool first) override;
 
   PacketResult SendThreadSpecificPacketAndWaitForResponse(
       lldb::tid_t tid, StreamString &&payload,
       StringExtractorGDBRemote &response, bool send_async);
 
+  Status SendGetTraceDataPacket(StreamGDBRemote &packet, lldb::user_id_t uid,
+                                lldb::tid_t thread_id,
+                                llvm::MutableArrayRef<uint8_t> &buffer,
+                                size_t offset);
+
 private:
   DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationClient);
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // liblldb_GDBRemoteCommunicationClient_h_

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

 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/JSON.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
-#include "lldb/Utility/StreamGDBRemote.h"
 #include "lldb/Utility/StreamString.h"
 
 // Project includes
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "Utility/StringExtractorGDBRemote.h"
 #include "lldb/Host/Config.h"
 
bool GDBRemoteCommunicationClient::SyncThreadState(lldb::tid_t tid) {
   StreamString packet;
   StringExtractorGDBRemote response;
   packet.Printf("QSyncThreadState:%4.4" PRIx64 ";", tid);
   return SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
              GDBRemoteCommunication::PacketResult::Success &&
          response.IsOKResponse();
 }
 
+lldb::user_id_t
+GDBRemoteCommunicationClient::SendStartTracePacket(const TraceOptions &options,
+                                                   Status &error) {
+  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+  lldb::user_id_t ret_uid = LLDB_INVALID_UID;
+
+  StreamGDBRemote escaped_packet;
+  escaped_packet.PutCString("jTraceStart:");
+
+  StructuredData::Dictionary json_packet;
+  json_packet.AddIntegerItem("type", options.getType());
+  json_packet.AddIntegerItem("buffersize", options.getTraceBufferSize());
+  json_packet.AddIntegerItem("metabuffersize", options.getMetaDataBufferSize());
+
+  if (options.getThreadID() != LLDB_INVALID_THREAD_ID)
+    json_packet.AddIntegerItem("threadid", options.getThreadID());
+
+  StructuredData::DictionarySP custom_params = options.getTraceParams();
+  if (custom_params)
+    json_packet.AddItem("params", custom_params);
+
+  StreamString json_string;
+  json_packet.Dump(json_string, false);
+  escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
+
+  StringExtractorGDBRemote response;
+  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
+                                   true) ==
+      GDBRemoteCommunication::PacketResult::Success) {
+    if (!response.IsNormalResponse()) {
+      error.SetError(response.GetError(), eErrorTypeGeneric);
+      LLDB_LOG(log, "Target does not support Tracing");
+    } else {
+      ret_uid = response.GetHexMaxU64(false, LLDB_INVALID_UID);
+    }
+  } else {
+    LLDB_LOG(log, "failed to send packet");
+    error.SetErrorStringWithFormat("failed to send packet: '%s'",
+                                   escaped_packet.GetData());
+  }
+  return ret_uid;
+}
+
+Status
+GDBRemoteCommunicationClient::SendStopTracePacket(lldb::user_id_t uid,
+                                                  lldb::tid_t thread_id) {
+  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+  StringExtractorGDBRemote response;
+  Status error;
+
+  StructuredData::Dictionary json_packet;
+  StreamGDBRemote escaped_packet;
+  StreamString json_string;
+  escaped_packet.PutCString("jTraceStop:");
+
+  json_packet.AddIntegerItem("traceid", uid);
+
+  if (thread_id != LLDB_INVALID_THREAD_ID)
+    json_packet.AddIntegerItem("threadid", thread_id);
+
+  json_packet.Dump(json_string, false);
+
+  escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
+
+  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
+                                   true) ==
+      GDBRemoteCommunication::PacketResult::Success) {
+    if (!response.IsOKResponse()) {
+      error.SetError(response.GetError(), eErrorTypeGeneric);
+      LLDB_LOG(log, "stop tracing failed");
+    }
+  } else {
+    LLDB_LOG(log, "failed to send packet");
+    error.SetErrorStringWithFormat(
+        "failed to send packet: '%s' with error '%d'", escaped_packet.GetData(),
+        response.GetError());
+  }
+  return error;
+}
+
+Status GDBRemoteCommunicationClient::SendGetDataPacket(
+    lldb::user_id_t uid, lldb::tid_t thread_id,
+    llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
+  StreamGDBRemote escaped_packet;
+  escaped_packet.PutCString("jTraceBufferRead:");
+  return SendGetTraceDataPacket(escaped_packet, uid, thread_id, buffer, offset);
+}
+
+Status GDBRemoteCommunicationClient::SendGetMetaDataPacket(
+    lldb::user_id_t uid, lldb::tid_t thread_id,
+    llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
+  StreamGDBRemote escaped_packet;
+  escaped_packet.PutCString("jTraceMetaRead:");
+  return SendGetTraceDataPacket(escaped_packet, uid, thread_id, buffer, offset);
+}
+
+Status
+GDBRemoteCommunicationClient::SendGetTraceConfigPacket(lldb::user_id_t uid,
+                                                       TraceOptions &options) {
+  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+  StringExtractorGDBRemote response;
+  Status error;
+
+  StreamString json_string;
+  StreamGDBRemote escaped_packet;
+  escaped_packet.PutCString("jTraceConfigRead:");
+
+  StructuredData::Dictionary json_packet;
+  json_packet.AddIntegerItem("traceid", uid);
+
+  if (options.getThreadID() != LLDB_INVALID_THREAD_ID)
+    json_packet.AddIntegerItem("threadid", options.getThreadID());
+
+  json_packet.Dump(json_string, false);
+  escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
+
+  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
+                                   true) ==
+      GDBRemoteCommunication::PacketResult::Success) {
+    if (response.IsNormalResponse()) {
+      uint64_t type = std::numeric_limits<uint64_t>::max();
+      uint64_t buffersize = std::numeric_limits<uint64_t>::max();
+      uint64_t metabuffersize = std::numeric_limits<uint64_t>::max();
+
+      auto json_object = StructuredData::ParseJSON(response.Peek());
+
+      if (!json_object ||
+          json_object->GetType() != StructuredData::Type::eTypeDictionary) {
+        error.SetErrorString("Invalid Configuration obtained");
+        return error;
+      }
+
+      auto json_dict = json_object->GetAsDictionary();
+
+      json_dict->GetValueForKeyAsInteger<uint64_t>("metabuffersize",
+                                                   metabuffersize);
+      options.setMetaDataBufferSize(metabuffersize);
+
+      json_dict->GetValueForKeyAsInteger<uint64_t>("buffersize", buffersize);
+      options.setTraceBufferSize(buffersize);
+
+      json_dict->GetValueForKeyAsInteger<uint64_t>("type", type);
+      options.setType(static_cast<lldb::TraceType>(type));
+
+      StructuredData::ObjectSP custom_params_sp =
+          json_dict->GetValueForKey("params");
+      if (custom_params_sp) {
+        if (custom_params_sp->GetType() !=
+            StructuredData::Type::eTypeDictionary) {
+          error.SetErrorString("Invalid Configuration obtained");
+          return error;
+        } else
+          options.setTraceParams(
+              static_pointer_cast<StructuredData::Dictionary>(
+                  custom_params_sp));
+      }
+    } else {
+      error.SetError(response.GetError(), eErrorTypeGeneric);
+    }
+  } else {
+    LLDB_LOG(log, "failed to send packet");
+    error.SetErrorStringWithFormat("failed to send packet: '%s'",
+                                   escaped_packet.GetData());
+  }
+  return error;
+}
+
+Status GDBRemoteCommunicationClient::SendGetTraceDataPacket(
+    StreamGDBRemote &packet, lldb::user_id_t uid, lldb::tid_t thread_id,
+    llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
+  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+  Status error;
+
+  StructuredData::Dictionary json_packet;
+
+  json_packet.AddIntegerItem("traceid", uid);
+  json_packet.AddIntegerItem("offset", offset);
+  json_packet.AddIntegerItem("buffersize", buffer.size());
+
+  if (thread_id != LLDB_INVALID_THREAD_ID)
+    json_packet.AddIntegerItem("threadid", thread_id);
+
+  StreamString json_string;
+  json_packet.Dump(json_string, false);
+
+  packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
+  StringExtractorGDBRemote response;
+  if (SendPacketAndWaitForResponse(packet.GetString(), response, true) ==
+      GDBRemoteCommunication::PacketResult::Success) {
+    if (response.IsNormalResponse()) {
+      size_t filled_size = response.GetHexBytesAvail(buffer);
+      buffer = llvm::MutableArrayRef<uint8_t>(buffer.data(), filled_size);
+    } else {
+      error.SetError(response.GetError(), eErrorTypeGeneric);
+      buffer = buffer.slice(buffer.size());
+    }
+  } else {
+    LLDB_LOG(log, "failed to send packet");
+    error.SetErrorStringWithFormat("failed to send packet: '%s'",
+                                   packet.GetData());
+    buffer = buffer.slice(buffer.size());
+  }
+  return error;
+}
+
 bool GDBRemoteCommunicationClient::GetModuleInfo(
     const FileSpec &module_file_spec, const lldb_private::ArchSpec &arch_spec,
     ModuleSpec &module_spec) {
   if (!m_supports_qModuleInfo)
     return false;
 
   std::string module_path = module_file_spec.GetPath(false);
   if (module_path.empty())

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

protected:
   PacketResult Handle_z(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_s(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qXfer_auxv_read(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_QSaveRegisterState(StringExtractorGDBRemote &packet);
 
+  PacketResult Handle_jTraceStart(StringExtractorGDBRemote &packet);
+
+  PacketResult Handle_jTraceRead(StringExtractorGDBRemote &packet);
+
+  PacketResult Handle_jTraceStop(StringExtractorGDBRemote &packet);
+
+  PacketResult Handle_jTraceConfigRead(StringExtractorGDBRemote &packet);
+
   PacketResult Handle_QRestoreRegisterState(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_vAttach(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_D(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qThreadStopInfo(StringExtractorGDBRemote &packet);
 

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

void GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers() {
   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_Z,
                                 &GDBRemoteCommunicationServerLLGS::Handle_Z);
   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_z,
                                 &GDBRemoteCommunicationServerLLGS::Handle_z);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_QPassSignals,
       &GDBRemoteCommunicationServerLLGS::Handle_QPassSignals);
 
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_jTraceStart,
+      &GDBRemoteCommunicationServerLLGS::Handle_jTraceStart);
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_jTraceBufferRead,
+      &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead);
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_jTraceMetaRead,
+      &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead);
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_jTraceStop,
+      &GDBRemoteCommunicationServerLLGS::Handle_jTraceStop);
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_jTraceConfigRead,
+      &GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead);
+
   RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k,
                         [this](StringExtractorGDBRemote packet, Status &error,
                                bool &interrupt, bool &quit) {
                           quit = true;
                           return this->Handle_k(packet);
                         });
 }
 
while (true) {
     case eConnectionStatusInterrupted:
     case eConnectionStatusTimedOut:
       return;
     }
   }
 }
 
 GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_jTraceStart(
+    StringExtractorGDBRemote &packet) {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+  // Fail if we don't have a current process.
+  if (!m_debugged_process_sp ||
+      (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
+    return SendErrorResponse(68);
+
+  if (!packet.ConsumeFront("jTraceStart:"))
+    return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
+
+  TraceOptions options;
+  uint64_t type = std::numeric_limits<uint64_t>::max();
+  uint64_t buffersize = std::numeric_limits<uint64_t>::max();
+  lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
+  uint64_t metabuffersize = std::numeric_limits<uint64_t>::max();
+
+  auto json_object = StructuredData::ParseJSON(packet.Peek());
+
+  if (!json_object ||
+      json_object->GetType() != StructuredData::Type::eTypeDictionary)
+    return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
+
+  auto json_dict = json_object->GetAsDictionary();
+
+  json_dict->GetValueForKeyAsInteger<uint64_t>("metabuffersize",
+                                               metabuffersize);
+  options.setMetaDataBufferSize(metabuffersize);
+
+  json_dict->GetValueForKeyAsInteger<uint64_t>("buffersize", buffersize);
+  options.setTraceBufferSize(buffersize);
+
+  json_dict->GetValueForKeyAsInteger<uint64_t>("type", type);
+  options.setType(static_cast<lldb::TraceType>(type));
+
+  json_dict->GetValueForKeyAsInteger<uint64_t>("threadid", tid);
+  options.setThreadID(tid);
+
+  StructuredData::ObjectSP custom_params_sp =
+      json_dict->GetValueForKey("params");
+  if (custom_params_sp &&
+      custom_params_sp->GetType() != StructuredData::Type::eTypeDictionary)
+    return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
+
+  options.setTraceParams(
+      static_pointer_cast<StructuredData::Dictionary>(custom_params_sp));
+
+  if (buffersize == std::numeric_limits<uint64_t>::max() ||
+      type != lldb::TraceType::eTraceTypeProcessorTrace) {
+    LLDB_LOG(log, "Ill formed packet buffersize = {0} type = {1}", buffersize,
+             type);
+    return SendIllFormedResponse(packet, "JTrace:start: Ill formed packet ");
+  }
+
+  Status error;
+  lldb::user_id_t uid = LLDB_INVALID_UID;
+  uid = m_debugged_process_sp->StartTrace(options, error);
+  LLDB_LOG(log, "uid is {0} , error is {1}", uid, error.GetError());
+  if (error.Fail())
+    return SendErrorResponse(error.GetError());
+
+  StreamGDBRemote response;
+  response.Printf("%" PRIx64, uid);
+  return SendPacketNoLock(response.GetString());
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_jTraceStop(
+    StringExtractorGDBRemote &packet) {
+  // Fail if we don't have a current process.
+  if (!m_debugged_process_sp ||
+      (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
+    return SendErrorResponse(68);
+
+  if (!packet.ConsumeFront("jTraceStop:"))
+    return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
+
+  lldb::user_id_t uid = LLDB_INVALID_UID;
+  lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
+
+  auto json_object = StructuredData::ParseJSON(packet.Peek());
+
+  if (!json_object ||
+      json_object->GetType() != StructuredData::Type::eTypeDictionary)
+    return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
+
+  auto json_dict = json_object->GetAsDictionary();
+
+  if (!json_dict->GetValueForKeyAsInteger<lldb::user_id_t>("traceid", uid))
+    return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
+
+  json_dict->GetValueForKeyAsInteger<lldb::tid_t>("threadid", tid);
+
+  Status error = m_debugged_process_sp->StopTrace(uid, tid);
+
+  if (error.Fail())
+    return SendErrorResponse(error.GetError());
+
+  return SendOKResponse();
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead(
+    StringExtractorGDBRemote &packet) {
+
+  // Fail if we don't have a current process.
+  if (!m_debugged_process_sp ||
+      (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
+    return SendErrorResponse(68);
+
+  if (!packet.ConsumeFront("jTraceConfigRead:"))
+    return SendIllFormedResponse(packet,
+                                 "jTraceConfigRead: Ill formed packet ");
+
+  lldb::user_id_t uid = LLDB_INVALID_UID;
+  lldb::tid_t threadid = LLDB_INVALID_THREAD_ID;
+
+  auto json_object = StructuredData::ParseJSON(packet.Peek());
+
+  if (!json_object ||
+      json_object->GetType() != StructuredData::Type::eTypeDictionary)
+    return SendIllFormedResponse(packet,
+                                 "jTraceConfigRead: Ill formed packet ");
+
+  auto json_dict = json_object->GetAsDictionary();
+
+  if (!json_dict->GetValueForKeyAsInteger<lldb::user_id_t>("traceid", uid))
+    return SendIllFormedResponse(packet,
+                                 "jTraceConfigRead: Ill formed packet ");
+
+  json_dict->GetValueForKeyAsInteger<lldb::tid_t>("threadid", threadid);
+
+  TraceOptions options;
+  StreamGDBRemote response;
+
+  options.setThreadID(threadid);
+  Status error = m_debugged_process_sp->GetTraceConfig(uid, options);
+
+  if (error.Fail())
+    return SendErrorResponse(error.GetError());
+
+  StreamGDBRemote escaped_response;
+  StructuredData::Dictionary json_packet;
+
+  json_packet.AddIntegerItem("type", options.getType());
+  json_packet.AddIntegerItem("buffersize", options.getTraceBufferSize());
+  json_packet.AddIntegerItem("metabuffersize", options.getMetaDataBufferSize());
+
+  StructuredData::DictionarySP custom_params = options.getTraceParams();
+  if (custom_params)
+    json_packet.AddItem("params", custom_params);
+
+  StreamString json_string;
+  json_packet.Dump(json_string, false);
+  escaped_response.PutEscapedBytes(json_string.GetData(),
+                                   json_string.GetSize());
+  return SendPacketNoLock(escaped_response.GetString());
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_jTraceRead(
+    StringExtractorGDBRemote &packet) {
+
+  // Fail if we don't have a current process.
+  if (!m_debugged_process_sp ||
+      (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
+    return SendErrorResponse(68);
+
+  enum PacketType { MetaData, BufferData };
+  PacketType tracetype = MetaData;
+
+  if (packet.ConsumeFront("jTraceBufferRead:"))
+    tracetype = BufferData;
+  else if (packet.ConsumeFront("jTraceMetaRead:"))
+    tracetype = MetaData;
+  else {
+    return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
+  }
+
+  lldb::user_id_t uid = LLDB_INVALID_UID;
+
+  size_t byte_count = std::numeric_limits<size_t>::max();
+  lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
+  size_t offset = std::numeric_limits<size_t>::max();
+
+  auto json_object = StructuredData::ParseJSON(packet.Peek());
+
+  if (!json_object ||
+      json_object->GetType() != StructuredData::Type::eTypeDictionary)
+    return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
+
+  auto json_dict = json_object->GetAsDictionary();
+
+  if (!json_dict->GetValueForKeyAsInteger<lldb::user_id_t>("traceid", uid) ||
+      !json_dict->GetValueForKeyAsInteger<uint64_t>("offset", offset) ||
+      !json_dict->GetValueForKeyAsInteger<uint64_t>("buffersize", byte_count))
+    return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
+
+  json_dict->GetValueForKeyAsInteger<lldb::tid_t>("threadid", tid);
+
+  // Allocate the response buffer.
+  uint8_t *buffer = new (std::nothrow) uint8_t[byte_count];
+  if (buffer == nullptr)
+    return SendErrorResponse(0x78);
+
+  StreamGDBRemote response;
+  Status error;
+  llvm::MutableArrayRef<uint8_t> buf(buffer, byte_count);
+
+  if (tracetype == BufferData)
+    error = m_debugged_process_sp->GetData(uid, tid, buf, offset);
+  else if (tracetype == MetaData)
+    error = m_debugged_process_sp->GetMetaData(uid, tid, buf, offset);
+
+  if (error.Fail())
+    return SendErrorResponse(error.GetError());
+
+  for (size_t i = 0; i < buf.size(); ++i)
+    response.PutHex8(buf[i]);
+
+  StreamGDBRemote escaped_response;
+  escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
+  return SendPacketNoLock(escaped_response.GetString());
+}
+
+GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo(
     StringExtractorGDBRemote &packet) {
   // Fail if we don't have a current process.
   if (!m_debugged_process_sp ||
       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
     return SendErrorResponse(68);
 
   lldb::pid_t pid = m_debugged_process_sp->GetID();
 
   if (pid == LLDB_INVALID_PROCESS_ID)
     return SendErrorResponse(1);
 
   ProcessInstanceInfo proc_info;
   if (!Host::GetProcessInfo(pid, proc_info))
     return SendErrorResponse(1);
 
   StreamString response;
   CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qC(StringExtractorGDBRemote &packet) {
   // Fail if we don't have a current process.
   if (!m_debugged_process_sp ||
       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
     return SendErrorResponse(68);
 
   // Make sure we set the current thread so g and p packets return
   // the data the gdb will expect.
   lldb::tid_t tid = m_debugged_process_sp->GetCurrentThreadID();
   SetCurrentThreadID(tid);
 
GDBRemoteCommunicationServerLLGS::Handle_k(StringExtractorGDBRemote &packet) {
   }
 
   Status error = m_debugged_process_sp->Kill();
   if (error.Fail() && log)
     log->Printf("GDBRemoteCommunicationServerLLGS::%s Failed to kill debugged "
                 "process %" PRIu64 ": %s",
                 __FUNCTION__, m_debugged_process_sp->GetID(),
                 error.AsCString());
 
   // No OK response for kill packet.
   // return SendOKResponse ();
   return PacketResult::Success;
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("QSetDisableASLR:"));
   if (packet.GetU32(0))
     m_process_launch_info.GetFlags().Set(eLaunchFlagDisableASLR);
   else
     m_process_launch_info.GetFlags().Clear(eLaunchFlagDisableASLR);
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("QSetWorkingDir:"));
   std::string path;
   packet.GetHexByteString(path);
   m_process_launch_info.SetWorkingDirectory(FileSpec{path, true});
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir(

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

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ThreadSafeValue.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
+#include "lldb/Utility/StreamGDBRemote.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringExtractor.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-private-forward.h"
 
 #include "GDBRemoteCommunicationClient.h"
 #include "GDBRemoteRegisterContext.h"
 
public:
 
   //----------------------------------------------------------------------
   // Process Watchpoints
   //----------------------------------------------------------------------
   Status EnableWatchpoint(Watchpoint *wp, bool notify = true) override;
 
   Status DisableWatchpoint(Watchpoint *wp, bool notify = true) override;
 
   Status GetWatchpointSupportInfo(uint32_t &num) override;
 
+  lldb::user_id_t StartTrace(const TraceOptions &options,
+                             Status &error) override;
+
+  Status StopTrace(lldb::user_id_t uid, lldb::tid_t thread_id) override;
+
+  Status GetData(lldb::user_id_t uid, lldb::tid_t thread_id,
+                 llvm::MutableArrayRef<uint8_t> &buffer,
+                 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;
+
+  Status GetTraceConfig(lldb::user_id_t uid, TraceOptions &options) override;
+
   Status GetWatchpointSupportInfo(uint32_t &num, bool &after) override;
 
   bool StartNoticingNewThreads() override;
 
   bool StopNoticingNewThreads() override;
 
   GDBRemoteCommunicationClient &GetGDBRemote() { return m_gdb_comm; }
 
   Status SendEventData(const char *data) override;
 
   //----------------------------------------------------------------------

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

if (error.Success()) {
           new EventDataBytes(packet.GetString().data(), packet.GetSize()));
 
     } else
       SetExitStatus(-1, error.AsCString());
   }
   return error;
 }
 
+lldb::user_id_t ProcessGDBRemote::StartTrace(const TraceOptions &options,
+                                             Status &error) {
+  return m_gdb_comm.SendStartTracePacket(options, error);
+}
+
+Status ProcessGDBRemote::StopTrace(lldb::user_id_t uid, lldb::tid_t thread_id) {
+  return m_gdb_comm.SendStopTracePacket(uid, thread_id);
+}
+
+Status ProcessGDBRemote::GetData(lldb::user_id_t uid, lldb::tid_t thread_id,
+                                 llvm::MutableArrayRef<uint8_t> &buffer,
+                                 size_t offset) {
+  return m_gdb_comm.SendGetDataPacket(uid, thread_id, buffer, offset);
+}
+
+Status ProcessGDBRemote::GetMetaData(lldb::user_id_t uid, lldb::tid_t thread_id,
+                                     llvm::MutableArrayRef<uint8_t> &buffer,
+                                     size_t offset) {
+  return m_gdb_comm.SendGetMetaDataPacket(uid, thread_id, buffer, offset);
+}
+
+Status ProcessGDBRemote::GetTraceConfig(lldb::user_id_t uid,
+                                        TraceOptions &options) {
+  return m_gdb_comm.SendGetTraceConfigPacket(uid, options);
+}
+
 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();

source/Utility/StringExtractor.cpp

while (m_index < m_packet.size() && ::isxdigit(m_packet[m_index])) {
 
       ++m_index;
       ++nibble_count;
     }
   }
   return result;
 }
 
+bool StringExtractor::ConsumeFront(const llvm::StringRef &str) {
+  llvm::StringRef S = GetStringRef();
+  if (!S.startswith(str))
+    return false;
+  else
+    m_index += str.size();
+  return true;
+}
+
 size_t StringExtractor::GetHexBytes(llvm::MutableArrayRef<uint8_t> dest,
                                     uint8_t fail_fill_value) {
   size_t bytes_extracted = 0;
   while (!dest.empty() && GetBytesLeft() > 0) {
     dest[0] = GetHexU8(fail_fill_value);
     if (!IsGood())
       break;
     ++bytes_extracted;

source/Utility/StringExtractorGDBRemote.h

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

source/Utility/StringExtractorGDBRemote.cpp

case 'q':
 
     case 'X':
       if (PACKET_STARTS_WITH("qXfer:auxv:read::"))
         return eServerPacketType_qXfer_auxv_read;
       break;
     }
     break;
 
   case 'j':
     if (PACKET_STARTS_WITH("jModulesInfo:"))
       return eServerPacketType_jModulesInfo;
     if (PACKET_MATCHES("jSignalsInfo"))
       return eServerPacketType_jSignalsInfo;
     if (PACKET_MATCHES("jThreadsInfo"))
       return eServerPacketType_jThreadsInfo;
+    if (PACKET_STARTS_WITH("jTraceBufferRead:"))
+      return eServerPacketType_jTraceBufferRead;
+    if (PACKET_STARTS_WITH("jTraceConfigRead:"))
+      return eServerPacketType_jTraceConfigRead;
+    if (PACKET_STARTS_WITH("jTraceMetaRead:"))
+      return eServerPacketType_jTraceMetaRead;
+    if (PACKET_STARTS_WITH("jTraceStart:"))
+      return eServerPacketType_jTraceStart;
+    if (PACKET_STARTS_WITH("jTraceStop:"))
+      return eServerPacketType_jTraceStop;
     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;

unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

 //===-- GDBRemoteCommunicationClientTest.cpp --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include <future>
 
 #include "GDBRemoteTestUtils.h"
 
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/StructuredData.h"
+#include "lldb/Core/TraceOptions.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/DataBuffer.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 using namespace lldb_private::process_gdb_remote;
 using namespace lldb_private;
 using namespace lldb;
TEST_F(GDBRemoteCommunicationClientTest, GetMemoryRegionInfoInvalidResponse) {
   MemoryRegionInfo region_info;
   std::future<Status> result = std::async(std::launch::async, [&] {
     return client.GetMemoryRegionInfo(addr, region_info);
   });
 
   HandlePacket(server, "qMemoryRegionInfo:4000", "start:4000;size:0000;");
   EXPECT_FALSE(result.get().Success());
 }
+
+TEST_F(GDBRemoteCommunicationClientTest, SendStartTracePacket) {
+  TestClient client;
+  MockServer server;
+  Connect(client, server);
+  if (HasFailure())
+    return;
+
+  TraceOptions options;
+  Status error;
+
+  options.setType(lldb::TraceType::eTraceTypeProcessorTrace);
+  options.setMetaDataBufferSize(8192);
+  options.setTraceBufferSize(8192);
+  options.setThreadID(0x23);
+
+  StructuredData::DictionarySP custom_params =
+      std::make_shared<StructuredData::Dictionary>();
+  custom_params->AddStringItem("tracetech", "intel-pt");
+  custom_params->AddIntegerItem("psb", 0x01);
+
+  options.setTraceParams(custom_params);
+
+  std::future<lldb::user_id_t> result = std::async(std::launch::async, [&] {
+    return client.SendStartTracePacket(options, error);
+  });
+
+  const char *expected_packet =
+      R"(jTraceStart:{"buffersize" : 8192,"metabuffersize" : 8192,"params" : {"psb" : 1,"tracetech" : "intel-pt"},"threadid" : 35,"type" : 1})";
+  HandlePacket(server, expected_packet, "1");
+  ASSERT_TRUE(error.Success());
+  ASSERT_EQ(result.get(), 1);
+
+  error.Clear();
+  result = std::async(std::launch::async, [&] {
+    return client.SendStartTracePacket(options, error);
+  });
+
+  HandlePacket(server, expected_packet, "E23");
+  ASSERT_EQ(result.get(), LLDB_INVALID_UID);
+  ASSERT_FALSE(error.Success());
+}
+
+TEST_F(GDBRemoteCommunicationClientTest, SendStopTracePacket) {
+  TestClient client;
+  MockServer server;
+  Connect(client, server);
+  if (HasFailure())
+    return;
+
+  lldb::tid_t thread_id = 0x23;
+  lldb::user_id_t trace_id = 3;
+
+  std::future<Status> result = std::async(std::launch::async, [&] {
+    return client.SendStopTracePacket(trace_id, thread_id);
+  });
+
+  const char *expected_packet = R"(jTraceStop:{"threadid" : 35,"traceid" : 3})";
+  HandlePacket(server, expected_packet, "OK");
+  ASSERT_TRUE(result.get().Success());
+
+  result = std::async(std::launch::async, [&] {
+    return client.SendStopTracePacket(trace_id, thread_id);
+  });
+
+  HandlePacket(server, expected_packet, "E23");
+  ASSERT_FALSE(result.get().Success());
+}
+
+TEST_F(GDBRemoteCommunicationClientTest, SendGetDataPacket) {
+  TestClient client;
+  MockServer server;
+  Connect(client, server);
+  if (HasFailure())
+    return;
+
+  lldb::tid_t thread_id = 0x23;
+  lldb::user_id_t trace_id = 3;
+
+  uint8_t buf[32] = {};
+  llvm::MutableArrayRef<uint8_t> buffer(buf, 32);
+  size_t offset = 0;
+
+  std::future<Status> result = std::async(std::launch::async, [&] {
+    return client.SendGetDataPacket(trace_id, thread_id, buffer, offset);
+  });
+
+  const char *expected_packet =
+      R"(jTraceBufferRead:{"buffersize" : 32,"offset" : 0,"threadid" : 35,"traceid" : 3})";
+  HandlePacket(server, expected_packet, "123456");
+  ASSERT_TRUE(result.get().Success());
+  ASSERT_EQ(buffer.size(), 3);
+  ASSERT_EQ(buf[0], 0x12);
+  ASSERT_EQ(buf[1], 0x34);
+  ASSERT_EQ(buf[2], 0x56);
+
+  llvm::MutableArrayRef<uint8_t> buffer2(buf, 32);
+  result = std::async(std::launch::async, [&] {
+    return client.SendGetDataPacket(trace_id, thread_id, buffer2, offset);
+  });
+
+  HandlePacket(server, expected_packet, "E23");
+  ASSERT_FALSE(result.get().Success());
+  ASSERT_EQ(buffer2.size(), 0);
+}
+
+TEST_F(GDBRemoteCommunicationClientTest, SendGetMetaDataPacket) {
+  TestClient client;
+  MockServer server;
+  Connect(client, server);
+  if (HasFailure())
+    return;
+
+  lldb::tid_t thread_id = 0x23;
+  lldb::user_id_t trace_id = 3;
+
+  uint8_t buf[32] = {};
+  llvm::MutableArrayRef<uint8_t> buffer(buf, 32);
+  size_t offset = 0;
+
+  std::future<Status> result = std::async(std::launch::async, [&] {
+    return client.SendGetMetaDataPacket(trace_id, thread_id, buffer, offset);
+  });
+
+  const char *expected_packet =
+      R"(jTraceMetaRead:{"buffersize" : 32,"offset" : 0,"threadid" : 35,"traceid" : 3})";
+  HandlePacket(server, expected_packet, "123456");
+  ASSERT_TRUE(result.get().Success());
+  ASSERT_EQ(buffer.size(), 3);
+  ASSERT_EQ(buf[0], 0x12);
+  ASSERT_EQ(buf[1], 0x34);
+  ASSERT_EQ(buf[2], 0x56);
+
+  llvm::MutableArrayRef<uint8_t> buffer2(buf, 32);
+  result = std::async(std::launch::async, [&] {
+    return client.SendGetMetaDataPacket(trace_id, thread_id, buffer2, offset);
+  });
+
+  HandlePacket(server, expected_packet, "E23");
+  ASSERT_FALSE(result.get().Success());
+  ASSERT_EQ(buffer2.size(), 0);
+}
+
+TEST_F(GDBRemoteCommunicationClientTest, SendGetTraceConfigPacket) {
+  TestClient client;
+  MockServer server;
+  Connect(client, server);
+  if (HasFailure())
+    return;
+
+  lldb::tid_t thread_id = 0x23;
+  lldb::user_id_t trace_id = 3;
+  TraceOptions options;
+  options.setThreadID(thread_id);
+
+  std::future<Status> result = std::async(std::launch::async, [&] {
+    return client.SendGetTraceConfigPacket(trace_id, options);
+  });
+
+  const char *expected_packet =
+      R"(jTraceConfigRead:{"threadid" : 35,"traceid" : 3})";
+  const char *response =
+      R"({"buffersize" : 8192,"params" : {"psb" : 1,"tracetech" : "intel-pt"}],"metabuffersize" : 8192,"threadid" : 35,"type" : 1}])";
+  HandlePacket(server, expected_packet, response);
+  ASSERT_TRUE(result.get().Success());
+  ASSERT_EQ(options.getTraceBufferSize(), 8192);
+  ASSERT_EQ(options.getMetaDataBufferSize(), 8192);
+  ASSERT_EQ(options.getType(), 1);
+
+  auto custom_params = options.getTraceParams();
+
+  uint64_t psb_value;
+  llvm::StringRef trace_tech_value;
+
+  ASSERT_TRUE(custom_params);
+  ASSERT_EQ(custom_params->GetType(), StructuredData::Type::eTypeDictionary);
+  ASSERT_TRUE(
+      custom_params->GetValueForKeyAsInteger<uint64_t>("psb", psb_value));
+  ASSERT_EQ(psb_value, 1);
+  ASSERT_TRUE(
+      custom_params->GetValueForKeyAsString("tracetech", trace_tech_value));
+  ASSERT_STREQ(trace_tech_value.data(), "intel-pt");
+
+  // Checking error response.
+  std::future<Status> result2 = std::async(std::launch::async, [&] {
+    return client.SendGetTraceConfigPacket(trace_id, options);
+  });
+
+  HandlePacket(server, expected_packet, "E23");
+  ASSERT_FALSE(result2.get().Success());
+
+  // Wrong JSON as response.
+  std::future<Status> result3 = std::async(std::launch::async, [&] {
+    return client.SendGetTraceConfigPacket(trace_id, options);
+  });
+
+  const char *incorrect_json =
+      R"("buffersize" : 8192,"params" : {"psb" : 1,"tracetech" : "intel-pt"}],"metabuffersize" : 8192,"threadid" : 35,"type" : 1}])";
+  HandlePacket(server, expected_packet, incorrect_json);
+  ASSERT_FALSE(result3.get().Success());
+
+  // Wrong JSON as custom_params.
+  std::future<Status> result4 = std::async(std::launch::async, [&] {
+    return client.SendGetTraceConfigPacket(trace_id, options);
+  });
+
+  const char *incorrect_custom_params =
+      R"({"buffersize" : 8192,"params" : "psb" : 1,"tracetech" : "intel-pt"}],"metabuffersize" : 8192,"threadid" : 35,"type" : 1}])";
+  HandlePacket(server, expected_packet, incorrect_custom_params);
+  ASSERT_FALSE(result4.get().Success());
+}
 No newline at end of file