Patch for lldb bug 26322 “core load hangs”

[hhellyer]

Summary

This patch changes the way ProcessElfCore.cpp handles signal information.
The patch changes ProcessElfCore.cpp to use the signal from si_signo in SIGINFO notes in preference to the value of cursig in PRSTATUS notes. The value from SIGINFO seems to be more thread specific. The value from PRSTATUS is usually the same for all threads even if only one thread received a signal.
If it cannot find any SIGINFO blocks it reverts to the old behaviour and uses the value from cursig in PRSTATUS. If after that no thread appears to have been stopped it forces the status of the first thread to be SIGSTOP to prevent lldb hanging waiting for any thread from the core file to change state.

The order is:

• If one or more threads have a non-zero si_signo in SIGINFO that will be used.
• If no threads had a SIGINFO block with a non-zero si_signo set all threads signals to the value in cursig in their PRSTATUS notes.
• If no thread has a signal set to a non-zero value set the signal for only the first thread to SIGSTOP.

This resolves two issues. The first was identified in bug 26322, the second became apparent while investigating this problem and looking at the signal values reported for each thread via “thread list”.

Firstly lldb is able to load core dumps generated by gcore where each thread has a SIGINFO note containing a signal number but cursig in the PRSTATUS block for each thread is 0.

Secondly if a SIGINFO note was found the “thread list” command will no longer show the same signal number for all threads. At the moment if a process crashes, for example with SIGILL, all threads will show “stop reason = signal SIGILL”. With this patch only the thread that executed the illegal instruction shows that stop reason. The other threads show “stop reason = signal 0”.

[clayborg]

Just a few quick changes.

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

208–209

If you are just iterating (not also wanting indexes, or keeping any iterators in the for loop) then use:

for (const auto &thread_data: m_thread_data) {
  if (thread_data.signo != 0)
    siginfo_signal_found = true;
  if (thread_data.prstatus_sig != 0)
    prstatus_signal_found = true;
}

219–220

for (const auto &thread_data: m_thread_data) {

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

93

add const to "arch":

const lldb_private::ArchSpec &arch

100

Add const:

const lldb_private::ArchSpec &arch

[jingham]

Besides Greg's comments, this looks reasonable to me.

[labath]

Thank you for looking into this. This has been a long standing issue that we haven't got time to address.

Could you also add some tests to cover the new functionality? It sounds like it would be easy to generate tiny core files which trigger this. You can look at tests in TestLinuxCore.py for examples. If you run into trouble there, let me know.

[sas]

Just a couple nits inline. Also, did you run clang-format on your change? I see some issues with ifs and the associated parentheses.

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

215

Nit: if (!siginfo_signal_found).

218

Similar nit: if (prstatus_signal_found).

[labath]

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

224

You should not use signal numbers from the host here -- the macro may not be present (windows), or it may not have the same value. You need to get the correct set of signals with Process::GetUnixSignals(), and then look up the signal by name.

[hhellyer]

Update with fixes from review comments.
I've run clang-format, fixed the use of iterators and added const qualifiers.
I removed the use of the SIGSTOP constant and use GetUnixSignals instead.
I've also moved that block down a few lines until after SetUnixSignals has been called.

I will update the patch with the test cases shortly.

[hhellyer]

Update patch due to two missing changes.

[clayborg]

Looks good.

[hhellyer]

This is marked ready to land and I can land it now but I'm still working on the testcases.
I can either:

• Land the code changes and do the tests under another patch.
• Hold off on delivering this until I've finished the tests.

I'm not sure which is the preferred option. The tests will probably need to be delivered with core files so they will be much larger deltas than just the functional code changes currently contained in this patch. Is there a preferred option?

[labath]

I can't say we're being very consistent in enforcing it, but general llvm policy is for tests to go together with the changes.

I am curious, how do you go about creating these core files?

The core files I created were very tiny as I did not require any syscalls, so I could avoid linking libc. Here it sounds like you would need at least one (clone(2)). I am considering reimplementing the required clone(2) bits inline, but I am afraid that may end up being a bit hairy.

[hhellyer]

I haven't solved that yet! ;-)

I'm currently ending up with cores of ~500kb which is probably too big. I'm seeing what I can do to bring them down but it might be that I can't shrink them that much. I'm attempting to write two tests, one for multiple threads and one for cores generated by gcore but the actual C program for both is very similar.

What would you say a sensible target size actually is?

The other option is to run these tests just on Linux then it might be possible to create the core dumps as part of the test. There's a lot of drawbacks to that - not least just that they wouldn't be run every where but also that depending on how the OS is setup it's not always possible to create a core on a signal or attach gcore. I don't really want to add flakey tests.

[labath]

In D26676#598559, @hhellyer wrote:

I haven't solved that yet! ;-)

I'm currently ending up with cores of ~500kb which is probably too big. I'm seeing what I can do to bring them down but it might be that I can't shrink them that much. I'm attempting to write two tests, one for multiple threads and one for cores generated by gcore but the actual C program for both is very similar.

What would you say a sensible target size actually is?

I would say about 100k is OK, but of course, the less, the better.

The other option is to run these tests just on Linux then it might be possible to create the core dumps as part of the test. There's a lot of drawbacks to that - not least just that they wouldn't be run every where but also that depending on how the OS is setup it's not always possible to create a core on a signal or attach gcore. I don't really want to add flakey tests.

Yeah, we can't rely on linux kernel to generate the core files, as there are many ways that could be disabled. If we had a core file writer in LLDB (I don't know if we do, or if it works), we could possibly do that.

