[RFA/testsuite] backtrace past pthread_cond_wait()

[RFA/testsuite] backtrace past pthread_cond_wait()

[Joel Brobecker]

[-- Attachment #1: Type: text/plain, Size: 732 bytes --]

Hello,

Re: http://sources.redhat.com/ml/gdb-patches/2003-10/msg00440.html

Here is a new test that would verify that GDB is able to unwind past
pthread_cond_wait(). On my laptop, I get all PASS, while on a RH9.0
machine I get one FAIL.

I am not too familiar with pthreads, so I hope my program is portable.
In particular, I am worried about cygwin... Some guidance would be much
appreciated (in Ada, we use tasks, which syntax and behavior is defined
by the Ada Reference Manual, so the issue about portability is left to
the compiler/runtime developers).

2003-11-19  J. Brobecker  <brobecker@gnat.com>

        * gdb.threads/pt.c: New file.
        * gdb.threads/pthread_cond_wait.exp: New test.

OK to apply?

Thanks,
-- 
Joel

[-- Attachment #2: pt.c --]
[-- Type: text/plain, Size: 1712 bytes --]

/* A small multi-threaded test case.

   Copyright 2003
   Free Software Foundation, Inc.

   This file is part of GDB.

   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 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include <pthread.h>
#include <stdio.h>
#include <time.h>

void
cond_wait (pthread_cond_t *cond, pthread_mutex_t *mut)
{
  pthread_mutex_lock(mut);
  pthread_cond_wait (cond, mut);
  pthread_mutex_unlock (mut);
}

void
noreturn (void)
{
  pthread_mutex_t mut;
  pthread_cond_t cond;

  pthread_mutex_init (&mut, NULL);
  pthread_cond_init (&cond, NULL);

  /* Wait for a condition that will never be signaled, so we effectively
     block the thread here.  */
  cond_wait (&cond, &mut);
}

void *
forever_pthread (void *unused)
{
  noreturn ();
}

void
break_me (void)
{
  /* Just an anchor to help putting a breakpoint.  */
}

int
main (void)
{
  pthread_t forever;
  const struct timespec ts = { 0, 10000000 }; /* 0.01 sec */

  pthread_create (&forever, NULL, forever_pthread, NULL);
  for (;;)
    {
      nanosleep (&ts, NULL);
      break_me();
    }

  return 0;
}


[-- Attachment #3: pthread_cond_wait.exp --]
[-- Type: text/plain, Size: 2572 bytes --]

# Copyright (C) 2003 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 2 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, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

# Please email any bugs, comments, and/or additions to this file to:
# bug-gdb@gnu.org

# This file was written by Joel Brobecker.
#
# It verifies that GDB is able to compute a backtrace for a thread
# being blocked on a call to pthread_cond_wait(). 

if $tracelevel then {
	strace $tracelevel
}

set testfile "pt"
set srcfile ${testfile}.c
set binfile ${objdir}/${subdir}/${testfile}

if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug "incdir=${objdir}"]] != "" } {
    return -1
}

gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
gdb_load ${binfile}

gdb_test "break break_me" \
         "Breakpoint 1 at .*: file .*pt.c, line .*" \
         "breakpoint on break_me"

gdb_test "run" \
         ".*Breakpoint 1, break_me ().*" \
         "run to break_me"

# Depending on the thread implementation (Linux Threads, NPTL, etc...),
# The number of threads known to GDB may vary. We should have at least
# two threads, but we may have more. We want to switch to the pthread
# we created via pthread_create, and its ID should be the highest ID
# of all threads known to GDB.
set thread_id ""
send_gdb "info threads\n"
gdb_expect {
    -re "\s*(\[0-9\]+) Thread.*$gdb_prompt $" {
        set thread_id $expect_out(1,string)
    }
    default {
        fail "Unable to find thread id, defaulting to 2"
        set thread_id "2"
    }
}
    

# Switch to thread 2, which is doing a forever wait...
gdb_test "thread $thread_id" \
         ".*Switching to thread $thread_id.*" \
         "switching to thread $thread_id"

# Verify that we are able to get a sensible backtrace, including
# the frame for the pthread_cond_wait() call.
gdb_test "backtrace" \
         ".*pthread_cond_wait.*cond_wait.*noreturn.*forever_pthread.*" \
         "backtrace in blocked thread"

