[lldb] [gdb-remote] Support getting siginfo via API

[mgorny]

Summary

Add Thread::GetSiginfo() and SBThread::GetSiginfo() methods to retrieve
the siginfo value from server.

[mgorny]

Add another test using FreeBSD siginfo_t, to make sure we select the platform correctly.

[labath]

Seems reasonable to me. Jim, do you have any thoughts on this?

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py

494

I'd probably factor the out the common parts into a helper fn, as these two tests only differ in constants.

[mgorny]

Add a common test function. Document the raw data. Include trapno check on FreeBSD.

That said, it just occurred to me that I need to add some packet indicating the architecture.

[mgorny]

I've forgotten that the architecture is inferred from target here. Added i386 test for completeness.

[mgorny]

Update following changes in GetSiginfoType() — notably stop relying on the SBPlatform API and update for new prototype.

[labath]

lldb/source/API/SBThread.cpp

1326–1334

It should be fine to chain these, relying on the fact that the SB methods on an empty object will return another empty object.

[mgorny]

lldb/source/API/SBThread.cpp

1326–1334

I suppose I could avoid process and switch to getting byte order from target but tbh I think the explicit error message for lack of process is worth keeping the split.

[jingham]

We don't return errors separately for any of the API's that return an SBValue. SBValue's carry their error with them (SBValue.GetError()) so it would be confusing to have two errors.

[mgorny]

In D118055#3276558, @jingham wrote:

We don't return errors separately for any of the API's that return an SBValue. SBValue's carry their error with them (SBValue.GetError()) so it would be confusing to have two errors.

I'm sorry but I can't figure out how to set the error inside SBValue. The only user-facing thing that seems to allow passing Status seems to be ValueObjectConstResult::Create() but it feels like it's not supposed to be used like this (and it doesn't seem to preserve my Status either).

[jingham]

Yes, you probably need to make another change, which is actually probably a good idea as well.

The immediate problem is that the default constructed SBValue is empty, it has a null ValueObjectSP, so until you somehow make it valid you can't get a valid error from it, in which to set your error string. By the time you've made a valid SBValue it's too late.

But I think actually you should fix this by having a

ValueObjectSP lldb_private::Thread::GetSiginfoValue()

then the SB API will just wrap that call. That way you can make a real ValueObject, with a real error, and return that at any stage.

That will fix your problem, but the real reason for doing this is that lldb_private code can't call back into the SB API's. So if anybody in lldb_private land needed the ValueObject that wrapped the Siginfo information, which is after all the handiest form in which to have it, they would be out of luck.

I didn't get a chance to review this, sorry about that. But in general, SB API's should not do any more work than is necessary to marshal the incoming arguments & figure out which lldb_private API to dispatch it to. Otherwise you've written code is going to end up getting duplicated somewhere (in a command or somewhere else it's needed...)

[mgorny]

Add Thread::GetSiginfoValue() to perform baseline value construction, and limit SBThread::GetSiginfo() to wrapping that. Return errors via ValueObjectConstResult.

[jingham]

Thanks for making that change! LGTM.

lldb/bindings/interface/SBThread.i

~SBThread();
     Takes no arguments, returns a bool.
     lldb may be able to detect that function calls should not be executed
     on a given thread at a particular point in time.  It is recommended that
     this is checked before performing an inferior function call on a given
     thread.") SafeToCallFunctions;
     bool
     SafeToCallFunctions ();
 
