From: Tom Tromey Date: Thu, 8 Nov 2012 21:16:43 +0000 (+0000) Subject: gdb X-Git-Tag: cgen-snapshot-20121201~206 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=9015683b1c9a8d301cd846fcc8bf73726310bd4f;p=external%2Fbinutils.git 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) : 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) : New case; make pseudosection. --- diff --git a/bfd/ChangeLog b/bfd/ChangeLog index d472c5d..4d32f21 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,8 @@ +2012-11-08 Tom Tromey + + * elf.c (elfcore_grok_note) : New case; make + pseudosection. + 2012-11-08 Alan Modra * aclocal.m4: Regenerate. diff --git a/bfd/elf.c b/bfd/elf.c index cab1cc7..4465f48 100644 --- a/bfd/elf.c +++ b/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); } } diff --git a/gdb/ChangeLog b/gdb/ChangeLog index a099c37..5a2260b 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,12 @@ 2012-11-08 Tom Tromey + * 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) : New case. + +2012-11-08 Tom Tromey + PR gdb/14704: * gdb_bfd.c (gdb_bfd_ref): Set BFD_DECOMPRESS. (zlib_decompress_section): Remove. diff --git a/gdb/corelow.c b/gdb/corelow.c index 2080068..99611ba 100644 --- a/gdb/corelow.c +++ b/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, diff --git a/gdb/linux-tdep.c b/gdb/linux-tdep.c index 65f5f97..f02d510 100644 --- a/gdb/linux-tdep.c +++ b/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 (¤t_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; diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 689cbd4..5ff056c 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,5 +1,12 @@ 2012-11-08 Tom Tromey + * 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 + * gdb.base/comprdebug.exp: New file. 2012-11-06 Pedro Alves diff --git a/gdb/testsuite/gdb.base/siginfo-obj.exp b/gdb/testsuite/gdb.base/siginfo-obj.exp index 9ca649d..c6ab6ff 100644 --- a/gdb/testsuite/gdb.base/siginfo-obj.exp +++ b/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" +} diff --git a/gdb/testsuite/gdb.base/siginfo-thread.c b/gdb/testsuite/gdb.base/siginfo-thread.c new file mode 100644 index 0000000..a47bcb3 --- /dev/null +++ b/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 . + +*/ + +#include +#include +#include +#include +#include +#include + +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; +} diff --git a/gdb/testsuite/gdb.base/siginfo-thread.exp b/gdb/testsuite/gdb.base/siginfo-thread.exp new file mode 100644 index 0000000..315ac01 --- /dev/null +++ b/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 . + + +# 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" +}