Re: [RFA/testsuite] backtrace past pthread_cond_wait()

[Joel Brobecker]

Ping?

I know I mentioned the portability issue, but nobody sent any comments.
Let's not let best be the enemy of good: Let's check the test program
as it is now, and we can adjust it later on other platforms as needed.

(I'll have to change the copyright year...)

On Wed, Nov 19, 2003 at 11:34:58PM -0800, Joel Brobecker wrote:
> Hello,
> 
> Re: http://sources.redhat.com/ml/gdb-patches/2003-10/msg00440.html
> 
> Here is a new test that would verify that GDB is able to unwind past
> pthread_cond_wait(). On my laptop, I get all PASS, while on a RH9.0
> machine I get one FAIL.
> 
> I am not too familiar with pthreads, so I hope my program is portable.
> In particular, I am worried about cygwin... Some guidance would be much
> appreciated (in Ada, we use tasks, which syntax and behavior is defined
> by the Ada Reference Manual, so the issue about portability is left to
> the compiler/runtime developers).
> 
> 2003-11-19  J. Brobecker  <brobecker@gnat.com>
> 
>         * gdb.threads/pt.c: New file.
>         * gdb.threads/pthread_cond_wait.exp: New test.
> 
> OK to apply?
> 
> Thanks,
> -- 
> Joel

> /* A small multi-threaded test case.
> 
>    Copyright 2003
>    Free Software Foundation, Inc.
> 
>    This file is part of GDB.
> 
>    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 2 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, write to the Free Software
>    Foundation, Inc., 59 Temple Place - Suite 330,
>    Boston, MA 02111-1307, USA.  */
> 
> #include <pthread.h>
> #include <stdio.h>
> #include <time.h>
> 
> void
> cond_wait (pthread_cond_t *cond, pthread_mutex_t *mut)
> {
>   pthread_mutex_lock(mut);
>   pthread_cond_wait (cond, mut);
>   pthread_mutex_unlock (mut);
> }
> 
> void
> noreturn (void)
> {
>   pthread_mutex_t mut;
>   pthread_cond_t cond;
> 
>   pthread_mutex_init (&mut, NULL);
>   pthread_cond_init (&cond, NULL);
> 
>   /* Wait for a condition that will never be signaled, so we effectively
>      block the thread here.  */
>   cond_wait (&cond, &mut);
> }
> 
> void *
> forever_pthread (void *unused)
> {
>   noreturn ();
> }
> 
> void
> break_me (void)
> {
>   /* Just an anchor to help putting a breakpoint.  */
> }
> 
> int
> main (void)
> {
>   pthread_t forever;
>   const struct timespec ts = { 0, 10000000 }; /* 0.01 sec */
> 
>   pthread_create (&forever, NULL, forever_pthread, NULL);
>   for (;;)
>     {
>       nanosleep (&ts, NULL);
>       break_me();
>     }
> 
>   return 0;
> }
> 

> # Copyright (C) 2003 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 2 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, write to the Free Software
> # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
> 
> # Please email any bugs, comments, and/or additions to this file to:
> # bug-gdb@gnu.org
> 
> # This file was written by Joel Brobecker.
> #
> # It verifies that GDB is able to compute a backtrace for a thread
> # being blocked on a call to pthread_cond_wait(). 
> 
> if $tracelevel then {
> 	strace $tracelevel
> }
> 
> set testfile "pt"
> set srcfile ${testfile}.c
> set binfile ${objdir}/${subdir}/${testfile}
> 
> if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug "incdir=${objdir}"]] != "" } {
>     return -1
> }
> 
> gdb_exit
> gdb_start
> gdb_reinitialize_dir $srcdir/$subdir
> gdb_load ${binfile}
> 
> gdb_test "break break_me" \
>          "Breakpoint 1 at .*: file .*pt.c, line .*" \
>          "breakpoint on break_me"
> 
> gdb_test "run" \
>          ".*Breakpoint 1, break_me ().*" \
>          "run to break_me"
> 
> # Depending on the thread implementation (Linux Threads, NPTL, etc...),
> # The number of threads known to GDB may vary. We should have at least
> # two threads, but we may have more. We want to switch to the pthread
> # we created via pthread_create, and its ID should be the highest ID
> # of all threads known to GDB.
> set thread_id ""
> send_gdb "info threads\n"
> gdb_expect {
>     -re "\s*(\[0-9\]+) Thread.*$gdb_prompt $" {
>         set thread_id $expect_out(1,string)
>     }
>     default {
>         fail "Unable to find thread id, defaulting to 2"
>         set thread_id "2"
>     }
> }
>     
> 
> # Switch to thread 2, which is doing a forever wait...
> gdb_test "thread $thread_id" \
>          ".*Switching to thread $thread_id.*" \
>          "switching to thread $thread_id"
> 
> # Verify that we are able to get a sensible backtrace, including
> # the frame for the pthread_cond_wait() call.
> gdb_test "backtrace" \
>          ".*pthread_cond_wait.*cond_wait.*noreturn.*forever_pthread.*" \
>          "backtrace in blocked thread"
> 


