gdb

* linux-tdep.c (linux_make_siginfo_note): New function.
	(linux_make_corefile_notes): Use it.
	* corelow.c (get_core_siginfo): New function.
	(core_xfer_partial) <TARGET_OBJECT_SIGNAL_INFO>: New case.
gdb/testsuite
	* gdb.base/siginfo-obj.exp: Create core file.  Test siginfo from
	core files, if possible.
	* gdb.base/siginfo-thread.c: New file
	* gdb.base/siginfo-thread.exp: New file
bfd
	* elf.c (elfcore_grok_note) <NT_SIGINFO>: New case; make
	pseudosection.

bfd/ChangeLog

@@ -1,3 +1,8 @@
+2012-11-08  Tom Tromey  <tromey@redhat.com>
+
+	* elf.c (elfcore_grok_note) <NT_SIGINFO>: New case; make
+	pseudosection.
+
 2012-11-08  Alan Modra  <amodra@gmail.com>
 
 	* aclocal.m4: Regenerate.

bfd/elf.c

@@ -8604,6 +8604,10 @@ elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
 
 	return TRUE;
       }
+
+    case NT_SIGINFO:
+      return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
+					      note);
     }
 }
 

gdb/ChangeLog

@@ -1,3 +1,10 @@
+2012-11-08  Tom Tromey  <tromey@redhat.com>
+
+	* linux-tdep.c (linux_make_siginfo_note): New function.
+	(linux_make_corefile_notes): Use it.
+	* corelow.c (get_core_siginfo): New function.
+	(core_xfer_partial) <TARGET_OBJECT_SIGNAL_INFO>: New case.
+
 2012-11-08  Tom Tromey  <tromey@redhat.com>
 
 	PR gdb/14704:

gdb/corelow.c

@@ -656,6 +656,36 @@ add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
   list->pos += 4;
 }
 
