[intel-pt][trace] Implement a "get supported trace type" packet

[wallace]

Summary

Depends on D89283.

The goal of this packet (jTraceGetSupportedType) is to be able to query the gdb-server for the tracing technology that can work for the current debuggeer, which can make the user experience simpler but allowing the user to simply type

thread trace start

to start tracing the current thread without even telling the debugger to use "intel-pt", for example. Similarly, thread trace start [args...] would accept args beloging to the working trace type.

Also, if the user typed

help thread trace start

We could directly show the help information of the trace type that is supported for the target, or mention instead that no tracing is supported, if that's the case.

I added some simple tests, besides, when I ran this on my machine with intel-pt support, I got

$ process plugin packet send "jTraceSupportedType"                                                                                        
  packet: jTraceSupportedType
response: {"description":"Intel Processor Trace","pluginName":"intel-pt"}

On a machine without intel-pt support, I got

$ process plugin packet send "jTraceSupportedType"                                                                                        
  packet: jTraceSupportedType
response: E00;

[DavidSpickett]

lldb/docs/lldb-gdb-remote.txt

245

Saying lldb-enumerations.h might save someone some grepping time, also saying that it should be in decimal.

Can you clarify what TraceType means? Is it:
The way the trace is generated/stored, like on chip vs off chip
The thing you're tracging, e.g. instructions or power usage
Specific trace versions e.g intel pt, arm coresight (pretty sure it's not this one)

If there's the possibility of one system having multiple types then the packet should at least have the format to hold them, even though we only read the first one.

Which your code already does since:
1,2;
Would stop parsing at the ',' anyway, but worth noting if it's relevant.

254

What is the AAAAA for?

[labath]

lldb/docs/lldb-gdb-remote.txt

245

The j in these trace packets was supposed to refer to the fact they are json-formatted. Using json for this is overkill, but that means I'm now torn between wanting to preserve the j consistency and the jTrace consistency. If this were returning a list of types, using json for that might not be totally unreasonable, and would let us avoid this dilemma :P.

254

That's the extended (textual) error message -- lldb and gdb have independently invented incompatible formats for that (I share a blame it that :/).

This style of presentation is consistent with the other jTrace packets, though I am not sure it's that helpful really -- we support the extended error on any response packet and we don't document that always. (Also the error message will only be sent if the client actually signals support for it.)

(In fact, when I look at the implementation, I see that it will _never_ send the textual error message.)

[wallace]

Thanks for the feedback! Some changes:

• I'm no longer showing the AAAAA in the documentation, as @labath pointed out that I was not using it, and, in fact, there's no need to use it.
• I'm now using a json array to represent the return value of the packet. It's going to be a 0 or 1 element array for, probably, many years, but it makes the packet more robust and can use the j prefix sensically.
• I improved the documentation, addressing @DavidSpickett questions. In short, a TraceType corresponds to a high-level Trace plugin that can provide LLDB with a list of instructions executed by a given program.
• I renamed eTraceTypeProcessorTrace to eTraceTypeIntelProcessorTrace (notice the Intel word) to disambiguate.

[clayborg]

So I know Intel had gone and done some tracing support in an external kind of way before. This patch is preparing to use this functionality by asking for the supported trace types. I am not a fan of a global enumeration in lldb-enumerations.h controlling the tracing type and having to have GDB servers have to respond using these LLDB specific enumeration values. It would be nice if we can query the GDB server for the supported trace types and have them respond with a string for the tracing type. See my inlined comments for what was thinking. I also think that a GDB server should respond with a single kind of supported tracing, see inlined comments for more details.

lldb/docs/lldb-gdb-remote.txt

245

I'm not a fan of using the enumeration in lldb-enumerations.h here if we can avoid it. See my comment below about giving a name to the tracing types.

247–248

So my main question is: should a lldb-server be able to return multiple tracing types? I would vote to always respond with the best tracing that is available and ensure that lldb-server can only enable on kind of trace. I know IntelPT can be supported along with some other format that only saves that few branches (ABL?), but if IntelPT is available, should we respond with only IntelPT being available? It would be also nice to have a name for each returned tracing type instead of just a number? Maybe making the response a dictionary of tracing integer type to name would be nice?:

{ 1: "intel-pt", 2: "abl" }

I would rather we return just a single entry here if possible. If we can, this might be better as a dictionary response:

{ "name": "intel-pt", "trace-type": 1 }

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

395–399

So here we are returning only 1 tracing type? That is fine if we switch the reply to the jTraceSupportedTypes to be a single value, otherwise this would need to be an array. Not a fan of having to use enumerations from lldb-enumerations.h, so I would rather return a ConstString with the plug-in name if possible.

lldb/include/lldb/Target/Process.h

2555

Again only one is fine if we switch the jTraceSupportedTypes to return one value.

lldb/include/lldb/lldb-enumerations.h

776

enumerations in this header file cannot change as they are part of the API for LLDB, so we can't rename this. You can add a comment letting people know about this, but you can't rename this.

[wallace]

After a sync up with Greg, I've followed his recommedations and did the following changes:

• Kept the packet as a simple packet returning one single trace type. However, now the response is a json object {"pluginName": <name>, "description": <text>}. This makes it very explicit that the name returned should match a Trace plug-in name, making future implementations simpler.

We analyzed the existing jTrace packets, which were done several years ago by Intel and we realized that they are not generic enough for the way we are implementing Trace plugin. Those packets are too intel-pt specific and we'll be patching them to make them more generic. For example, the "metabuffersize" is something specific to intel pt.

We also don't like the fact that it's using a public enum TraceType. We are now trying to use instead a string name, which will be more user-friendly and will help connect different gdb-servers and Trace plug-ins.

• Removed the changes to the TraceType enum and the old intel pt plugin.

[wallace]

nit

[clayborg]

See inlined comments. Just some questions on wether we are going to reuse the other existing "tTrace*" packets, or if we are going to make new ones.

lldb/docs/lldb-gdb-remote.txt

249

Can't IntelPT exist on a machine but not be enabled? If so I would suggest adding a few more key values:

"enabled": <boolean>,
"enableInstructions": <string>

"enabled" would say if this tracing mechanism is currently installed and if it is enabled or not.
"enableInstructions" could clarify what you would have to do to enable this tracing feature, like run a "sudo" command, or enable a kernel module and reboot, etc.

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

3462

So are we going to reuse all of the other "jTrace*" packets and possibly expand their usage? If so, then this name is good. If we are going to make new packets for tracing then "jLLDBTraceSupportedType" might make more sense and all commands we would add would start with "jLLDBTrace".

[wallace]

lldb/docs/lldb-gdb-remote.txt

249

I was running some tests and checking the documentation on the kernel, and Intel PT is either available or not (from the OS perspective). There's no configuration to do, which leaves this case simple.

However, there are other situations like what you describe. If you want to use Intel PT on a VM, then you need to enable the corresponding capabilities on your VM software. This case would benefit from the fields you propose. Right now I wouldn't attempt to solve that, so I prefer not to add new fields. However, in the future, when that's needed, we can add these fields to the packet as it's a flexible json object.

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

3462

I'm glad you mention this. I'm thinking about using a completely new set of packets and document the existing ones as deprecated.

The old packets include:

• jTraceMetaRead -> it's confusing and not really useful for the current implementation. Even the external intel-pt plugin doesn't make use of it. It exposes the data gotten when invoking the SYS_perf_event_open syscall, which is too perf+linux only. It can be useful for getting more information out of the kernel, like some clock tracing, but nothing useful as of now.
• jTraceConfigRead -> instead of having it, jTraceStart could return that config once tracing has been enabled. That would avoid one round trip, as decoding can't happen anyway without this information.
• jTraceStop -> it expects a trace ID (which is intel-pt only in the current implementation), and an optional thread id. It could be simpler by just asking a list of thread ids, or none and then stop the entire process.
• jTraceStart -> it's expecting fields like metabuffersize, which don't make sense if we want to generalize this. It also returns a trace ID (which is intel-pt only). It could instead receive a trace-plugin name, a list of thread ids, a process id, and then a set of json params. Also, as mentioned above, it could return the jTraceConfig, making the api simpler.

Overall, I'd prefer to implement new packets in a very generic way. So I'll take your jLLDB prefix.

Btw, We could implement a generic data query packet

• jLLDBTraceQueryData -> which would receive a generic data query packet that would be handled by each trace type. It could return trace buffers, or the metadata from the jTraceMetaRead packet, or any plugin-specific data.

That would leave us with jLLDBTraceStart, jLLDBTraceStop, jLLDBTraceSupportedType and jLLDBTraceQueryData

[wallace]

• Renamed the packet to jLLDBTraceSupportedType following Greg's suggestion
• Also, marked the old trace packets as deprecated, to discourage their usage. I doubt anyone is using them, as in March I discovered that the external intel-pt plugin was broken for a long time, due to a wrong python setup and a broken decoder. I fixed it in https://reviews.llvm.org/D76872, and by doing that I noticed that no one was using it. I tried to contact the Intel folks that worked on that feature in 2017, but it seems they are not working on that any more. Interestingly, the gdb intel-pt plugin has been a little bit active these years.

[labath]

lldb/docs/lldb-gdb-remote.txt

247

Having lldb-server match the lldb trace plugin name seems a bit backward to me. I think it'd be more natural if the server reports a name for the technology it uses and then the client picks a plugin to go with that technology.

I think it's fine if the process of "picking a plugin" is implemented by matching the GetPluginName() string to the value returned here, so I don't think that the code needs to change in anyway (except maybe droping the word "plugin" from the field name?). My quibble is about how this is framed in the documentation -- I'd say this should be the source of truth and trace plugin should reference it instead of the other way around. (One reason for that could be that we can change the plugin matching logic in the client any time we want, but changing the packet format brings up compatibility concerns.)

247–248

If we're expecting that lldb-server will be able to capture multiple kinds of traces (on the same processor architecture), then (strongly) believe lldb-server should be able to return/enumerate all of them. I don't think lldb-server should be in the business of deciding what the user wants to do (like, he may want deliberately use the "inferior" technology so he can compare the performance/features of the two trace types, or whatever). Defaulting to the most advanced format is of course fine, but that could be done by listing that format first (or giving them an explicit priority, etc.).

That said, there is still a big if on that statement -- tracing technologies are complex beasts, so I'd be surprised if a single processor supports two technologies with feature sets that overlap well enough that they may be thrown into the same bag. However, I don't know much about processor traces and Greg's comment seems to imply that they do exist.

(It's also worth noting that it'd be fairly easy to extend this packed to (optionally) return a list of these dictionaries if that becomes needed.)

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

397

We now have an UnimplementedError class you can return here.

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

3462

Given the state the old intel plugin, I wouldn't be surprised if it was completely unused. As such I don't have a problem with new packets (if the old ones don't fit). However, I also don't want to carry the excess compatibility baggage for too long either. I'd say we should just delete all the old code as soon your implementation reaches rough feature parity (which shouldn't take long, as the old code didn't do much iirc).

[wallace]

• Use name instead of pluginName and UnimplementedError, as @labath suggested
• Still keep the packet returning one single trace technology. It'll be a long time until two technologies collide, but if that ever happens, we can extend the packet to return a list or a dictionary. As of now, the only technology that could potentially collide with intel-pt is LBR, which traces only the last 32 branches and is pretty much defunct in new applications, as Intel PT is actually the modern version of LBR. Arm has Coresight, Windows also has intel-pt. AMD has IBS. For now, I'm in favor of keeping it simple.

[labath]

Just some layering remarks. Other than that, I think this is fine.

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

17

You shouldn't include lldb/Target from here. We already have Utility/TraceOptions.h. Maybe TraceTypeInfo could go there instead?

lldb/include/lldb/Target/Process.h

2547–2548

This code shouldn't refer the the gdb packets. Theoretically we could have other process plugins supporting this.

lldb/include/lldb/Target/Trace.h

184–185 ↗

(On Diff #302630)

Neither should this.

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

60

the empty check is superfluous.

[wallace]

address issues

[clayborg]

lldb/docs/lldb-gdb-remote.txt

248

Should this specify that this name needs to match the name of the LLDB plug-in?

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

165–169

Mark as deprecated?

170

Maybe add a space to separate the above deprecated stuff from this new stuff

lldb/include/lldb/Utility/TraceOptions.h

21

We should specify that this needs to match the LLDB trace plug-in name on the header doc.

lldb/include/lldb/lldb-enumerations.h

772

Mark as deprecated?

[wallace]

Address all comments, specially improved the documentation requested by @clayborg.

[clayborg]

So down to just one question about the packet definition about if we should have an error code in JSON or if an error code even makes sense. Other than that this LGTM

lldb/docs/lldb-gdb-remote.txt

262

I know the deprecated trace packets allows an error code to be returned, but since we already have JSON being used here, I would be a shame to not return an error in the JSON with a string that is human readable instead of a EXX where XX are two hex digits. can we say the response is either:

{"name": <name>, "description", <description>}

or

{"error": <error-string>}

Or just have no error code? What would the error be able to tell us?

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

3462

I agree Pavel, lets remove the old code when we can.

[labath]

lldb/docs/lldb-gdb-remote.txt

262

An error response might be suitable in case the client sends this packet without a running process.

I think we just stick to the established error code format, which already contains provisions for returning textual errors. I don't believe any of our existing json packets use json-encoded errors...

[wallace]

Added a test that accounts for a custom error message from the gdb-server.
I decided to follow @labath's approach of using the existing error code format (;AAAAAAA). It works well and the GDBClient classes already have good support for that, specifically StringExtractorGDBRemote.h

[clayborg]

LGTM with the AAAAAAAA error string stuff included so we can get a nice string error message. Pavel, do you have anything?

[labath]

I didn't check all the details, but seems ok to me.

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

3465–3468

Use early exits to avoid nesting.

[stella.stamenova]

It looks like this broke the windows lldb buildbot:

http://lab.llvm.org:8011/#/builders/83/builds/693

[wallace]

@stella.stamenova I'm working on a fix right now.

lldb/docs/lldb-gdb-remote.txt

 //  they are not provided to lldb, lldb will likely need to send one to
 //  two packets per thread to fetch the data at every private stop.
 //----------------------------------------------------------------------
 
 send packet: QListThreadsInStopReply
 read packet: OK
 
 //----------------------------------------------------------------------
+// jLLDBTraceSupportedType
+//
+// 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.
+//----------------------------------------------------------------------
+
+send packet: jLLDBTraceSupportedType
+read packet: {"name": <name>, "description", <description>}/E<error code>
+
+//----------------------------------------------------------------------
 // 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

 //----------------------------------------------------------------------
 
 send packet: jTraceStart:{"type":<type>,"buffersize":<buffersize>}]
 read packet: <trace id>/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
 // jTraceStop:
 //
+// This packet is deprecated.
+//
 // 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 -

 //----------------------------------------------------------------------
 
 send packet: jTraceStop:{"traceid":<trace id>}]
 read packet: <OK response>/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
 // jTraceBufferRead:
 //
+// This packet is deprecated.
+//
 // 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 -

 //----------------------------------------------------------------------
 
 send packet: jTraceBufferRead:{"traceid":<trace id>,"offset":<byteoffset>,"buffersize":<byte_count>}]
 read packet: <binary trace data>/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
 // jTraceMetaRead:
 //