-- 
Joel

Re: [RFA/testsuite] backtrace past pthread_cond_wait()

[Daniel Jacobowitz]

On Wed, Nov 19, 2003 at 11:34:58PM -0800, Joel Brobecker wrote:
> Hello,
> 
> Re: http://sources.redhat.com/ml/gdb-patches/2003-10/msg00440.html
> 
> Here is a new test that would verify that GDB is able to unwind past
> pthread_cond_wait(). On my laptop, I get all PASS, while on a RH9.0
> machine I get one FAIL.

On Debian unstable I get all PASS, with both LinuxThreads and NPTL. 
Not bad.  Didn't even have to use the system's separate debug info
(I keep the debug info in /usr/lib/debug and my test GDB tree pointed
at /usr/local/lib/debug, usually).

> I am not too familiar with pthreads, so I hope my program is
> portable. In particular, I am worried about cygwin... Some guidance
> would be much appreciated (in Ada, we use tasks, which syntax and
> behavior is defined by the Ada Reference Manual, so the issue about
> portability is left to the compiler/runtime developers).
> 
> 2003-11-19  J. Brobecker  <brobecker@gnat.com>
> 
>         * gdb.threads/pt.c: New file.
>         * gdb.threads/pthread_cond_wait.exp: New test.
> 
> OK to apply?

My only complaint is about pt.c - please use a more descriptive name.
The test itself looks OK.  I would be happier if you didn't play games
with info threads; the order in which GDB will discover threads is
actually somewhat random using gdbserver, since new threads are not
notified.  But this should be OK anyway.

Michael Snyder is the listed maintainer of gdb.threads.  Michael?

> 
> Thanks,
> -- 
> Joel

> /* A small multi-threaded test case.
> 
>    Copyright 2003
>    Free Software Foundation, Inc.
> 
>    This file is part of GDB.
> 
>    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 2 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, write to the Free Software
>    Foundation, Inc., 59 Temple Place - Suite 330,
>    Boston, MA 02111-1307, USA.  */
> 
> #include <pthread.h>
> #include <stdio.h>
> #include <time.h>
> 
> void
> cond_wait (pthread_cond_t *cond, pthread_mutex_t *mut)
> {
>   pthread_mutex_lock(mut);
>   pthread_cond_wait (cond, mut);
>   pthread_mutex_unlock (mut);
> }
> 
> void
> noreturn (void)
> {
>   pthread_mutex_t mut;
>   pthread_cond_t cond;
> 
>   pthread_mutex_init (&mut, NULL);
>   pthread_cond_init (&cond, NULL);
> 
>   /* Wait for a condition that will never be signaled, so we effectively
>      block the thread here.  */
>   cond_wait (&cond, &mut);
> }
> 
> void *
> forever_pthread (void *unused)
> {
>   noreturn ();
> }
> 
> void
> break_me (void)
> {
>   /* Just an anchor to help putting a breakpoint.  */
> }
> 
> int
> main (void)
> {
>   pthread_t forever;
>   const struct timespec ts = { 0, 10000000 }; /* 0.01 sec */
> 
>   pthread_create (&forever, NULL, forever_pthread, NULL);
>   for (;;)
>     {
>       nanosleep (&ts, NULL);
>       break_me();
>     }
> 
>   return 0;
> }
> 

