From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 2944 invoked by alias); 2 Nov 2012 19:32:22 -0000 Received: (qmail 2936 invoked by uid 22791); 2 Nov 2012 19:32:21 -0000 X-SWARE-Spam-Status: No, hits=-6.9 required=5.0 tests=AWL,BAYES_00,KHOP_RCVD_UNTRUST,KHOP_SPAMHAUS_DROP,RCVD_IN_DNSWL_HI,RCVD_IN_HOSTKARMA_W,RP_MATCHES_RCVD,SPF_HELO_PASS,TW_EG X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 02 Nov 2012 19:32:15 +0000 Received: from int-mx02.intmail.prod.int.phx2.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id qA2JWEs7002828 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Fri, 2 Nov 2012 15:32:14 -0400 Received: from barimba (ovpn01.gateway.prod.ext.phx2.redhat.com [10.5.9.1]) by int-mx02.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id qA2JWBKI016313 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES128-SHA bits=128 verify=NO); Fri, 2 Nov 2012 15:32:12 -0400 From: Tom Tromey To: Pedro Alves Cc: gdb-patches@sourceware.org Subject: Re: RFC: handle new NT_SIGINFO note in gdb References: <878vanyj3k.fsf__16012.8015945249$1351617533$gmane$org@fleche.redhat.com> <87d2zxrvuw.fsf@fleche.redhat.com> <87390rq319.fsf@fleche.redhat.com> <509418AC.2060404@redhat.com> Date: Fri, 02 Nov 2012 19:32:00 -0000 In-Reply-To: <509418AC.2060404@redhat.com> (Pedro Alves's message of "Fri, 02 Nov 2012 19:02:04 +0000") Message-ID: <87liejol6s.fsf@fleche.redhat.com> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.2 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2012-11/txt/msg00069.txt.bz2 >>>>> "Pedro" == Pedro Alves writes: Pedro> I think here should be $ssi_signo, not $ssi_errno. Sad oversight on my part. Thanks. Pedro> GDB makes no effort to make sure the the signaled thread Pedro> is the first dumped thread. Thanks. Here's an update. This takes a bit of a brute force approach to testing that just one thread got a SEGV. Tom 2012-11-02 Tom Tromey * elf.c (elfcore_grok_note) : New case; make pseudosection. 2012-11-02 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-02 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 --- bfd/ChangeLog | 5 + bfd/elf.c | 4 + gdb/ChangeLog | 7 ++ gdb/corelow.c | 35 ++++++++ gdb/linux-tdep.c | 56 +++++++++++++ gdb/testsuite/ChangeLog | 7 ++ gdb/testsuite/gdb.base/siginfo-obj.exp | 22 +++++ gdb/testsuite/gdb.base/siginfo-thread.c | 83 +++++++++++++++++++ gdb/testsuite/gdb.base/siginfo-thread.exp | 128 +++++++++++++++++++++++++++++ 9 files changed, 347 insertions(+), 0 deletions(-) create mode 100644 gdb/testsuite/gdb.base/siginfo-thread.c create mode 100644 gdb/testsuite/gdb.base/siginfo-thread.exp 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/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/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" +} -- 1.7.7.6