+// This packet is deprecated.
+//
 // BRIEF
 //  Similar Packet as above except it reads meta data.
 //----------------------------------------------------------------------
 
 /----------------------------------------------------------------------
 // jTraceConfigRead:
 //
+// This packet is deprecated.
+//
 // 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

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

 //===-- NativeProcessProtocol.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_HOST_COMMON_NATIVEPROCESSPROTOCOL_H
 #define LLDB_HOST_COMMON_NATIVEPROCESSPROTOCOL_H
 
 #include "NativeBreakpointList.h"
 #include "NativeThreadProtocol.h"
 #include "NativeWatchpointList.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/TraceOptions.h"
 #include "lldb/Utility/UnimplementedError.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
public:
   /// \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

 //===-- Process.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_PROCESS_H
 #define LLDB_TARGET_PROCESS_H
 
 #include "lldb/Host/Config.h"
 
 #include <limits.h>
 
 #include <chrono>
 #include <list>
 #include <memory>
 #include <mutex>
 #include <string>

 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/InstrumentationRuntime.h"
 #include "lldb/Target/Memory.h"
 #include "lldb/Target/QueueList.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Target/ThreadPlanStack.h"
+#include "lldb/Target/Trace.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Listener.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/TraceOptions.h"
+#include "lldb/Utility/UnimplementedError.h"
 #include "lldb/Utility/UserIDResolver.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