> # Copyright (C) 2003 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 2 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, write to the Free Software
> # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
> 
> # Please email any bugs, comments, and/or additions to this file to:
> # bug-gdb@gnu.org
> 
> # This file was written by Joel Brobecker.
> #
> # It verifies that GDB is able to compute a backtrace for a thread
> # being blocked on a call to pthread_cond_wait(). 
> 
> if $tracelevel then {
> 	strace $tracelevel
> }
> 
> set testfile "pt"
> set srcfile ${testfile}.c
> set binfile ${objdir}/${subdir}/${testfile}
> 
> if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug "incdir=${objdir}"]] != "" } {
>     return -1
> }
> 
> gdb_exit
> gdb_start
> gdb_reinitialize_dir $srcdir/$subdir
> gdb_load ${binfile}
> 
> gdb_test "break break_me" \
>          "Breakpoint 1 at .*: file .*pt.c, line .*" \
>          "breakpoint on break_me"
> 
> gdb_test "run" \
>          ".*Breakpoint 1, break_me ().*" \
>          "run to break_me"
> 
> # Depending on the thread implementation (Linux Threads, NPTL, etc...),
> # The number of threads known to GDB may vary. We should have at least
> # two threads, but we may have more. We want to switch to the pthread
> # we created via pthread_create, and its ID should be the highest ID
> # of all threads known to GDB.
> set thread_id ""
> send_gdb "info threads\n"
> gdb_expect {
>     -re "\s*(\[0-9\]+) Thread.*$gdb_prompt $" {
>         set thread_id $expect_out(1,string)
>     }
>     default {
>         fail "Unable to find thread id, defaulting to 2"
>         set thread_id "2"
>     }
> }
>     
> 
> # Switch to thread 2, which is doing a forever wait...
> gdb_test "thread $thread_id" \
>          ".*Switching to thread $thread_id.*" \
>          "switching to thread $thread_id"
> 
> # Verify that we are able to get a sensible backtrace, including
> # the frame for the pthread_cond_wait() call.
> gdb_test "backtrace" \
>          ".*pthread_cond_wait.*cond_wait.*noreturn.*forever_pthread.*" \
>          "backtrace in blocked thread"
> 


-- 
Daniel Jacobowitz
MontaVista Software                         Debian GNU/Linux Developer

Re: [RFA/testsuite] backtrace past pthread_cond_wait()

[Daniel Jacobowitz]

On Wed, Nov 19, 2003 at 11:34:58PM -0800, Joel Brobecker wrote:
> Hello,
> 
> Re: http://sources.redhat.com/ml/gdb-patches/2003-10/msg00440.html
> 
> Here is a new test that would verify that GDB is able to unwind past
> pthread_cond_wait(). On my laptop, I get all PASS, while on a RH9.0
> machine I get one FAIL.

On Debian unstable I get all PASS, with both LinuxThreads and NPTL. 
Not bad.  Didn't even have to use the system's separate debug info
(I keep the debug info in /usr/lib/debug and my test GDB tree pointed
at /usr/local/lib/debug, usually).

> I am not too familiar with pthreads, so I hope my program is
> portable. In particular, I am worried about cygwin... Some guidance
> would be much appreciated (in Ada, we use tasks, which syntax and
> behavior is defined by the Ada Reference Manual, so the issue about
> portability is left to the compiler/runtime developers).
> 
> 2003-11-19  J. Brobecker  <brobecker@gnat.com>
> 
>         * gdb.threads/pt.c: New file.
>         * gdb.threads/pthread_cond_wait.exp: New test.
> 
> OK to apply?

My only complaint is about pt.c - please use a more descriptive name.
The test itself looks OK.  I would be happier if you didn't play games
with info threads; the order in which GDB will discover threads is
actually somewhat random using gdbserver, since new threads are not
notified.  But this should be OK anyway.

Michael Snyder is the listed maintainer of gdb.threads.  Michael?

> 
> Thanks,
> -- 
> Joel