That said, I was able to trivially generate a ~20k core file by setting /proc/$PID/coredump_filter to 0. You won't get any memory regions that way, but it does not sound like you need any for this test anyway. It could probably be even improved by some tricks like static linking (to avoid having a long list of modules, etc). Have you tried that?

[hhellyer]

I'd assumed that gcore would ignore the coredump_filter setting but it turns out it doesn't so I should be able to use that. lldb seems happy enough opening the core files produced with a filter of 0 so it's probably the simplest solution.

I don't think lldb has a core file writer for Linux/ELF, process save-core doesn't seem to think it does. I'm not sure it would help in this case though - I need to make sure we can open core files created via gcore. Opening core files generated by lldb itself would be a separate test case. It's still quite a desirable feature, Linux does not really have a good API for creating core dumps. gcore is useful but it still means exec-ing another process.

I'll tidy up my test cases and try to generate at least 64 and 32 bit intel cores to go with them before adding them to this patch.

[clayborg]

Checking core files into the repository will grow all git based repositories over time as every version of every core file will be included in the git clone. We have avoided checking in core files or any other larger files for this very reason. Not sure what the right answer is here.

[hhellyer]

Updating the patch to include the test cases and scripts to produce the core dumps.
I haven't included the core dumps and when I do I'll need to update the pid and
tid values in the test scripts. That can wait until we've decided what to do about
the core dumps though.

[labath]

We probably don't want to check in zillions of core files, but I believe having a couple of them is fine, particularly when care is taken to minimize their size. I believe the benefits (being able to run tests on a piece of code in a reproducible and platform-independent manner) outweigh the downsides. And I don't expect these files to change every week (probably more like never), so they won't bloat the history. Compare that with a 7MB python reference html file we currently store in the repo, which we should update (but we don't) on every API change.

[hhellyer]

Updated to add the test executables and core files.

[hhellyer]

@labath If you are happy with the tests and the size of their supporting files I'll land this, otherwise let me know if anything needs changing.

[labath]

I just tried it, and these tests run fine without the executable file. Just remove those, and I think we're ready.

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/gcore/TestGCore.py

39

You don't need the executable file for this test. Just create an empty target self.dbg.CreateTarget("") and use that.

[hhellyer]

Updating patch to remove executables and create empty targets in the test cases.