void PruneThreadPlans();
   /// server, which shall interpret accordingly. The thread_id can be
   /// specified in the options to obtain the configuration used by a specific
   /// thread. The thread_id specified should also match the uid otherwise an
   /// error will be returned.
   virtual Status GetTraceConfig(lldb::user_id_t uid, TraceOptions &options) {
     return Status("Not implemented");
   }
 
+  ///  Get the processor tracing type supported for this process.
+  ///  Responses might be different depending on the architecture and
+  ///  capabilities of the underlying OS.
+  ///
+  ///  \return
+  ///     The supported trace type or an \a llvm::Error if tracing is
+  ///     not supported for the inferior.
+  virtual llvm::Expected<TraceTypeInfo> GetSupportedTraceType() {
+    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:
   void SetState(lldb::EventSP &event_sp);
 

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

 //===-- StringExtractorGDBRemote.h ------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_STRINGEXTRACTORGDBREMOTE_H
 #define LLDB_UTILITY_STRINGEXTRACTORGDBREMOTE_H
 
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StringExtractor.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <string>
 
 #include <stddef.h>
 #include <stdint.h>
 
enum ServerPacketType {
     eServerPacketType_X,
     eServerPacketType_Z,
     eServerPacketType_z,
 
     eServerPacketType__M,
     eServerPacketType__m,
     eServerPacketType_notify, // '%' notification
 
     eServerPacketType_jTraceStart,
     eServerPacketType_jTraceBufferRead,
     eServerPacketType_jTraceMetaRead,
     eServerPacketType_jTraceStop,
     eServerPacketType_jTraceConfigRead,
+    eServerPacketType_jLLDBTraceSupportedType,
   };
 
   ServerPacketType GetServerPacketType() const;
 
   enum ResponseType { eUnsupported = 0, eAck, eNack, eError, eOK, eResponse };
 
   ResponseType GetResponseType() const;
 

lldb/include/lldb/Utility/TraceOptions.h

 //===-- TraceOptions.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_TRACEOPTIONS_H
 #define 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.
+  std::string name;
+  /// A description for the technology.
+  std::string description;
+};
+
 class TraceOptions {
 public:
   TraceOptions() : m_trace_params(new StructuredData::Dictionary()) {}
 
   const StructuredData::DictionarySP &getTraceParams() const {
     return m_trace_params;
   }
 
private:
   /// m_trace_params is meant to hold any custom parameters
   /// apart from meta buffer size and trace size.
   /// The interpretation of such parameters is left to
   /// the lldb-server.
   StructuredData::DictionarySP m_trace_params;
 };
 }
 
