[LLDB] Show sub type of memory tagging SEGV when reading a core file

[DavidSpickett]

Summary

Previously we only looked at the si_signo field, so you got:

(lldb) bt
* thread #1, name = 'a.out.mte', stop reason = signal SIGSEGV
  * frame #0: 0x00000000004007f4

This patch adds si_code so we can show:

(lldb) bt
* thread #1, name = 'a.out.mte', stop reason = signal SIGSEGV: sync tag check fault
  * frame #0: 0x00000000004007f4

The format matches that generated by Plugins/Process/POSIX/CrashReason,
which is used in native code. However we do not include the fault address
because (at least on Linux) the corefile doesn't include it.

The order of errno and code was incorrect in ElfLinuxSigInfo::Parse.
It was the order that a "swapped" siginfo arch would use, which for Linux,
is only MIPS. We removed MIPS Linux support some time ago.

See:
https://github.com/torvalds/linux/blob/fe15c26ee26efa11741a7b632e9f23b01aca4cc6/include/uapi/asm-generic/siginfo.h#L121

I've only added the two memory tagging fault types so far but
this can be expanded to any signal easily.

[labath]

lldb/source/Plugins/Process/elf-core/ThreadElfCore.cpp

227

I think this won't work on Windows (no siginfo_t type, nor constants to decode it) -- and it may return garbage on other platforms if they use different constants.

If I may suggest an alternative implementation:

• Implement ThreadElfCore::GetSiginfo to return (verbatim) copy of the siginfo_t from the core file
• Implement a generic stop info description calculation (on platform class) function

Besides the stop description, this should also make the thread siginfo command work, and we can consider removing the lldb-server-based stop info computation logic, since this impl should cover both live and post-portem use cases.

[DavidSpickett]

lldb/source/Plugins/Process/elf-core/ThreadElfCore.cpp

227

Yes, of course.

I'll try what you suggested.

[DavidSpickett]

Add code functionality to UnixSignals instead.

[DavidSpickett]

This should build anywhere now.

I looked at thread siginfo and I see what you mean, but it'll take me some time to confirm exactly how much of siginfo is in the core file. I did get it to work using the full type, but I'm pretty sure some of the values were invalid.

Now I'm looking at replacing the CrashReason code with UnixSignals. Perhaps it can learn to append fault addresses and bounds.

[DavidSpickett]

lldb/source/Plugins/Process/Utility/LinuxSignals.cpp

32

See https://github.com/torvalds/linux/blob/6a98c9cae232800c319ed69e1063480d31430887/include/uapi/asm-generic/siginfo.h#L229, the codes apply to all architectures.

[DavidSpickett]

I'm working on merging CrashReason into UnixSignals, so this will either be part of, or on top of that.

[DavidSpickett]

This will be back as part of a series.

lldb/include/lldb/Target/StopInfo.h

 //===-- StopInfo.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
 //
 //===----------------------------------------------------------------------===//
 
static lldb::StopInfoSP CreateStopReasonWithBreakpointSiteID(
       Thread &thread, lldb::break_id_t break_id, bool should_stop);
 
   static lldb::StopInfoSP CreateStopReasonWithWatchpointID(
       Thread &thread, lldb::break_id_t watch_id,
       lldb::addr_t watch_hit_addr = LLDB_INVALID_ADDRESS);
 
   static lldb::StopInfoSP
   CreateStopReasonWithSignal(Thread &thread, int signo,
-                             const char *description = nullptr);
+                             const char *description = nullptr,
+                             std::optional<int> code = std::nullopt);
 
   static lldb::StopInfoSP CreateStopReasonToTrace(Thread &thread);
 
   static lldb::StopInfoSP
   CreateStopReasonWithPlan(lldb::ThreadPlanSP &plan,
                            lldb::ValueObjectSP return_valobj_sp,
                            lldb::ExpressionVariableSP expression_variable_sp);
 

lldb/include/lldb/Target/UnixSignals.h

 //===-- UnixSignals.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
 //
 //===----------------------------------------------------------------------===//
 
public:
 
   // Constructors and Destructors
   UnixSignals();
 
   virtual ~UnixSignals();
 
   const char *GetSignalAsCString(int32_t signo) const;
 