[hhellyer]

I'll land these changes tomorrow morning (UK time) so I can watch the builds and check there's no problems with the tests.

[labath]

It fails on the linux buildbot, but not when I run it locally. I am going to investigate the issue.

[labath]

Oh, you fixed it. Thank you. :)

[hhellyer]

@labath - Yes sorry about that. To be safe I did the "honest" thing of using arc to pull down the patch from phabriactor and then arc commit to land it to make sure I committed exactly what was reviewed. Somewhere in that it lost the contents of the core files and just created empty files for them. :-(

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/gcore/TestGCore.py

+"""
+Test signal reporting when debugging with linux core files.
+"""
+
+from __future__ import print_function
+
+import shutil
+import struct
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class GCoreTestCase(TestBase):
+    NO_DEBUG_INFO_TESTCASE = True
+
+    mydir = TestBase.compute_mydir(__file__)
+    _initial_platform = lldb.DBG.GetSelectedPlatform()
+
+    _i386_pid = 5586
+    _x86_64_pid = 5669
+
+    @skipIf(oslist=['windows'])
+    @skipIf(triple='^mips')
+    def test_i386(self):
+        """Test that lldb can read the process information from an i386 linux core file."""
+        self.do_test("linux-i386", self._i386_pid)
+
+    @skipIf(oslist=['windows'])
+    @skipIf(triple='^mips')
+    def test_x86_64(self):
+        """Test that lldb can read the process information from an x86_64 linux core file."""
+        self.do_test("linux-x86_64", self._x86_64_pid)
+
+    def do_test(self, filename, pid):
+        target = self.dbg.CreateTarget("")
+        process = target.LoadCore(filename + ".core")
+        self.assertTrue(process, PROCESS_IS_VALID)
+        self.assertEqual(process.GetNumThreads(), 3)
+        self.assertEqual(process.GetProcessID(), pid)
+
+        for thread in process:
+            reason = thread.GetStopReason()
+            self.assertEqual(reason, lldb.eStopReasonSignal)
+            signal = thread.GetStopReasonDataAtIndex(1)
+            # Check we got signal 19 (SIGSTOP)
+            self.assertEqual(signal, 19)
+
+        self.dbg.DeleteTarget(target)
+        lldb.DBG.SetSelectedPlatform(self._initial_platform)

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/gcore/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// This test verifies the correct handling of child thread exits.
+
+#include <atomic>
+#include <thread>
+#include <csignal>
+
+pseudo_barrier_t g_barrier1;
+pseudo_barrier_t g_barrier2;
+
+void *
+thread1 ()
+{
+  // Synchronize with the main thread.
+  pseudo_barrier_wait(g_barrier1);
+
+  // Synchronize with the main thread and thread2.
+  pseudo_barrier_wait(g_barrier2);
+
+  // Return
+  return NULL;
+}
+
+void *
+thread2 ()
+{
+
+  // Synchronize with thread1 and the main thread.
+  pseudo_barrier_wait(g_barrier2); // Should not reach here.
+
+  // Return
+  return NULL;
+}
+
+int main ()
+{
+
+  pseudo_barrier_init(g_barrier1, 2);
+  pseudo_barrier_init(g_barrier2, 3);
+
+  // Create a thread.
+  std::thread thread_1(thread1);
+
+  // Wait for thread1 to start.
+  pseudo_barrier_wait(g_barrier1);
+
+  // Wait for thread1 to start.
+  std::thread thread_2(thread2);
+
+  // Thread 2 is waiting for another thread to reach the barrier.
+  // This should have for ever. (So we can run gcore against this process.)
+  thread_2.join();
+
+  return 0;
+}

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/gcore/main.mk

+LEVEL = ../../../../make
+
+CXX_SOURCES := main.cpp
+ENABLE_THREADS := YES
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/gcore/make-core.sh

+#! /bin/sh
+
+linux_check_ptrace_scope()
+{
+    if grep -q '1' </proc/sys/kernel/yama/ptrace_scope; then
+        cat <<EOF
+Your system prevents the use of PTRACE to attach to non-child processes. The core file
+cannot be generated.  Please reset /proc/sys/kernel/yama/ptrace_scope to 0 (requires root
+privileges) to enable core generation via gcore.
+EOF
+        exit 1
+    fi
+}
+
+set -e -x
+
+OS=$(uname -s)
+if [ "$OS" = Linux ]; then
+    linux_check_ptrace_scope
+fi
+
+rm -f a.out
+make -f main.mk
+
+cat <<EOF
+Executable file is in a.out.
+Core file will be saved as core.<pid>.
+EOF
+
+stack_size=`ulimit -s`
+
+# Decrease stack size to 16k => smaller core files.
+# gcore won't run with the smaller stack
+ulimit -Ss 16
+
+core_dump_filter=`cat /proc/self/coredump_filter`
+echo 0 > /proc/self/coredump_filter
+
+./a.out &
+
+pid=$!
+
+echo $core_dump_filter > /proc/self/coredump_filter
+
+# Reset stack size as so there's enough space to run gcore.
+ulimit -s $stack_size
+
+echo "Sleeping for 5 seconds to wait for $pid"
+
+sleep 5
+echo "Taking core from process $pid"
+
+gcore -o core $pid
+
+echo "Killing process $pid"
+kill -9 $pid

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/thread_crash/TestLinuxCoreThreads.py

+"""
+Test signal reporting when debugging with linux core files.
+"""
+
+from __future__ import print_function
+
+import shutil
+import struct
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class LinuxCoreThreadsTestCase(TestBase):
+    NO_DEBUG_INFO_TESTCASE = True
+
+    mydir = TestBase.compute_mydir(__file__)
+    _initial_platform = lldb.DBG.GetSelectedPlatform()
+
+    _i386_pid = 5193
+    _x86_64_pid = 5222
+
+    # Thread id for the failing thread.
+    _i386_tid = 5195
+    _x86_64_tid = 5250
+
+    @skipIf(oslist=['windows'])
+    @skipIf(triple='^mips')
+    def test_i386(self):
+        """Test that lldb can read the process information from an i386 linux core file."""
+        self.do_test("linux-i386", self._i386_pid, self._i386_tid)
+
+    @skipIf(oslist=['windows'])
+    @skipIf(triple='^mips')
+    def test_x86_64(self):
+        """Test that lldb can read the process information from an x86_64 linux core file."""
+        self.do_test("linux-x86_64", self._x86_64_pid, self._x86_64_tid)
+
+    def do_test(self, filename, pid, tid):
+        target = self.dbg.CreateTarget("")
+        process = target.LoadCore(filename + ".core")
+        self.assertTrue(process, PROCESS_IS_VALID)
+        self.assertEqual(process.GetNumThreads(), 3)
+        self.assertEqual(process.GetProcessID(), pid)
+
+        for thread in process:
+            reason = thread.GetStopReason()
+            if( thread.GetThreadID() == tid ):
+                self.assertEqual(reason, lldb.eStopReasonSignal)
+                signal = thread.GetStopReasonDataAtIndex(1)
+                # Check we got signal 4 (SIGILL)
+                self.assertEqual(signal, 4)
+            else:
+                signal = thread.GetStopReasonDataAtIndex(1)
+                # Check we got no signal on the other threads
+                self.assertEqual(signal, 0)
+
+        self.dbg.DeleteTarget(target)
+        lldb.DBG.SetSelectedPlatform(self._initial_platform)

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/thread_crash/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// This test verifies the correct handling of child thread exits.
+
+#include <atomic>
+#include <thread>
+#include <csignal>
+
+pseudo_barrier_t g_barrier1;
+pseudo_barrier_t g_barrier2;
+
+void *
+thread1 ()
+{
+  // Synchronize with the main thread.
+  pseudo_barrier_wait(g_barrier1);
+
+  // Synchronize with the main thread and thread2.
+  pseudo_barrier_wait(g_barrier2);
+
+  // Return
+  return NULL; // Should not reach here. (thread2 should raise SIGILL)
+}
+
+void *
+thread2 ()
+{
+  raise(SIGILL); // Raise SIGILL
+
+  // Synchronize with thread1 and the main thread.
+  pseudo_barrier_wait(g_barrier2); // Should not reach here.
+
+  // Return
+  return NULL;
+}
+
+int main ()
+{
+  pseudo_barrier_init(g_barrier1, 2);
+  pseudo_barrier_init(g_barrier2, 3);
+
+  // Create a thread.
+  std::thread thread_1(thread1);
+
+  // Wait for thread1 to start.
+  pseudo_barrier_wait(g_barrier1);
+
+  // Create another thread.
+  std::thread thread_2(thread2);
+
+  // Wait for thread2 to start.
+  // Second thread should crash but first thread and main thread may reach here.
+  pseudo_barrier_wait(g_barrier2);
+
+  return 0;
+}

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/thread_crash/main.mk

+LEVEL = ../../../../make
+
+CXX_SOURCES := main.cpp
+ENABLE_THREADS := YES
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/thread_crash/make-core.sh

+#! /bin/sh
+
+linux_check_core_pattern()
+{
+    if grep -q '^|' </proc/sys/kernel/core_pattern; then
+        cat <<EOF
+Your system uses a crash report tool ($(cat /proc/sys/kernel/core_pattern)). Core files
+will not be generated.  Please reset /proc/sys/kernel/core_pattern (requires root
+privileges) to enable core generation.
+EOF
+        exit 1
+    fi
+}
+
+OS=$(uname -s)
+case "$OS" in
+FreeBSD)
+    core_pattern=$(sysctl -n kern.corefile)
+    ;;
+Linux)
+    core_pattern=$(cat /proc/sys/kernel/core_pattern)
+    ;;
+*)
+    echo "OS $OS not supported" >&2
+    exit 1
+    ;;
+esac
+
+set -e -x
+
+if [ "$OS" = Linux ]; then
+    linux_check_core_pattern
+fi
+
+ulimit -c 1000
+real_limit=$(ulimit -c)
+if [ $real_limit -lt 100 ]; then
+    cat <<EOF
+Unable to increase the core file limit. Core file may be truncated!
+To fix this, increase HARD core file limit (ulimit -H -c 1000). This may require root
+privileges.
+EOF
+fi
+
+rm -f a.out
+make -f main.mk
+
+cat <<EOF
+Executable file is in a.out.
+Core file will be saved according to pattern $core_pattern.
+EOF
+
+# Save stack size and core_dump_filter
+stack_size=`ulimit -s`
+ulimit -Ss 32 # Decrease stack size to 32k => smaller core files.
+
+core_dump_filter=`cat /proc/self/coredump_filter`
+echo 0 > /proc/self/coredump_filter
+
+exec ./a.out
+
+# Reset stack size and core_dump_filter
+echo core_dump_filter > /proc/self/coredump_filter
+ulimit -s $stack_size

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