+namespace llvm {
+namespace json {
+
+bool fromJSON(const Value &value, lldb_private::TraceTypeInfo &info, Path path);
+
+} // namespace json
+} // namespace llvm
+
 #endif // LLDB_UTILITY_TRACEOPTIONS_H

lldb/include/lldb/lldb-enumerations.h

enum BasicType {
   eBasicTypeLongDoubleComplex,
   eBasicTypeObjCID,
   eBasicTypeObjCClass,
   eBasicTypeObjCSel,
   eBasicTypeNullPtr,
   eBasicTypeOther
 };
 
 enum TraceType {
   eTraceTypeNone = 0,
 
-  // Hardware Trace generated by the processor.
+  /// Intel Processor Trace
   eTraceTypeProcessorTrace
 };
 
 enum StructuredDataType {
   eStructuredDataTypeInvalid = -1,
   eStructuredDataTypeNull = 0,
   eStructuredDataTypeGeneric,
   eStructuredDataTypeArray,
   eStructuredDataTypeInteger,

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

 //===-- NativeProcessLinux.h ---------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NativeProcessLinux_H_
 #define liblldb_NativeProcessLinux_H_
 
 #include <csignal>
 #include <unordered_set>
 
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-types.h"
 
 #include "NativeThreadLinux.h"
Status GetData(lldb::user_id_t traceid, lldb::tid_t thread,
                  size_t offset = 0) override;
 
   Status GetMetaData(lldb::user_id_t traceid, lldb::tid_t thread,
                      llvm::MutableArrayRef<uint8_t> &buffer,
                      size_t offset = 0) override;
 
   Status GetTraceConfig(lldb::user_id_t traceid, TraceOptions &config) override;
 
+  virtual llvm::Expected<TraceTypeInfo> GetSupportedTraceType() override;
+
   // Interface used by NativeRegisterContext-derived classes.
   static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr = nullptr,
                               void *data = nullptr, size_t data_size = 0,
                               long *result = nullptr);
 
   bool SupportHardwareSingleStepping() const;
 
 protected:

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