+  std::string GetSignalAsString(int32_t signo,
+                                std::optional<int32_t> code) const;
+
   bool SignalIsValid(int32_t signo) const;
 
   int32_t GetSignalNumberFromName(const char *name) const;
 
   const char *GetSignalInfo(int32_t signo, bool &should_suppress,
                             bool &should_stop, bool &should_notify) const;
 
   bool GetShouldSuppress(int32_t signo) const;
public:
   // it runs.  So don't call these functions anywhere but the constructor of
   // your subclass of UnixSignals or in your Process Plugin's GetUnixSignals
   // method before you return the UnixSignal object.
 
   void AddSignal(int signo, const char *name, bool default_suppress,
                  bool default_stop, bool default_notify,
                  const char *description, const char *alias = nullptr);
 
+  void AddSignalCode(int signo, int code, const char *description);
+
   void RemoveSignal(int signo);
 
   /// Track how many times signals are hit as stop reasons.
   void IncrementSignalHitCount(int signo);
 
   /// Get the hit count statistics for signals.
   ///
   /// Gettings statistics on the hit counts of signals can help explain why some

 
 protected:
   // Classes that inherit from UnixSignals can see and modify these
 
   struct Signal {
     ConstString m_name;
     ConstString m_alias;
     std::string m_description;
+    std::map<int32_t, ConstString> m_codes;
     uint32_t m_hit_count = 0;
     bool m_suppress : 1, m_stop : 1, m_notify : 1;
     bool m_default_suppress : 1, m_default_stop : 1, m_default_notify : 1;
 
     Signal(const char *name, bool default_suppress, bool default_stop,
            bool default_notify, const char *description, const char *alias);
 
     ~Signal() = default;

lldb/source/Plugins/Process/Utility/LinuxSignals.cpp

 //===-- LinuxSignals.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
 //
 //===----------------------------------------------------------------------===//
 
void LinuxSignals::Reset() {
   AddSignal(4,      "SIGILL",       false,    true,   true,   "illegal instruction");
   AddSignal(5,      "SIGTRAP",      true,     true,   true,   "trace trap (not reset when caught)");
   AddSignal(6,      "SIGABRT",      false,    true,   true,   "abort()/IOT trap", "SIGIOT");
   AddSignal(7,      "SIGBUS",       false,    true,   true,   "bus error");
   AddSignal(8,      "SIGFPE",       false,    true,   true,   "floating point exception");
   AddSignal(9,      "SIGKILL",      false,    true,   true,   "kill");
   AddSignal(10,     "SIGUSR1",      false,    true,   true,   "user defined signal 1");
   AddSignal(11,     "SIGSEGV",      false,    true,   true,   "segmentation violation");
+  AddSignalCode(11, 8 /*SEGV_MTEAERR*/, "async tag check fault");
+  AddSignalCode(11, 9 /*SEGV_MTESERR*/, "sync tag check fault");
   AddSignal(12,     "SIGUSR2",      false,    true,   true,   "user defined signal 2");
   AddSignal(13,     "SIGPIPE",      false,    true,   true,   "write to pipe with reading end closed");
   AddSignal(14,     "SIGALRM",      false,    false,  false,  "alarm");
   AddSignal(15,     "SIGTERM",      false,    true,   true,   "termination requested");
   AddSignal(16,     "SIGSTKFLT",    false,    true,   true,   "stack fault");
   AddSignal(17,     "SIGCHLD",      false,    false,  true,   "child status has changed", "SIGCLD");
   AddSignal(18,     "SIGCONT",      false,    false,  true,   "process continue");
   AddSignal(19,     "SIGSTOP",      true,     true,   true,   "process stop");

lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

 //===-- ProcessElfCore.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
 //
 //===----------------------------------------------------------------------===//
 
case ELF::NT_PRPSINFO: {
       break;
     }
     case ELF::NT_SIGINFO: {
       ELFLinuxSigInfo siginfo;
       Status status = siginfo.Parse(note.data, arch);
       if (status.Fail())
         return status.ToError();
       thread_data.signo = siginfo.si_signo;
+      thread_data.code = siginfo.si_code;
       break;
     }
     case ELF::NT_FILE: {
       m_nt_file_entries.clear();
       lldb::offset_t offset = 0;
       const uint64_t count = note.data.GetAddress(&offset);
       note.data.GetAddress(&offset); // Skip page size
       for (uint64_t i = 0; i < count; ++i) {

lldb/source/Plugins/Process/elf-core/ThreadElfCore.h

 //===-- ThreadElfCore.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
 //
 //===----------------------------------------------------------------------===//
 

 static_assert(sizeof(ELFLinuxPrPsInfo) == 136,
               "sizeof ELFLinuxPrPsInfo is not correct!");
 
 struct ThreadData {
   lldb_private::DataExtractor gpregset;
   std::vector<lldb_private::CoreNote> notes;
   lldb::tid_t tid;
   int signo = 0;
+  int code = 0;
   int prstatus_sig = 0;
   std::string name;
 };
 
 class ThreadElfCore : public lldb_private::Thread {
 public:
   ThreadElfCore(lldb_private::Process &process, const ThreadData &td);
 
public:
   }
 
 protected:
   // Member variables.
   std::string m_thread_name;
   lldb::RegisterContextSP m_thread_reg_ctx_sp;
 
   int m_signo;
+  int m_code;
 
   lldb_private::DataExtractor m_gpregset_data;
   std::vector<lldb_private::CoreNote> m_notes;
 
   bool CalculateStopInfo() override;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_ELF_CORE_THREADELFCORE_H

lldb/source/Plugins/Process/elf-core/ThreadElfCore.cpp

 //===-- ThreadElfCore.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 <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 // Construct a Thread object with given data
 ThreadElfCore::ThreadElfCore(Process &process, const ThreadData &td)
     : Thread(process, td.tid), m_thread_name(td.name), m_thread_reg_ctx_sp(),
-      m_signo(td.signo), m_gpregset_data(td.gpregset), m_notes(td.notes) {}
+      m_signo(td.signo), m_code(td.code), m_gpregset_data(td.gpregset),
+      m_notes(td.notes) {}
 
 ThreadElfCore::~ThreadElfCore() { DestroyThread(); }
 
 void ThreadElfCore::RefreshStateAfterStop() {
   GetRegisterContext()->InvalidateIfNeeded(false);
 }
 
 RegisterContextSP ThreadElfCore::GetRegisterContext() {
ThreadElfCore::CreateRegisterContextForFrame(StackFrame *frame) {
   } else {
     reg_ctx_sp = GetUnwinder().CreateRegisterContextForFrame(frame);
   }
   return reg_ctx_sp;
 }
 
 bool ThreadElfCore::CalculateStopInfo() {
   ProcessSP process_sp(GetProcess());
-  if (process_sp) {
-    SetStopInfo(StopInfo::CreateStopReasonWithSignal(*this, m_signo));
-    return true;
-  }
+  if (!process_sp)
     return false;
+
+  SetStopInfo(StopInfo::CreateStopReasonWithSignal(
+      *this, m_signo, /*description=*/nullptr, m_code));
+  return true;
 }
 
 // Parse PRSTATUS from NOTE entry
 ELFLinuxPrStatus::ELFLinuxPrStatus() {
   memset(this, 0, sizeof(ELFLinuxPrStatus));
 }
 
 size_t ELFLinuxPrStatus::GetSize(const lldb_private::ArchSpec &arch) {
error.SetErrorStringWithFormat(
         GetSize(arch), data.GetByteSize());
     return error;
   }
 
   // Parsing from a 32 bit ELF core file, and populating/reusing the structure
   // properly, because the struct is for the 64 bit version
   offset_t offset = 0;
   si_signo = data.GetU32(&offset);
-  si_code = data.GetU32(&offset);
   si_errno = data.GetU32(&offset);
+  si_code = data.GetU32(&offset);
 
   return error;
 }

lldb/source/Target/StopInfo.cpp

 //===-- StopInfo.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
 //
 //===----------------------------------------------------------------------===//
 
private:
   bool m_step_over_plan_complete = false;
   bool m_using_step_over_plan = false;
 };
 
 // StopInfoUnixSignal
 
 class StopInfoUnixSignal : public StopInfo {
 public:
-  StopInfoUnixSignal(Thread &thread, int signo, const char *description)
-      : StopInfo(thread, signo) {
+  StopInfoUnixSignal(Thread &thread, int signo, const char *description,
+                     std::optional<int> code)
+      : StopInfo(thread, signo), m_code(code) {
     SetDescription(description);
   }
 
   ~StopInfoUnixSignal() override = default;
 
   StopReason GetStopReason() const override { return eStopReasonSignal; }
 
   bool ShouldStopSynchronous(Event *event_ptr) override {
if (thread_sp) {
         thread_sp->SetResumeSignal(m_value);
     }
   }
 
   const char *GetDescription() override {
     if (m_description.empty()) {
       ThreadSP thread_sp(m_thread_wp.lock());
       if (thread_sp) {
+        UnixSignalsSP unix_signals = thread_sp->GetProcess()->GetUnixSignals();
         StreamString strm;
-        const char *signal_name =
-            thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
-                m_value);
-        if (signal_name)
-          strm.Printf("signal %s", signal_name);
+        strm << "signal ";
+
+        std::string signal_name =
+            unix_signals->GetSignalAsString(m_value, m_code);
+        if (signal_name.size())
+          strm << signal_name;
         else
-          strm.Printf("signal %" PRIi64, m_value);
+          strm.Printf("%" PRIi64, m_value);
+
         m_description = std::string(strm.GetString());
       }
     }
     return m_description.c_str();
   }
+
+private:
+  // In siginfo_t terms, if m_value is si_signo, m_code is si_code.
+  std::optional<int> m_code;
 };
 
 // StopInfoTrace
 
 class StopInfoTrace : public StopInfo {
 public:
   StopInfoTrace(Thread &thread) : StopInfo(thread, LLDB_INVALID_UID) {}
 

 
 StopInfoSP
 StopInfo::CreateStopReasonWithWatchpointID(Thread &thread, break_id_t watch_id,
                                            lldb::addr_t watch_hit_addr) {
   return StopInfoSP(new StopInfoWatchpoint(thread, watch_id, watch_hit_addr));
 }
 
 StopInfoSP StopInfo::CreateStopReasonWithSignal(Thread &thread, int signo,
-                                                const char *description) {
+                                                const char *description,
+                                                std::optional<int> code) {
   thread.GetProcess()->GetUnixSignals()->IncrementSignalHitCount(signo);
-  return StopInfoSP(new StopInfoUnixSignal(thread, signo, description));
+  return StopInfoSP(new StopInfoUnixSignal(thread, signo, description, code));
 }
 
 StopInfoSP StopInfo::CreateStopReasonToTrace(Thread &thread) {
   return StopInfoSP(new StopInfoTrace(thread));
 }
 
 StopInfoSP StopInfo::CreateStopReasonWithPlan(
     ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp,

lldb/source/Target/UnixSignals.cpp

 //===-- UnixSignals.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
 //
 //===----------------------------------------------------------------------===//
 
void UnixSignals::AddSignal(int signo, const char *name, bool default_suppress,
                             bool default_stop, bool default_notify,
                             const char *description, const char *alias) {
   Signal new_signal(name, default_suppress, default_stop, default_notify,
                     description, alias);
   m_signals.insert(std::make_pair(signo, new_signal));
   ++m_version;
 }
 
+void UnixSignals::AddSignalCode(int signo, int code, const char *description) {
+  collection::iterator signal = m_signals.find(signo);
+  if (signal == m_signals.end())
+    return;
+  signal->second.m_codes.insert(std::pair{code, description});
+  ++m_version;
+}
+
 void UnixSignals::RemoveSignal(int signo) {
   collection::iterator pos = m_signals.find(signo);
   if (pos != m_signals.end())
     m_signals.erase(pos);
   ++m_version;
 }
 
 const char *UnixSignals::GetSignalAsCString(int signo) const {
   collection::const_iterator pos = m_signals.find(signo);
   if (pos == m_signals.end())
     return nullptr;
   else
     return pos->second.m_name.GetCString();
 }
 
+std::string UnixSignals::GetSignalAsString(int32_t signo,
+                                           std::optional<int32_t> code) const {
+  std::string str;
+
+  collection::const_iterator pos = m_signals.find(signo);
+  if (pos != m_signals.end()) {
+    str = pos->second.m_name.GetCString();
+
+    if (code) {
+      std::map<int, ConstString>::const_iterator cpos =
+          pos->second.m_codes.find(*code);
+      if (cpos != pos->second.m_codes.end()) {
+        str += ": ";
+        str += cpos->second.GetCString();
+      }
+    }
+  }
+
+  return str;
+}
+
 bool UnixSignals::SignalIsValid(int32_t signo) const {
   return m_signals.find(signo) != m_signals.end();
 }
 
 ConstString UnixSignals::GetShortName(ConstString name) const {
   if (name)
     return ConstString(name.GetStringRef().substr(3)); // Remove "SIG" from name
   return name;

lldb/test/API/linux/aarch64/mte_core_file/TestAArch64LinuxMTEMemoryTagCoreFile.py

def test_mte_commands_no_mte(self):
         self.runCmd("target create --core core.nomte")
 
         self.expect("memory tag read 0 1",
                 substrs=["error: Process does not support memory tagging"], error=True)
         # Note that this tells you memory tagging is not supported at all, versus
         # the MTE core file which does support it but does not allow writing tags.
         self.expect("memory tag write 0 1",
                 substrs=["error: Process does not support memory tagging"], error=True)
+
+    @skipIfLLVMTargetMissing("AArch64")
+    def test_mte_tag_fault_reason(self):
+        """ Test that we correctly report the fault reason. """
+        self.runCmd("target create --core core.mte")
+
+        # There is no fault address shown here because core files do not include
+        # si_addr.
+        self.expect("bt", substrs=[
+                "* thread #1, name = 'a.out.mte', stop reason = signal SIGSEGV: "
+                "sync tag check fault"])

lldb/unittests/Signals/UnixSignalsTest.cpp

 //===-- UnixSignalsTest.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 <string>

 class TestSignals : public UnixSignals {
 public:
   TestSignals() {
     m_signals.clear();
     AddSignal(2, "SIG2", false, true, true, "DESC2");
     AddSignal(4, "SIG4", true, false, true, "DESC4");
     AddSignal(8, "SIG8", true, true, true, "DESC8");
     AddSignal(16, "SIG16", true, false, false, "DESC16");
+    AddSignalCode(16, 1, "a specific type of SIG16");
   }
 };
 
 void ExpectEqArrays(llvm::ArrayRef<int32_t> expected,
                     llvm::ArrayRef<int32_t> observed, const char *file,
                     int line) {
   std::string location = llvm::formatv("{0}:{1}", file, line);
   ASSERT_EQ(expected.size(), observed.size()) << location;
TEST(UnixSignalsTest, GetInfo) {
   EXPECT_EQ(true, should_notify);
 
   EXPECT_EQ(true, signals.GetShouldSuppress(signo));
   EXPECT_EQ(false, signals.GetShouldStop(signo));
   EXPECT_EQ(true, signals.GetShouldNotify(signo));
   EXPECT_EQ(name, signals.GetSignalAsCString(signo));
 }
 
+TEST(UnixSignalsTest, GetAsCString) {
+  TestSignals signals;
+
+  EXPECT_EQ(nullptr, signals.GetSignalAsCString(100));
+  std::string name = signals.GetSignalAsCString(16);
+  EXPECT_EQ("SIG16", name);
+}
+
+TEST(UnixSignalsTest, GetAsString) {
+  TestSignals signals;
+
+  EXPECT_EQ("", signals.GetSignalAsString(100, std::nullopt));
+  EXPECT_EQ("SIG16", signals.GetSignalAsString(16, std::nullopt));
+  EXPECT_EQ("", signals.GetSignalAsString(100, 100));
+  EXPECT_EQ("SIG16", signals.GetSignalAsString(16, 100));
+  EXPECT_EQ("SIG16: a specific type of SIG16",
+            signals.GetSignalAsString(16, 1));
+}
+
 TEST(UnixSignalsTest, VersionChange) {
   TestSignals signals;
 
   int32_t signo = 8;
   uint64_t ver = signals.GetVersion();
   EXPECT_GT(ver, 0ull);
   EXPECT_EQ(true, signals.GetShouldSuppress(signo));
   EXPECT_EQ(true, signals.GetShouldStop(signo));

llvm/docs/ReleaseNotes.rst

 
 Changes to LLDB
 ---------------------------------
 
 * In the results of commands such as `expr` and `frame var`, type summaries will now
   omit defaulted template parameters. The full template parameter list can still be
   viewed with `expr --raw-output`/`frame var --raw-output`. (`D141828 <https://reviews.llvm.org/D141828>`_)
 
+* When debugging a Linux core file containing a segfault related to memory tagging,
+  LLDB now reports the specific type of that fault. For example ``SIGSEGV: sync tag check fault``.
+
 Changes to Sanitizers
 ---------------------
 
 Other Changes
 -------------
 
 External Open Source Projects Using LLVM 15
 ===========================================