if (header->p_type == llvm::ELF::PT_LOAD) {
       vm_addr = last_addr;
     }
   }
 
   if (!ranges_are_sorted) {
     m_core_aranges.Sort();
     m_core_range_infos.Sort();
   }
 
   // Even if the architecture is set in the target, we need to override
   // it to match the core file which is always single arch.
   ArchSpec arch(m_core_module_sp->GetArchitecture());
   if (arch.IsValid())
     GetTarget().SetArchitecture(arch);
 
   SetUnixSignals(UnixSignals::Create(GetArchitecture()));
 
+  // Ensure we found at least one thread that was stopped on a signal.
+  bool siginfo_signal_found = false;
+  bool prstatus_signal_found = false;
+  // Check we found a signal in a SIGINFO note.
+  for (const auto &thread_data: m_thread_data) {
+    if (thread_data.signo != 0)
+      siginfo_signal_found = true;
+    if (thread_data.prstatus_sig != 0)
+      prstatus_signal_found = true;
+  }
+  if (!siginfo_signal_found) {
+    // If we don't have signal from SIGINFO use the signal from each threads
+    // PRSTATUS note.
+    if (prstatus_signal_found) {
+      for (auto &thread_data: m_thread_data)
+        thread_data.signo = thread_data.prstatus_sig;
+    } else if (m_thread_data.size() > 0) {
+      // If all else fails force the first thread to be SIGSTOP
+      m_thread_data.begin()->signo =
+          GetUnixSignals()->GetSignalNumberFromName("SIGSTOP");
+    }
+  }
+
   // Core files are useless without the main executable. See if we can locate
   // the main
   // executable using data we found in the core file notes.
   lldb::ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
   if (!exe_module_sp) {
     // The first entry in the NT_FILE might be our executable
     if (!m_nt_file_entries.empty()) {
       ModuleSpec exe_module_spec;
enum {
   NT_PRSTATUS = 1,
   NT_FPREGSET,
   NT_PRPSINFO,
   NT_TASKSTRUCT,
   NT_PLATFORM,
   NT_AUXV,
   NT_FILE = 0x46494c45,
   NT_PRXFPREG = 0x46e62b7f,
+  NT_SIGINFO = 0x53494749,
 };
 
 namespace FREEBSD {
 
 enum {
   NT_PRSTATUS = 1,
   NT_FPREGSET,
   NT_PRPSINFO,
Error ProcessElfCore::ParseThreadContextsFromNoteSegment(
   lldb::offset_t offset = 0;
   std::unique_ptr<ThreadData> thread_data(new ThreadData);
   bool have_prstatus = false;
   bool have_prpsinfo = false;
 
   ArchSpec arch = GetArchitecture();
   ELFLinuxPrPsInfo prpsinfo;
   ELFLinuxPrStatus prstatus;
+  ELFLinuxSigInfo siginfo;
   size_t header_size;
   size_t len;
   Error error;
 
   // Loop through the NOTE entires in the segment
   while (offset < segment_header->p_filesz) {
     ELFNote note = ELFNote();
     note.Parse(segment_data, &offset);
if (note.n_name == "FreeBSD") {
       }
     } else if (note.n_name == "CORE") {
       switch (note.n_type) {
       case NT_PRSTATUS:
         have_prstatus = true;
         error = prstatus.Parse(note_data, arch);
         if (error.Fail())
           return error;
-        thread_data->signo = prstatus.pr_cursig;
+        thread_data->prstatus_sig = prstatus.pr_cursig;
         thread_data->tid = prstatus.pr_pid;
         header_size = ELFLinuxPrStatus::GetSize(arch);
         len = note_data.GetByteSize() - header_size;
         thread_data->gpregset = DataExtractor(note_data, header_size, len);
         break;
       case NT_FPREGSET:
         // In a i386 core file NT_FPREGSET is present, but it's not the result
         // of the FXSAVE instruction like in 64 bit files.
if (note.n_name == "FreeBSD") {
           m_nt_file_entries.push_back(entry);
         }
         for (uint64_t i = 0; i < count; ++i) {
           const char *path = note_data.GetCStr(&offset);
           if (path && path[0])
             m_nt_file_entries[i].path.SetCString(path);
         }
       } break;
+      case NT_SIGINFO: {
+        error = siginfo.Parse(note_data, arch);
+        if (error.Fail())
+          return error;
+        thread_data->signo = siginfo.si_signo;
+      } break;
       default:
         break;
       }
     } else if (note.n_name == "LINUX") {
       switch (note.n_type) {
       case NT_PRXFPREG:
         thread_data->fpregset = note_data;
       }

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

default:
       return 0;
     }
   }
 };
 
 static_assert(sizeof(ELFLinuxPrStatus) == 112,
               "sizeof ELFLinuxPrStatus is not correct!");
 
+struct ELFLinuxSigInfo {
+  int32_t si_signo;
+  int32_t si_code;
+  int32_t si_errno;
+
+  ELFLinuxSigInfo();
+
+  lldb_private::Error Parse(lldb_private::DataExtractor &data,
+                            const lldb_private::ArchSpec &arch);
+
+  // Return the bytesize of the structure
+  // 64 bit - just sizeof
+  // 32 bit - hardcoded because we are reusing the struct, but some of the
+  // members are smaller -
+  // so the layout is not the same
+  static size_t GetSize(const lldb_private::ArchSpec &arch) {
+    switch (arch.GetCore()) {
+    case lldb_private::ArchSpec::eCore_x86_64_x86_64:
+      return sizeof(ELFLinuxSigInfo);
+    case lldb_private::ArchSpec::eCore_s390x_generic:
+    case lldb_private::ArchSpec::eCore_x86_32_i386:
+    case lldb_private::ArchSpec::eCore_x86_32_i486:
+      return 12;
+    default:
+      return 0;
+    }
+  }
+};
+
+static_assert(sizeof(ELFLinuxSigInfo) == 12,
+              "sizeof ELFLinuxSigInfo is not correct!");
+
 // PRPSINFO structure's size differs based on architecture.
 // This is the layout in the x86-64 arch case.
 // In the i386 case we parse it manually and fill it again
 // in the same structure
 struct ELFLinuxPrPsInfo {
   char pr_state;
   char pr_sname;
   char pr_zomb;

 static_assert(sizeof(ELFLinuxPrPsInfo) == 136,
               "sizeof ELFLinuxPrPsInfo is not correct!");
 
 struct ThreadData {
   lldb_private::DataExtractor gpregset;
   lldb_private::DataExtractor fpregset;
   lldb_private::DataExtractor vregset;
   lldb::tid_t tid;
-  int signo;
+  int signo = 0;
+  int prstatus_sig = 0;
   std::string name;
 };
 
 class ThreadElfCore : public lldb_private::Thread {
 public:
   ThreadElfCore(lldb_private::Process &process, const ThreadData &td);
 
   ~ThreadElfCore() override;

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

Error ELFLinuxPrPsInfo::Parse(DataExtractor &data, ArchSpec &arch) {
   default:
     error.SetErrorStringWithFormat("ELFLinuxPrPsInfo::%s Unknown architecture",
                                    __FUNCTION__);
     break;
   }
 
   return error;
 }
+
+//----------------------------------------------------------------
+// Parse SIGINFO from NOTE entry
+//----------------------------------------------------------------
+ELFLinuxSigInfo::ELFLinuxSigInfo() {
+  memset(this, 0, sizeof(ELFLinuxSigInfo));
+}
+
+Error ELFLinuxSigInfo::Parse(DataExtractor &data, const ArchSpec &arch) {
+  Error error;
+  ByteOrder byteorder = data.GetByteOrder();
+  if (GetSize(arch) > data.GetByteSize()) {
+    error.SetErrorStringWithFormat(
+        "NT_SIGINFO size should be %zu, but the remaining bytes are: %" PRIu64,
+        GetSize(arch), data.GetByteSize());
+    return error;
+  }
+
+  switch (arch.GetCore()) {
+  case ArchSpec::eCore_x86_64_x86_64:
+    data.ExtractBytes(0, sizeof(ELFLinuxPrStatus), byteorder, this);
+    break;
+  case ArchSpec::eCore_s390x_generic:
+  case ArchSpec::eCore_x86_32_i386:
+  case ArchSpec::eCore_x86_32_i486: {
+    // 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);
+
+    break;
+  }
+  default:
+    error.SetErrorStringWithFormat("ELFLinuxSigInfo::%s Unknown architecture",
+                                   __FUNCTION__);
+    break;
+  }
+
+  return error;
+}