if (!perf_monitor) {
       error = perf_monitor.takeError();
       return error;
     }
     error = (*perf_monitor).GetTraceConfig(config);
   }
   return error;
 }
 
+llvm::Expected<TraceTypeInfo> NativeProcessLinux::GetSupportedTraceType() {
+  if (ProcessorTraceMonitor::IsSupported())
+    return TraceTypeInfo{"intel-pt", "Intel Processor Trace"};
+  return NativeProcessProtocol::GetSupportedTraceType();
+}
+
 lldb::user_id_t
 NativeProcessLinux::StartTraceGroup(const TraceOptions &config,
                                            Status &error) {
 
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
   if (config.getType() != TraceType::eTraceTypeProcessorTrace)
     return LLDB_INVALID_UID;
 

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

 //===-- ProcessorTrace.h -------------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ProcessorTrace_H_
 #define liblldb_ProcessorTrace_H_
 
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/TraceOptions.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 
 #include <linux/perf_event.h>
 #include <sys/mman.h>
 #include <unistd.h>
class ProcessorTraceMonitor {
   ProcessorTraceMonitor()
       : m_mmap_meta(nullptr, munmap_delete(0)),
         m_mmap_aux(nullptr, munmap_delete(0)), m_fd(nullptr, file_close()),
         m_traceid(LLDB_INVALID_UID), m_thread_id(LLDB_INVALID_THREAD_ID){};
 
   void SetThreadID(lldb::tid_t tid) { m_thread_id = tid; }
 
 public:
+  static llvm::Expected<uint32_t> GetOSEventType();
+
+  static bool IsSupported();
+
   static Status GetCPUType(TraceOptions &config);
 
   static llvm::Expected<ProcessorTraceMonitorUP>
   Create(lldb::pid_t pid, lldb::tid_t tid, const TraceOptions &config,
          bool useProcessSettings);
 
   Status ReadPerfTraceAux(llvm::MutableArrayRef<uint8_t> &buffer,
                           size_t offset = 0);

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

 //===-- ProcessorTrace.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <algorithm>
 #include <fstream>
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MathExtras.h"
 
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "ProcessorTrace.h"
 #include "lldb/Host/linux/Support.h"
 
 #include <sys/ioctl.h>
 #include <sys/syscall.h>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace process_linux;
 using namespace llvm;
 
 lldb::user_id_t ProcessorTraceMonitor::m_trace_num = 1;
+const char *kOSEventIntelPTTypeFile =
+    "/sys/bus/event_source/devices/intel_pt/type";
 
 Status ProcessorTraceMonitor::GetTraceConfig(TraceOptions &config) const {
 #ifndef PERF_ATTR_SIZE_VER5
   llvm_unreachable("perf event not supported");
 #else
   Status error;
 
   config.setType(lldb::TraceType::eTraceTypeProcessorTrace);
   config.setMetaDataBufferSize(m_mmap_meta->data_size);
 
   config.setTraceBufferSize(m_mmap_meta->aux_size);
 
   error = GetCPUType(config);
 
   return error;
 #endif
 }
 
+Expected<uint32_t> ProcessorTraceMonitor::GetOSEventType() {
+  auto intel_pt_type_text =
+      llvm::MemoryBuffer::getFileAsStream(kOSEventIntelPTTypeFile);
+
+  if (!intel_pt_type_text)
+    return createStringError(inconvertibleErrorCode(),
+                             "Can't open the file '%s'",
+                             kOSEventIntelPTTypeFile);
+
+  uint32_t intel_pt_type = 0;
+  StringRef buffer = intel_pt_type_text.get()->getBuffer();
+  if (buffer.trim().getAsInteger(10, intel_pt_type))
+    return createStringError(
+        inconvertibleErrorCode(),
+        "The file '%s' has a invalid value. It should be an unsigned int.",
+        kOSEventIntelPTTypeFile);
+  return intel_pt_type;
+}
+
+bool ProcessorTraceMonitor::IsSupported() { return (bool)GetOSEventType(); }
+
 Status ProcessorTraceMonitor::StartTrace(lldb::pid_t pid, lldb::tid_t tid,
                                          const TraceOptions &config) {
 #ifndef PERF_ATTR_SIZE_VER5
   llvm_unreachable("perf event not supported");
 #else
   Status error;
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
 
#else
   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;
 
-  int intel_pt_type = 0;
-
-  auto ret = llvm::MemoryBuffer::getFileAsStream(
-      "/sys/bus/event_source/devices/intel_pt/type");
-  if (!ret) {
-    LLDB_LOG(log, "failed to open Config file");
-    return ret.getError();
-  }
+  Expected<uint32_t> intel_pt_type = GetOSEventType();
 
-  StringRef rest = ret.get()->getBuffer();
-  if (rest.empty() || rest.trim().getAsInteger(10, intel_pt_type)) {
-    LLDB_LOG(log, "failed to read Config file");
-    error.SetErrorString("invalid file");
+  if (!intel_pt_type) {
+    error = intel_pt_type.takeError();
     return error;
   }
 
-  rest.trim().getAsInteger(10, intel_pt_type);
-  LLDB_LOG(log, "intel pt type {0}", intel_pt_type);
-  attr.type = intel_pt_type;
+  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/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

 #include <string>
 #include <vector>
 
 #include "lldb/Host/File.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/GDBRemote.h"
 #include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/StructuredData.h"
+#include "lldb/Utility/TraceOptions.h"
 #if defined(_WIN32)
 #include "lldb/Host/windows/PosixApi.h"
 #endif
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
Status SendGetDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id,
                            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);
 
+  llvm::Expected<TraceTypeInfo> SendGetSupportedTraceType();
+
 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

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);
 }
 
+llvm::Expected<TraceTypeInfo>
+GDBRemoteCommunicationClient::SendGetSupportedTraceType() {
+  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
+
+  StreamGDBRemote escaped_packet;
+  escaped_packet.PutCString("jLLDBTraceSupportedType");
+
+  StringExtractorGDBRemote response;
+  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
+                                   true) ==
+      GDBRemoteCommunication::PacketResult::Success) {
+    if (response.IsNormalResponse()) {
+      if (llvm::Expected<TraceTypeInfo> type =
+              llvm::json::parse<TraceTypeInfo>(response.Peek()))
+        return *type;
+      else
+        return type.takeError();
+    } else
+      return response.GetStatus().ToError();
+  }
+  LLDB_LOG(log, "failed to send packet: jLLDBTraceSupportedType");
+  return llvm::createStringError(
+      llvm::inconvertibleErrorCode(),
+      "failed to send packet: jLLDBTraceSupportedType");
+}
+
 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/GDBRemoteCommunicationServerLLGS.h

 //===-- GDBRemoteCommunicationServerLLGS.h ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERLLGS_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERLLGS_H
 
 #include <mutex>
 #include <unordered_map>
 
 #include "lldb/Core/Communication.h"
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/lldb-private-forward.h"
 
 #include "GDBRemoteCommunicationServerCommon.h"
 
 class StringExtractorGDBRemote;
 