> /* A small multi-threaded test case.
> 
>    Copyright 2003
>    Free Software Foundation, Inc.
> 
>    This file is part of GDB.
> 
>    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 2 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, write to the Free Software
>    Foundation, Inc., 59 Temple Place - Suite 330,
>    Boston, MA 02111-1307, USA.  */
> 
> #include <pthread.h>
> #include <stdio.h>
> #include <time.h>
> 
> void
> cond_wait (pthread_cond_t *cond, pthread_mutex_t *mut)
> {
>   pthread_mutex_lock(mut);
>   pthread_cond_wait (cond, mut);
>   pthread_mutex_unlock (mut);
> }
> 
> void
> noreturn (void)
> {
>   pthread_mutex_t mut;
>   pthread_cond_t cond;
> 
>   pthread_mutex_init (&mut, NULL);
>   pthread_cond_init (&cond, NULL);
> 
>   /* Wait for a condition that will never be signaled, so we effectively
>      block the thread here.  */
>   cond_wait (&cond, &mut);
> }
> 
> void *
> forever_pthread (void *unused)
> {
>   noreturn ();
> }
> 
> void
> break_me (void)
> {
>   /* Just an anchor to help putting a breakpoint.  */
> }
> 
> int
> main (void)
> {
>   pthread_t forever;
>   const struct timespec ts = { 0, 10000000 }; /* 0.01 sec */
> 
>   pthread_create (&forever, NULL, forever_pthread, NULL);
>   for (;;)
>     {
>       nanosleep (&ts, NULL);
>       break_me();
>     }
> 
>   return 0;
> }
> 

> # Copyright (C) 2003 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 2 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, write to the Free Software
> # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
> 
> # Please email any bugs, comments, and/or additions to this file to:
> # bug-gdb@gnu.org
> 
> # This file was written by Joel Brobecker.
> #
> # It verifies that GDB is able to compute a backtrace for a thread
> # being blocked on a call to pthread_cond_wait(). 
> 
> if $tracelevel then {
> 	strace $tracelevel
> }
> 
> set testfile "pt"
> set srcfile ${testfile}.c
> set binfile ${objdir}/${subdir}/${testfile}
> 
> if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug "incdir=${objdir}"]] != "" } {
>     return -1
> }
> 
> gdb_exit
> gdb_start
> gdb_reinitialize_dir $srcdir/$subdir
> gdb_load ${binfile}
> 
> gdb_test "break break_me" \
>          "Breakpoint 1 at .*: file .*pt.c, line .*" \
>          "breakpoint on break_me"
> 
> gdb_test "run" \
>          ".*Breakpoint 1, break_me ().*" \
>          "run to break_me"
> 
> # Depending on the thread implementation (Linux Threads, NPTL, etc...),
> # The number of threads known to GDB may vary. We should have at least
> # two threads, but we may have more. We want to switch to the pthread
> # we created via pthread_create, and its ID should be the highest ID
> # of all threads known to GDB.
> set thread_id ""
> send_gdb "info threads\n"
> gdb_expect {
>     -re "\s*(\[0-9\]+) Thread.*$gdb_prompt $" {
>         set thread_id $expect_out(1,string)
>     }
>     default {
>         fail "Unable to find thread id, defaulting to 2"
>         set thread_id "2"
>     }
> }
>     
> 
> # Switch to thread 2, which is doing a forever wait...
> gdb_test "thread $thread_id" \
>          ".*Switching to thread $thread_id.*" \
>          "switching to thread $thread_id"
> 
> # Verify that we are able to get a sensible backtrace, including
> # the frame for the pthread_cond_wait() call.
> gdb_test "backtrace" \
>          ".*pthread_cond_wait.*cond_wait.*noreturn.*forever_pthread.*" \
>          "backtrace in blocked thread"
> 


-- 
Daniel Jacobowitz
MontaVista Software                         Debian GNU/Linux Developer

Re: [RFA/testsuite] backtrace past pthread_cond_wait()

[Joel Brobecker]

[I just see that this thread has been sitting for over a month without
any response. Gulps, I am really sorry]

> Michael Snyder is the listed maintainer of gdb.threads.  Michael?
Michael, any comments on the patch?

> > 2003-11-19  J. Brobecker  <brobecker@gnat.com>
> > 
> >         * gdb.threads/pt.c: New file.
> >         * gdb.threads/pthread_cond_wait.exp: New test.
> > 
> > OK to apply?
> 
> My only complaint is about pt.c - please use a more descriptive name.

Would pthread_cond_wait.c be a good name (following the usual habit of
making the .c filename identical to the .exp one)?

> The test itself looks OK.  I would be happier if you didn't play games
> with info threads; the order in which GDB will discover threads is
> actually somewhat random using gdbserver, since new threads are not
> notified.  But this should be OK anyway.

Yes, me too. Is there a better way of switching to the thread I'm
looking for? With an Ada program, it would be slightly simpler as
each task (equivalent of a C thread) has a name, and we have a command
"info tasks" that list all tasks with their name and some other info.
So we can match the task by task name, and then switch to that task
using another of our commands: "task <task_no>". I'd prefer to keep
the testcase in C, though, as it makes it much more widely used.