+    %feature("autodoc","
+    Retruns a SBValue object representing the siginfo for the current signal.
+    ") GetSiginfo;
+    lldb::SBValue
+    GetSiginfo(SBError &error);
+
     STRING_EXTENSION(SBThread)
 
 #ifdef SWIGPYTHON
     %pythoncode %{
         def __iter__(self):
             '''Iterate over all frames in a lldb.SBThread object.'''
             return lldb_iter(self, 'GetNumFrames', 'GetFrameAtIndex')
 

lldb/include/lldb/API/SBPlatform.h

public:
   /// \return
   ///     An lldb::SBEnvironment object which is a copy of the platform's
   ///     environment.
   SBEnvironment GetEnvironment();
 
 protected:
   friend class SBDebugger;
   friend class SBTarget;
+  friend class SBThread;
 
   lldb::PlatformSP GetSP() const;
 
   void SetSP(const lldb::PlatformSP &platform_sp);
 
   SBError ExecuteConnected(
       const std::function<lldb_private::Status(const lldb::PlatformSP &)>
           &func);
 
   lldb::PlatformSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBPLATFORM_H

lldb/include/lldb/API/SBTarget.h

protected:
   friend class SBFunction;
   friend class SBInstruction;
   friend class SBModule;
   friend class SBPlatform;
   friend class SBProcess;
   friend class SBSection;
   friend class SBSourceManager;
   friend class SBSymbol;
+  friend class SBThread;
   friend class SBValue;
   friend class SBVariablesOptions;
 
   // Constructors are private, use static Target::Create function to create an
   // instance of this class.
 
   lldb::TargetSP GetSP() const;
 

lldb/include/lldb/API/SBThread.h

public:
   uint32_t GetExtendedBacktraceOriginatingIndexID();
 
   SBValue GetCurrentException();
 
   SBThread GetCurrentExceptionBacktrace();
 
   bool SafeToCallFunctions();
 
+  SBValue GetSiginfo(SBError &error);
+
 private:
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBBreakpointCallbackBaton;
   friend class SBExecutionContext;
   friend class SBFrame;
   friend class SBProcess;
   friend class SBDebugger;

lldb/include/lldb/API/SBType.h

protected:
 
   void SetSP(const lldb::TypeImplSP &type_impl_sp);
 
   lldb::TypeImplSP m_opaque_sp;
 
   friend class SBFunction;
   friend class SBModule;
   friend class SBTarget;
+  friend class SBThread;
   friend class SBTypeEnumMember;
   friend class SBTypeEnumMemberList;
   friend class SBTypeNameSpecifier;
   friend class SBTypeMember;
   friend class SBTypeMemberFunction;
   friend class SBTypeList;
   friend class SBValue;
 

lldb/include/lldb/Target/Thread.h

 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/RegisterCheckpoint.h"
 #include "lldb/Target/StackFrameList.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/StructuredData.h"
+#include "lldb/Utility/UnimplementedError.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 #define LLDB_THREAD_MAX_STOP_EXC_DATA 8
 
 namespace lldb_private {
 
 class ThreadPlanStack;

   ///     The token needed by the SystemRuntime to create an extended backtrace.
   ///     LLDB_INVALID_ADDRESS is returned if no token is available.
   virtual uint64_t GetExtendedBacktraceToken() { return LLDB_INVALID_ADDRESS; }
 
   lldb::ValueObjectSP GetCurrentException();
 
   lldb::ThreadSP GetCurrentExceptionBacktrace();
 
+  virtual llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+  GetSiginfo(size_t max_size) const {
+    return llvm::make_error<UnimplementedError>();
+  }
+
 protected:
   friend class ThreadPlan;
   friend class ThreadList;
   friend class ThreadEventData;
   friend class StackFrameList;
   friend class StackFrame;
   friend class OperatingSystem;
 

lldb/source/API/SBThread.cpp

 
 lldb_private::Thread *SBThread::operator->() {
   return get();
 }
 
 lldb_private::Thread *SBThread::get() {
   return m_opaque_sp->GetThreadSP().get();
 }
+
+SBValue SBThread::GetSiginfo(SBError &error) {
+  LLDB_INSTRUMENT_VA(this, error);
+
+  SBValue value;
+  SBProcess process = GetProcess();
+  if (!process.IsValid()) {
+    error.SetErrorString("no process");
+    return value;
+  }
+  SBTarget target = process.GetTarget();
+  if (!target.IsValid()) {
+    error.SetErrorString("unable to get target");
+    return value;
+  }
+  SBPlatform platform = target.GetPlatform();
+  if (!platform.IsValid()) {
+    error.SetErrorString("unable to get platform");
+    return value;
+  }
+  CompilerType type = platform.GetSP()->GetSiginfoType(
+      target.GetSP()->GetArchitecture().GetTriple());
+  if (!type.IsValid()) {
+    error.SetErrorString("no siginfo_t for the platform");
+    return value;
+  }
+  llvm::Optional<uint64_t> type_size = type.GetByteSize(nullptr);
+  assert(type_size);
+  ThreadSP thread_sp = m_opaque_sp->GetThreadSP();
+  if (!thread_sp) {
+    error.SetErrorString("unable to get thread");
+    return value;
+  }
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> data =
+      thread_sp->GetSiginfo(type_size.getValue());
+  if (!data) {
+    error.SetErrorString(llvm::toString(data.takeError()).c_str());
+    return value;
+  }
+  SBData sb_data;
+  sb_data.SetData(error, data.get()->getBufferStart(),
+                  data.get()->getBufferSize(), process.GetByteOrder(), 0);
+  if (!sb_data.IsValid())
+    return value;
+
+  return target.CreateValueFromData("siginfo", sb_data, type);
+}

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

public:
   bool GetQPassSignalsSupported();
 
   bool GetAugmentedLibrariesSVR4ReadSupported();
 
   bool GetQXferFeaturesReadSupported();
 
   bool GetQXferMemoryMapReadSupported();
 
+  bool GetQXferSigInfoReadSupported();
+
   LazyBool SupportsAllocDeallocMemory() // const
   {
     // Uncomment this to have lldb pretend the debug server doesn't respond to
     // alloc/dealloc memory packets.
     // m_supports_alloc_dealloc_memory = lldb_private::eLazyBoolNo;
     return m_supports_alloc_dealloc_memory;
   }
 
protected:
   LazyBool m_supports_x = eLazyBoolCalculate;
   LazyBool m_avoid_g_packets = eLazyBoolCalculate;
   LazyBool m_supports_QSaveRegisterState = eLazyBoolCalculate;
   LazyBool m_supports_qXfer_auxv_read = eLazyBoolCalculate;
   LazyBool m_supports_qXfer_libraries_read = eLazyBoolCalculate;
   LazyBool m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate;
   LazyBool m_supports_qXfer_features_read = eLazyBoolCalculate;
   LazyBool m_supports_qXfer_memory_map_read = eLazyBoolCalculate;
+  LazyBool m_supports_qXfer_siginfo_read = eLazyBoolCalculate;
   LazyBool m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
   LazyBool m_supports_jThreadExtendedInfo = eLazyBoolCalculate;
   LazyBool m_supports_jLoadedDynamicLibrariesInfos = eLazyBoolCalculate;
   LazyBool m_supports_jGetSharedCacheInfo = eLazyBoolCalculate;
   LazyBool m_supports_QPassSignals = eLazyBoolCalculate;
   LazyBool m_supports_error_string_reply = eLazyBoolCalculate;
   LazyBool m_supports_multiprocess = eLazyBoolCalculate;
   LazyBool m_supports_memory_tagging = eLazyBoolCalculate;

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

 
 bool GDBRemoteCommunicationClient::GetQXferMemoryMapReadSupported() {
   if (m_supports_qXfer_memory_map_read == eLazyBoolCalculate) {
     GetRemoteQSupported();
   }
   return m_supports_qXfer_memory_map_read == eLazyBoolYes;
 }
 
+bool GDBRemoteCommunicationClient::GetQXferSigInfoReadSupported() {
+  if (m_supports_qXfer_siginfo_read == eLazyBoolCalculate) {
+    GetRemoteQSupported();
+  }
+  return m_supports_qXfer_siginfo_read == eLazyBoolYes;
+}
+
 uint64_t GDBRemoteCommunicationClient::GetRemoteMaxPacketSize() {
   if (m_max_packet_size == 0) {
     GetRemoteQSupported();
   }
   return m_max_packet_size;
 }
 
 bool GDBRemoteCommunicationClient::QueryNoAckModeSupported() {
if (!did_exec) {
     m_avoid_g_packets = eLazyBoolCalculate;
     m_supports_multiprocess = eLazyBoolCalculate;
     m_supports_qSaveCore = eLazyBoolCalculate;
     m_supports_qXfer_auxv_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate;
     m_supports_qXfer_features_read = eLazyBoolCalculate;
     m_supports_qXfer_memory_map_read = eLazyBoolCalculate;
+    m_supports_qXfer_siginfo_read = eLazyBoolCalculate;
     m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
     m_uses_native_signals = eLazyBoolCalculate;
     m_supports_qProcessInfoPID = true;
     m_supports_qfProcessInfo = true;
     m_supports_qUserName = true;
     m_supports_qGroupName = true;
     m_supports_qThreadStopInfo = true;
     m_supports_z0 = true;

 void GDBRemoteCommunicationClient::GetRemoteQSupported() {
   // Clear out any capabilities we expect to see in the qSupported response
   m_supports_qXfer_auxv_read = eLazyBoolNo;
   m_supports_qXfer_libraries_read = eLazyBoolNo;
   m_supports_qXfer_libraries_svr4_read = eLazyBoolNo;
   m_supports_augmented_libraries_svr4_read = eLazyBoolNo;
   m_supports_qXfer_features_read = eLazyBoolNo;
   m_supports_qXfer_memory_map_read = eLazyBoolNo;
+  m_supports_qXfer_siginfo_read = eLazyBoolNo;
   m_supports_multiprocess = eLazyBoolNo;
   m_supports_qEcho = eLazyBoolNo;
   m_supports_QPassSignals = eLazyBoolNo;
   m_supports_memory_tagging = eLazyBoolNo;
   m_supports_qSaveCore = eLazyBoolNo;
   m_uses_native_signals = eLazyBoolNo;
 
   m_max_packet_size = UINT64_MAX; // It's supposed to always be there, but if
for (llvm::StringRef x : llvm::split(response.GetStringRef(), ';')) {
         m_supports_qXfer_libraries_svr4_read = eLazyBoolYes; // implied
         m_supports_augmented_libraries_svr4_read = eLazyBoolYes;
       } else if (x == "qXfer:libraries:read+")
         m_supports_qXfer_libraries_read = eLazyBoolYes;
       else if (x == "qXfer:features:read+")
         m_supports_qXfer_features_read = eLazyBoolYes;
       else if (x == "qXfer:memory-map:read+")
         m_supports_qXfer_memory_map_read = eLazyBoolYes;
+      else if (x == "qXfer:siginfo:read+")
+        m_supports_qXfer_siginfo_read = eLazyBoolYes;
       else if (x == "qEcho")
         m_supports_qEcho = eLazyBoolYes;
       else if (x == "QPassSignals+")
         m_supports_QPassSignals = eLazyBoolYes;
       else if (x == "multiprocess+")
         m_supports_multiprocess = eLazyBoolYes;
       else if (x == "memory-tagging+")
         m_supports_memory_tagging = eLazyBoolYes;

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

public:
 
   lldb_private::LazyBool GetAssociatedWithLibdispatchQueue() override;
 
   void SetAssociatedWithLibdispatchQueue(
       lldb_private::LazyBool associated_with_libdispatch_queue) override;
 
   StructuredData::ObjectSP FetchThreadExtendedInfo() override;
 
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+  GetSiginfo(size_t max_size) const override;
+
 protected:
   friend class ProcessGDBRemote;
 
   std::string m_thread_name;
   std::string m_dispatch_queue_name;
   lldb::addr_t m_thread_dispatch_qaddr;
   lldb::addr_t m_dispatch_queue_t;
   lldb::QueueKind

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

 
 bool ThreadGDBRemote::CalculateStopInfo() {
   ProcessSP process_sp(GetProcess());
   if (process_sp)
     return static_cast<ProcessGDBRemote *>(process_sp.get())
         ->CalculateThreadStopInfo(this);
   return false;
 }
+
+llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+ThreadGDBRemote::GetSiginfo(size_t max_size) const {
+  ProcessSP process_sp(GetProcess());
+  if (!process_sp)
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "no process");
+  ProcessGDBRemote *gdb_process =
+      static_cast<ProcessGDBRemote *>(process_sp.get());
+  if (!gdb_process->m_gdb_comm.GetQXferSigInfoReadSupported())
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "qXfer:siginfo:read not supported");
+
+  llvm::Expected<std::string> response =
+      gdb_process->m_gdb_comm.ReadExtFeature("siginfo", "");
+  if (!response)
+    return response.takeError();
+
+  return llvm::MemoryBuffer::getMemBufferCopy(response.get());
+}

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py

def test_signal_lldb(self):
         self.runCmd("platform select remote-linux")
         target = self.createTarget("a.yaml")
         process = self.connect(target)
 
         self.assertEqual(process.threads[0].GetStopReason(),
                          lldb.eStopReasonSignal)
         self.assertEqual(process.threads[0].GetStopDescription(100),
                          'signal SIGUSR1')
+
+    def do_siginfo_test(self, platform, target_yaml, raw_data, expected):
+        class MyResponder(MockGDBServerResponder):
+            def qSupported(self, client_supported):
+                return "PacketSize=3fff;QStartNoAckMode+;qXfer:siginfo:read+"
+
+            def qXferRead(self, obj, annex, offset, length):
+                if obj == "siginfo":
+                    return raw_data, False
+                else:
+                    return None, False
+
+            def haltReason(self):
+                return "T02"
+
+            def cont(self):
+                return self.haltReason()
+
+        self.server.responder = MyResponder()
+
+        self.runCmd("platform select " + platform)
+        target = self.createTarget(target_yaml)
+        process = self.connect(target)
+
+        error = lldb.SBError()
+        siginfo = process.threads[0].GetSiginfo(error)
+        self.assertTrue(siginfo, error)
+
+        for key, value in expected.items():
+            self.assertEqual(siginfo.GetValueForExpressionPath("." + key)
+                             .GetValueAsUnsigned(),
+                             value)
+
+
+    def test_siginfo_linux_amd64(self):
+        data = (
+          # si_signo         si_errno        si_code
+            "\x11\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00"
+          # __pad0           si_pid          si_uid
+            "\x00\x00\x00\x00\xbf\xf7\x0b\x00\xe8\x03\x00\x00"
+          # si_status
+            "\x0c\x00\x00\x00" + "\x00" * 100)
+        expected = {
+            "si_signo": 17,  # SIGCHLD
+            "si_errno": 0,
+            "si_code": 1,  # CLD_EXITED
+            "_sifields._sigchld.si_pid": 784319,
+            "_sifields._sigchld.si_uid": 1000,
+            "_sifields._sigchld.si_status": 12,
+            "_sifields._sigchld.si_utime": 0,
+            "_sifields._sigchld.si_stime": 0,
+        }
+        self.do_siginfo_test("remote-linux", "basic_eh_frame.yaml",
+                             data, expected)
+
+    def test_siginfo_linux_i386(self):
+        data = (
+          # si_signo         si_errno        si_code
+            "\x11\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00"
+          # si_pid           si_uid          si_status
+            "\x49\x43\x07\x00\xe8\x03\x00\x00\x0c\x00\x00\x00"
+            + "\x00" * 104)
+        expected = {
+            "si_signo": 17,  # SIGCHLD
+            "si_errno": 0,
+            "si_code": 1,  # CLD_EXITED
+            "_sifields._sigchld.si_pid": 475977,
+            "_sifields._sigchld.si_uid": 1000,
+            "_sifields._sigchld.si_status": 12,
+            "_sifields._sigchld.si_utime": 0,
+            "_sifields._sigchld.si_stime": 0,
+        }
+        self.do_siginfo_test("remote-linux", "basic_eh_frame-i386.yaml",
+                             data, expected)
+
+    def test_siginfo_freebsd_amd64(self):
+        data = (
+          # si_signo         si_errno        si_code
+            "\x0b\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00"
+          # si_pid           si_uid          si_status
+            "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+          # si_addr
+            "\x76\x98\xba\xdc\xfe\x00\x00\x00"
+          # si_status                        si_trapno
+            "\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00"
+            + "\x00" * 36)
+
+        expected = {
+            "si_signo": 11,  # SIGSEGV
+            "si_errno": 0,
+            "si_code": 1,  # SEGV_MAPERR
+            "si_addr": 0xfedcba9876,
+            "_reason._fault._trapno": 12,
+        }
+        self.do_siginfo_test("remote-freebsd", "basic_eh_frame.yaml",
+                             data, expected)