protected:
   PacketResult Handle_jTraceStart(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_jTraceRead(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_jTraceStop(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_jTraceConfigRead(StringExtractorGDBRemote &packet);
 
+  PacketResult Handle_jLLDBTraceSupportedType(StringExtractorGDBRemote &packet);
+
   PacketResult Handle_QRestoreRegisterState(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_vAttach(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_D(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qThreadStopInfo(StringExtractorGDBRemote &packet);
 

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

 //===-- GDBRemoteCommunicationServerLLGS.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 <errno.h>
 
 #include "lldb/Host/Config.h"
 
 
 #include <chrono>
 #include <cstring>
 #include <thread>
 
 #include "GDBRemoteCommunicationServerLLGS.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_jTraceMetaRead,
       &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_jTraceStop,
       &GDBRemoteCommunicationServerLLGS::Handle_jTraceStop);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_jTraceConfigRead,
       &GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead);
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_jLLDBTraceSupportedType,
+      &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupportedType);
 
   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_g,
                                 &GDBRemoteCommunicationServerLLGS::Handle_g);
 
   RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k,
                         [this](StringExtractorGDBRemote packet, Status &error,
                                bool &interrupt, bool &quit) {
                           quit = true;
GDBRemoteCommunicationServerLLGS::Handle_jTraceStop(
 
   if (error.Fail())
     return SendErrorResponse(error);
 
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupportedType(
+    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);
+
+  llvm::Expected<TraceTypeInfo> supported_trace_type =
+      m_debugged_process_up->GetSupportedTraceType();
+  if (!supported_trace_type)
+    return SendErrorResponse(Status(supported_trace_type.takeError()));
+
+  StreamGDBRemote escaped_response;
+  StructuredData::Dictionary json_packet;
+
+  json_packet.AddStringItem("name", supported_trace_type->name);
+  json_packet.AddStringItem("description", supported_trace_type->description);
+
+  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_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

 #define LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_PROCESSGDBREMOTE_H
 
 #include <atomic>
 #include <map>
 #include <mutex>
 #include <string>
 #include <vector>
 
 #include "lldb/Core/LoadedModuleInfoList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/ThreadSafeValue.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/ConstString.h"
public:
   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;
 
+  llvm::Expected<TraceTypeInfo> GetSupportedTraceType() 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

 //===-- ProcessGDBRemote.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
 
 #include <errno.h>
 #include <stdlib.h>
 #if LLDB_ENABLE_POSIX
 #include <netinet/in.h>
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <unistd.h>
Status ProcessGDBRemote::GetMetaData(lldb::user_id_t uid, lldb::tid_t thread_id,
   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);
 }
 
+llvm::Expected<TraceTypeInfo> ProcessGDBRemote::GetSupportedTraceType() {
+  return m_gdb_comm.SendGetSupportedTraceType();
+}
+
 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/Utility/CMakeLists.txt

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

lldb/source/Utility/StringExtractorGDBRemote.cpp

 //===-- StringExtractorGDBRemote.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 
 #include <ctype.h>
 #include <string.h>
 
 StringExtractorGDBRemote::ResponseType
 StringExtractorGDBRemote::GetResponseType() const {
   if (m_packet.empty())
     return eUnsupported;
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;
     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"
+
+using namespace lldb_private;
+
+namespace llvm {
+namespace json {
+
+bool fromJSON(const Value &value, TraceTypeInfo &info, Path path) {
+  ObjectMapper o(value, path);
+  if (!o)
+    return false;
+  o.map("description", info.description);
+  return o.map("name", info.name);
+}
+
+} // namespace json
+} // namespace llvm

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

 //===-- GDBRemoteCommunicationClientTest.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 "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h"
 #include "GDBRemoteTestUtils.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/TraceOptions.h"
 #include "lldb/lldb-enumerations.h"
if (XMLDocument::XMLEnabled()) {
     // In case we have XML support, this will also do a "qXfer:memory-map".
     // Preceeded by a query for supported extensions. Pretend we don't support
     // that.
     HandlePacket(server, testing::StartsWith("qSupported:"), "");
   }
   EXPECT_FALSE(result.get().Success());
 }
 
+TEST_F(GDBRemoteCommunicationClientTest, SendTraceSupportedTypePacket) {
+  // Success response
+  {
+    std::future<llvm::Expected<TraceTypeInfo>> result = std::async(
+        std::launch::async, [&] { return client.SendGetSupportedTraceType(); });
+
+    HandlePacket(
+        server, "jLLDBTraceSupportedType",
+        R"({"name":"intel-pt","description":"Intel Processor Trace"}])");
+
+    llvm::Expected<TraceTypeInfo> trace_type_or_err = result.get();
+    EXPECT_THAT_EXPECTED(trace_type_or_err, llvm::Succeeded());
+    ASSERT_STREQ(trace_type_or_err->name.c_str(), "intel-pt");
+    ASSERT_STREQ(trace_type_or_err->description.c_str(),
+                 "Intel Processor Trace");
+  }
+
+  // Error response - wrong json
+  {
+    std::future<llvm::Expected<TraceTypeInfo>> result = std::async(
+        std::launch::async, [&] { return client.SendGetSupportedTraceType(); });
+
+    HandlePacket(server, "jLLDBTraceSupportedType", R"({"type":"intel-pt"}])");
+
+    llvm::Expected<TraceTypeInfo> trace_type_or_err = result.get();
+    EXPECT_THAT_EXPECTED(trace_type_or_err, llvm::Failed());
+  }
+
+  // Error response
+  {
+    std::future<llvm::Expected<TraceTypeInfo>> result = std::async(
+        std::launch::async, [&] { return client.SendGetSupportedTraceType(); });
+
+    HandlePacket(server, "jLLDBTraceSupportedType", "E23");
+    llvm::Expected<TraceTypeInfo> trace_type_or_err = result.get();
+    ASSERT_THAT_EXPECTED(trace_type_or_err, llvm::Failed());
+  }
+}
+
 TEST_F(GDBRemoteCommunicationClientTest, SendStartTracePacket) {
   TraceOptions options;
   Status error;
 
   options.setType(lldb::TraceType::eTraceTypeProcessorTrace);
   options.setMetaDataBufferSize(8192);
   options.setTraceBufferSize(8192);
   options.setThreadID(0x23);