> > /* A small multi-threaded test case.
> > 
> >    Copyright 2003
> >    Free Software Foundation, Inc.
> > 
> >    This file is part of GDB.
> > 
> >    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 2 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, write to the Free Software
> >    Foundation, Inc., 59 Temple Place - Suite 330,
> >    Boston, MA 02111-1307, USA.  */
> > 
> > #include <pthread.h>
> > #include <stdio.h>
> > #include <time.h>
> > 
> > void
> > cond_wait (pthread_cond_t *cond, pthread_mutex_t *mut)
> > {
> >   pthread_mutex_lock(mut);
> >   pthread_cond_wait (cond, mut);
> >   pthread_mutex_unlock (mut);
> > }
> > 
> > void
> > noreturn (void)
> > {
> >   pthread_mutex_t mut;
> >   pthread_cond_t cond;
> > 
> >   pthread_mutex_init (&mut, NULL);
> >   pthread_cond_init (&cond, NULL);
> > 
> >   /* Wait for a condition that will never be signaled, so we effectively
> >      block the thread here.  */
> >   cond_wait (&cond, &mut);
> > }
> > 
> > void *
> > forever_pthread (void *unused)
> > {
> >   noreturn ();
> > }
> > 
> > void
> > break_me (void)
> > {
> >   /* Just an anchor to help putting a breakpoint.  */
> > }
> > 
> > int
> > main (void)
> > {
> >   pthread_t forever;
> >   const struct timespec ts = { 0, 10000000 }; /* 0.01 sec */
> > 
> >   pthread_create (&forever, NULL, forever_pthread, NULL);
> >   for (;;)
> >     {
> >       nanosleep (&ts, NULL);
> >       break_me();
> >     }
> > 
> >   return 0;
> > }
> > 
> 
> > # Copyright (C) 2003 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 2 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, write to the Free Software
> > # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
> > 
> > # Please email any bugs, comments, and/or additions to this file to:
> > # bug-gdb@gnu.org
> > 
> > # This file was written by Joel Brobecker.
> > #
> > # It verifies that GDB is able to compute a backtrace for a thread
> > # being blocked on a call to pthread_cond_wait(). 
> > 
> > if $tracelevel then {
> > 	strace $tracelevel
> > }
> > 
> > set testfile "pt"
> > set srcfile ${testfile}.c
> > set binfile ${objdir}/${subdir}/${testfile}
> > 
> > if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug "incdir=${objdir}"]] != "" } {
> >     return -1
> > }
> > 
> > gdb_exit
> > gdb_start
> > gdb_reinitialize_dir $srcdir/$subdir
> > gdb_load ${binfile}
> > 
> > gdb_test "break break_me" \
> >          "Breakpoint 1 at .*: file .*pt.c, line .*" \
> >          "breakpoint on break_me"
> > 
> > gdb_test "run" \
> >          ".*Breakpoint 1, break_me ().*" \
> >          "run to break_me"
> > 
> > # Depending on the thread implementation (Linux Threads, NPTL, etc...),
> > # The number of threads known to GDB may vary. We should have at least
> > # two threads, but we may have more. We want to switch to the pthread
> > # we created via pthread_create, and its ID should be the highest ID
> > # of all threads known to GDB.
> > set thread_id ""
> > send_gdb "info threads\n"
> > gdb_expect {
> >     -re "\s*(\[0-9\]+) Thread.*$gdb_prompt $" {
> >         set thread_id $expect_out(1,string)
> >     }
> >     default {
> >         fail "Unable to find thread id, defaulting to 2"
> >         set thread_id "2"
> >     }
> > }
> >     
> > 
> > # Switch to thread 2, which is doing a forever wait...
> > gdb_test "thread $thread_id" \
> >          ".*Switching to thread $thread_id.*" \
> >          "switching to thread $thread_id"
> > 
> > # Verify that we are able to get a sensible backtrace, including
> > # the frame for the pthread_cond_wait() call.
> > gdb_test "backtrace" \
> >          ".*pthread_cond_wait.*cond_wait.*noreturn.*forever_pthread.*" \
> >          "backtrace in blocked thread"
> > 
> 
> 
> -- 
> Daniel Jacobowitz
> MontaVista Software                         Debian GNU/Linux Developer

-- 
Joel