+/* Read siginfo data from the core, if possible.  Returns -1 on
+   failure.  Otherwise, returns the number of bytes read.  ABFD is the
+   core file's BFD; READBUF, OFFSET, and LEN are all as specified by
+   the to_xfer_partial interface.  */
+
+static LONGEST
+get_core_siginfo (bfd *abfd, gdb_byte *readbuf, ULONGEST offset, LONGEST len)
+{
+  asection *section;
+  long pid;
+  char *section_name;
+  const char *name = ".note.linuxcore.siginfo";
+
+  if (ptid_get_lwp (inferior_ptid))
+    section_name = xstrprintf ("%s/%ld", name,
+			       ptid_get_lwp (inferior_ptid));
+  else
+    section_name = xstrdup (name);
+
+  section = bfd_get_section_by_name (abfd, section_name);
+  xfree (section_name);
+  if (section == NULL)
+    return -1;
+
+  if (!bfd_get_section_contents (abfd, section, readbuf, offset, len))
+    return -1;
+
+  return len;
+}
+
 static LONGEST
 core_xfer_partial (struct target_ops *ops, enum target_object object,
 		   const char *annex, gdb_byte *readbuf,
@@ -794,6 +824,11 @@ core_xfer_partial (struct target_ops *ops, enum target_object object,
 	}
       return -1;
 
+    case TARGET_OBJECT_SIGNAL_INFO:
+      if (readbuf)
+	return get_core_siginfo (core_bfd, readbuf, offset, len);
+      return -1;
+
     default:
       if (ops->beneath != NULL)
 	return ops->beneath->to_xfer_partial (ops->beneath, object,

gdb/linux-tdep.c

@@ -765,6 +765,44 @@ linux_collect_thread_registers (const struct regcache *regcache,
   return note_data;
 }
 
+/* Fetch the siginfo data for the current thread, if it exists.  If
+   there is no data, or we could not read it, return NULL.  Otherwise,
+   return a newly malloc'd buffer holding the data and fill in *SIZE
+   with the size of the data.  The caller is responsible for freeing
+   the data.  */
+
+static gdb_byte *
+linux_get_siginfo_data (struct gdbarch *gdbarch, LONGEST *size)
+{
+  struct type *siginfo_type;
+  gdb_byte *buf;
+  LONGEST bytes_read;
+  struct cleanup *cleanups;
+
+  if (!gdbarch_get_siginfo_type_p (gdbarch))
+    return NULL;
+  
+  siginfo_type = gdbarch_get_siginfo_type (gdbarch);
+
+  buf = xmalloc (TYPE_LENGTH (siginfo_type));
+  cleanups = make_cleanup (xfree, buf);
+
+  bytes_read = target_read (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
+			    buf, 0, TYPE_LENGTH (siginfo_type));
+  if (bytes_read == TYPE_LENGTH (siginfo_type))
+    {
+      discard_cleanups (cleanups);
+      *size = bytes_read;
+    }
+  else
+    {
+      do_cleanups (cleanups);
+      buf = NULL;
+    }
+
+  return buf;
+}
+
 struct linux_corefile_thread_data
 {
   struct gdbarch *gdbarch;
@@ -789,17 +827,35 @@ linux_corefile_thread_callback (struct thread_info *info, void *data)
     {
       struct cleanup *old_chain;
       struct regcache *regcache;
+      gdb_byte *siginfo_data;
+      LONGEST siginfo_size;
+
       regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
 
       old_chain = save_inferior_ptid ();
       inferior_ptid = info->ptid;
       target_fetch_registers (regcache, -1);
+      siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
       do_cleanups (old_chain);
 
+      old_chain = make_cleanup (xfree, siginfo_data);
+
       args->note_data = args->collect (regcache, info->ptid, args->obfd,
 				       args->note_data, args->note_size,
 				       args->stop_signal);
       args->num_notes++;
+
+      if (siginfo_data != NULL)
+	{
+	  args->note_data = elfcore_write_note (args->obfd,
+						args->note_data,
+						args->note_size,
+						"CORE", NT_SIGINFO,
+						siginfo_data, siginfo_size);
+	  args->num_notes++;
+	}
+
+      do_cleanups (old_chain);
     }
 
   return !args->note_data;

gdb/testsuite/ChangeLog

@@ -1,3 +1,10 @@
+2012-11-08  Tom Tromey  <tromey@redhat.com>
+
+	* gdb.base/siginfo-obj.exp: Create core file.  Test siginfo from
+	core files, if possible.
+	* gdb.base/siginfo-thread.c: New file
+	* gdb.base/siginfo-thread.exp: New file
+
 2012-11-08  Tom Tromey  <tromey@redhat.com>
 
 	* gdb.base/comprdebug.exp: New file.

gdb/testsuite/gdb.base/siginfo-obj.exp

@@ -56,6 +56,10 @@ if { ![runto_main] } then {
 # Run to the signal.
 gdb_test "continue" ".*Program received signal SIGSEGV.*" "continue to signal"
 
+# Try to generate a core file, for a later test.
+set gcorefile [standard_output_file $testfile.gcore]
+set gcore_created [gdb_gcore_cmd $gcorefile "save a core file"]
+
 set ssi_addr ""
 set test "Extract si_addr"
 gdb_test_multiple "p \$_siginfo" "$test" {
@@ -123,3 +127,21 @@ gdb_test "p ssi_addr" " = \\(void \\*\\) 0x666"
 gdb_test "p ssi_errno" " = 666"
 gdb_test "p ssi_code" " = 999"
 gdb_test "p ssi_signo" " = 11"
+
+# Test siginfo preservation in core files.
+if {$gcore_created} {
+    clean_restart $binfile
+
+    gdb_test "core $gcorefile" "Core was generated by.*" \
+	"core [file tail $gcorefile]"
+
+    gdb_test "p \$_siginfo.si_signo" " = $ssi_signo" \
+	"p \$_siginfo.si_signo from core file"
+    gdb_test "p \$_siginfo.si_errno" " = $ssi_errno" \
+	"p \$_siginfo.si_errno from core file"
+    gdb_test "p \$_siginfo.si_code" " = $ssi_code" \
+	"p \$_siginfo.si_code from core file"
+    gdb_test "p \$_siginfo._sifields._sigfault.si_addr" \
+	" = \\(void \\*\\) $ssi_addr" \
+	"p \$_siginfo._sifields._sigfault.si_addr from core file"
+}

gdb/testsuite/gdb.base/siginfo-thread.c

@@ -0,0 +1,83 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2004, 2007-2008, 2010-2012 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <pthread.h>
+
+static void *p;
+
+static void
+handler (int sig, siginfo_t *info, void *context)
+{
+  /* Copy to local vars, as the test wants to read them, and si_addr,
+     etc. may be preprocessor defines.  */
+  int ssi_errno = info->si_errno;
+  int ssi_signo = info->si_signo;
+  int ssi_code = info->si_code;
+  void *ssi_addr = info->si_addr;
+
+  _exit (0); /* set breakpoint here */
+}
+
+static void *
+segv_thread (void *ptr)
+{
+  *(int *)ptr = 0;
+}
+
+int
+main (void)
+{
+  pthread_t thr;
+
+  /* Set up unwritable memory.  */
+  {
+    size_t len;
+    len = sysconf(_SC_PAGESIZE);
+    p = mmap (0, len, PROT_NONE, MAP_ANON|MAP_PRIVATE, -1, 0);
+    if (p == MAP_FAILED)
+      {
+	perror ("mmap");
+	return 1;
+      }
+  }
+  /* Set up the signal handler.  */
+  {
+    struct sigaction action;
+    memset (&action, 0, sizeof (action));
+    action.sa_sigaction = handler;
+    action.sa_flags |= SA_SIGINFO;
+    if (sigaction (SIGSEGV, &action, NULL))
+      {
+	perror ("sigaction");
+	return 1;
+      }
+  }
+
+  /* Create a thread that will trigger SIGSEGV.  */
+  pthread_create (&thr, NULL, segv_thread, p);
+
+  pthread_join (thr, NULL);
+
+  return 0;
+}

gdb/testsuite/gdb.base/siginfo-thread.exp

@@ -0,0 +1,128 @@
+# Copyright 2004, 2007-2008, 2010-2012 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# Multi-threaded siginfo test.
+
+if [target_info exists gdb,nosignals] {
+    verbose "Skipping siginfo-thread.exp because of nosignals."
+    continue
+}
+
+if { ! [istarget "i?86-*-linux*"]
+     && ! [istarget "x86_64-*-linux*"]
+     && ! [istarget "arm*-*-linux*"] } {
+    verbose "Skipping siginfo-thread.exp because of lack of support."
+    return
+}
+
+standard_testfile .c
+
+if  {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" \
+	  "${binfile}" executable {debug}] != "" } {
+    return -1
+}
+
+clean_restart $binfile
+
+# Advance to main
+if { ![runto_main] } then {
+    gdb_suppress_tests
+}
+
+# Run to the signal.
+gdb_test "continue" ".*Program received signal SIGSEGV.*" "continue to signal"
+
+# Try to generate a core file, for a later test.
+set gcorefile [standard_output_file $testfile.gcore]
+set gcore_created [gdb_gcore_cmd $gcorefile "save a core file"]
+
+set ssi_addr ""
+set test "Extract si_addr"
+gdb_test_multiple "p \$_siginfo" "$test" {
+    -re "si_addr = ($hex).*$gdb_prompt $" {
+	set ssi_addr $expect_out(1,string)
+	pass "$test"
+    }
+}
+
+set test "Extract si_errno"
+gdb_test_multiple "p \$_siginfo" "$test" {
+    -re "si_errno = (\[0-9\]\+).*$gdb_prompt $" {
+	set ssi_errno $expect_out(1,string)
+	pass "$test"
+    }
+}
+
+set test "Extract si_code"
+gdb_test_multiple "p \$_siginfo" "$test" {
+    -re "si_code = (\[0-9\]\+).*$gdb_prompt $" {
+	set ssi_code $expect_out(1,string)
+	pass "$test"
+    }
+}
+
+set test "Extract si_signo"
+gdb_test_multiple "p \$_siginfo" "$test" {
+    -re "si_signo = (\[0-9\]\+).*$gdb_prompt $" {
+	set ssi_signo $expect_out(1,string)
+	pass "$test"
+    }
+}
+
+set bp_location [gdb_get_line_number "set breakpoint here"]
+
+gdb_test "break $bp_location"
+gdb_test "continue" ".* handler .*" "continue to handler"
+
+gdb_test "p ssi_addr" " = \\(void \\*\\) $ssi_addr"
+gdb_test "p ssi_errno" " = $ssi_errno"
+gdb_test "p ssi_code" " = $ssi_code"
+gdb_test "p ssi_signo" " = $ssi_signo"
+
+gdb_test "thread 1" ".*"
+# siginfo is available here -- it shows SIGSTOP -- so we test to make
+# sure that we have a different signal from the SEGV thread.
+gdb_test "p \$_siginfo.si_signo == $ssi_signo" " = 0" \
+    "test signal in main thread"
+
+# Test siginfo preservation in core files.
+if {$gcore_created} {
+    clean_restart $binfile
+
+    gdb_test "core $gcorefile" "Core was generated by.*" \
+	"core [file tail $gcorefile]"
+
+    gdb_test "p \$_siginfo.si_signo" " = $ssi_signo" \
+	"p \$_siginfo.si_signo from core file"
+    gdb_test "p \$_siginfo.si_errno" " = $ssi_errno" \
+	"p \$_siginfo.si_errno from core file"
+    gdb_test "p \$_siginfo.si_code" " = $ssi_code" \
+	"p \$_siginfo.si_code from core file"
+    gdb_test "p \$_siginfo._sifields._sigfault.si_addr" \
+	" = \\(void \\*\\) $ssi_addr" \
+	"p \$_siginfo._sifields._sigfault.si_addr from core file"
+
+    # We don't know which thread will be signalled, so we simply
+    # ensure that only one thread got a SEGV.
+    gdb_test_no_output "set variable \$count = 0"
+    foreach thread {1 2} {
+	gdb_test "thread $thread" ".*" "select thread $thread with core file"
+	gdb_test_no_output \
+	    "set variable \$count += (\$_siginfo.si_signo == $ssi_signo)" \
+	    "update counter in thread $thread"
+    }
+    gdb_test "print \$count" " = 1"
+}