[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

230

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

230

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 ↗

(On Diff #503274)

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/source/Plugins/Process/POSIX/CrashReason.h

 //===-- CrashReason.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_CrashReason_H_
 #define liblldb_CrashReason_H_
 
 #include "lldb/lldb-types.h"
 
 #include <csignal>
 
+#include <optional>
 #include <string>
 
 enum class CrashReason {
   eInvalidCrashReason,
 
   // SIGSEGV crash reasons.
   eInvalidAddress,
   ePrivilegedAddress,
enum class CrashReason {
   eFloatDivideByZero,
   eFloatOverflow,
   eFloatUnderflow,
   eFloatInexactResult,
   eFloatInvalidOperation,
   eFloatSubscriptRange
 };
 
-std::string GetCrashReasonString(CrashReason reason, lldb::addr_t fault_addr);
+// fault_addr will be empty when used from a core file which does not record the
+// fault address.
+std::string GetCrashReasonString(CrashReason reason,
+                                 std::optional<lldb::addr_t> fault_addr);
 std::string GetCrashReasonString(CrashReason reason, const siginfo_t &info);
 
 const char *CrashReasonAsString(CrashReason reason);
 
 CrashReason GetCrashReason(const siginfo_t &info);
 
 #endif // #ifndef liblldb_CrashReason_H_

lldb/source/Plugins/Process/POSIX/CrashReason.cpp

 //===-- CrashReason.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
 //
 //===----------------------------------------------------------------------===//
 
if (reason == CrashReason::eBoundViolation) {
     return str;
   }
 #endif
 
   return GetCrashReasonString(reason,
                               reinterpret_cast<uintptr_t>(info.si_addr));
 }
 
-std::string GetCrashReasonString(CrashReason reason, lldb::addr_t fault_addr) {
+std::string GetCrashReasonString(CrashReason reason,
+                                 std::optional<lldb::addr_t> fault_addr) {
   std::string str;
 
   switch (reason) {
   default:
     str = "unknown crash reason";
     break;
 
   case CrashReason::eInvalidAddress:
     str = "signal SIGSEGV: invalid address";
-    AppendFaultAddr(str, fault_addr);
+    if (fault_addr)
+      AppendFaultAddr(str, *fault_addr);
     break;
   case CrashReason::ePrivilegedAddress:
     str = "signal SIGSEGV: address access protected";
-    AppendFaultAddr(str, fault_addr);
+    if (fault_addr)
+      AppendFaultAddr(str, *fault_addr);
     break;
   case CrashReason::eBoundViolation:
     str = "signal SIGSEGV: bound violation";
     break;
   case CrashReason::eAsyncTagCheckFault:
     str = "signal SIGSEGV: async tag check fault";
     break;
   case CrashReason::eSyncTagCheckFault:
     str = "signal SIGSEGV: sync tag check fault";
-    AppendFaultAddr(str, fault_addr);
+    if (fault_addr)
+      AppendFaultAddr(str, *fault_addr);
     break;
   case CrashReason::eIllegalOpcode:
     str = "signal SIGILL: illegal instruction";
     break;
   case CrashReason::eIllegalOperand:
     str = "signal SIGILL: illegal instruction operand";
     break;
   case CrashReason::eIllegalAddressingMode:
CrashReason GetCrashReason(const siginfo_t &info) {
   case SIGBUS:
     return GetCrashReasonForSIGBUS(info);
   case SIGFPE:
     return GetCrashReasonForSIGFPE(info);
   case SIGILL:
     return GetCrashReasonForSIGILL(info);
   }
 
-  assert(false && "unexpected signal");
   return CrashReason::eInvalidCrashReason;
 }

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 "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 
+#include "Plugins/Process/POSIX/CrashReason.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_mips64.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_s390x.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
 #include "Plugins/Process/Utility/RegisterContextNetBSD_i386.h"

 #include "RegisterContextPOSIXCore_mips64.h"
 #include "RegisterContextPOSIXCore_powerpc.h"
 #include "RegisterContextPOSIXCore_ppc64le.h"
 #include "RegisterContextPOSIXCore_s390x.h"
 #include "RegisterContextPOSIXCore_x86_64.h"
 #include "ThreadElfCore.h"
 
 #include <memory>
+#include <optional>
 
 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;
+
+  siginfo_t info;
+  info.si_signo = m_signo;
+  info.si_code = m_code;
+  std::string description;
+  CrashReason reason = GetCrashReason(info);
+  if (reason != CrashReason::eInvalidCrashReason) {
+    description = GetCrashReasonString(reason, /*fault_addr=*/std::nullopt);
+  }
+  SetStopInfo(StopInfo::CreateStopReasonWithSignal(
+      *this, m_signo, description.size() ? description.c_str() : nullptr));
+  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/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"])

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>`_)
 
+* LLDB will now use the value of the ``siginfo`` ``si_code`` field to report
+  more specific signal types when debugging an ELF core file. For example
+  "sync tag check fault", which is a specific type of SIGSEGV.
+
 Changes to Sanitizers
 ---------------------
 
 Other Changes
 -------------
 
 External Open Source Projects Using LLVM 15
 ===========================================