/* libthread_db assisted debugging support, generic parts.
- Copyright (C) 1999-2001, 2003-2012 Free Software Foundation, Inc.
+ Copyright (C) 1999-2013 Free Software Foundation, Inc.
This file is part of GDB.
#include <dlfcn.h>
#include "gdb_proc_service.h"
#include "gdb_thread_db.h"
-
+#include "gdb_vecs.h"
#include "bfd.h"
#include "command.h"
#include "exceptions.h"
#include "linux-procfs.h"
#include "linux-osdata.h"
#include "auto-load.h"
+#include "cli/cli-utils.h"
#include <signal.h>
#include <ctype.h>
/* If non-zero, print details of libthread_db processing. */
-static int libthread_db_debug;
+static unsigned int libthread_db_debug;
static void
show_libthread_db_debug (struct ui_file *file, int from_tty,
thread_ptid = ptid_build (info->pid, ti.ti_lid, 0);
inout->thread_info = find_thread_ptid (thread_ptid);
- /* In the case of a zombie thread, don't continue. We don't want to
- attach to it thinking it is a new thread. */
- if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
- return TD_THR_ZOMBIE;
-
if (inout->thread_info == NULL)
{
/* New thread. Attach to it now (why wait?). */
return 0;
}
\f
-/* Convert between user-level thread ids and LWP ids. */
+/* Fetch the user-level thread id of PTID. */
-static ptid_t
+static void
thread_from_lwp (ptid_t ptid)
{
td_thrhandle_t th;
error (_("Cannot find user-level thread for LWP %ld: %s"),
GET_LWP (ptid), thread_db_err_str (err));
- /* Fetch the thread info. If we get back TD_THR_ZOMBIE, then the
- event thread has already died. If another gdb interface has called
- thread_alive() previously, the thread won't be found on the thread list
- anymore. In that case, we don't want to process this ptid anymore
- to avoid the possibility of later treating it as a newly
- discovered thread id that we should add to the list. Thus,
- we return a -1 ptid which is also how the thread list marks a
- dead thread. */
+ /* Long-winded way of fetching the thread info. */
io.thread_db_info = info;
io.thread_info = NULL;
- if (thread_get_info_callback (&th, &io) == TD_THR_ZOMBIE
- && io.thread_info == NULL)
- return minus_one_ptid;
-
- gdb_assert (ptid_get_tid (ptid) == 0);
- return ptid;
+ thread_get_info_callback (&th, &io);
}
\f
/* Set up the breakpoint. */
gdb_assert (exec_bfd);
(*bp) = (gdbarch_convert_from_func_ptr_addr
- (target_gdbarch,
+ (target_gdbarch (),
/* Do proper sign extension for the target. */
(bfd_get_sign_extend_vma (exec_bfd) > 0
? (CORE_ADDR) (intptr_t) notify.u.bptaddr
: (CORE_ADDR) (uintptr_t) notify.u.bptaddr),
¤t_target));
- create_thread_event_breakpoint (target_gdbarch, *bp);
+ create_thread_event_breakpoint (target_gdbarch (), *bp);
return TD_OK;
}
If the nptl bug is present in the inferior return 0 to silently ignore
such errors, and let gdb enumerate threads again later. In such case
GDB cannot properly display LWPs if the inferior thread list is
- corrupted. */
+ corrupted. For core files it does not apply, no 'later enumeration'
+ is possible. */
- if (!inferior_has_bug ("nptl_version", 2, 7))
+ if (!target_has_execution || !inferior_has_bug ("nptl_version", 2, 7))
{
exception_fprintf (gdb_stderr, except,
_("Warning: couldn't activate thread debugging "
}
/* Subroutine of try_thread_db_load_from_pdir to simplify it.
- Try loading libthread_db from the same directory as OBJ.
+ Try loading libthread_db in directory(OBJ)/SUBDIR.
+ SUBDIR may be NULL. It may also be something like "../lib64".
The result is true for success. */
static int
-try_thread_db_load_from_pdir_1 (struct objfile *obj)
+try_thread_db_load_from_pdir_1 (struct objfile *obj, const char *subdir)
{
struct cleanup *cleanup;
char *path, *cp;
return 0;
}
- path = xmalloc (strlen (obj->name) + 1 + strlen (LIBTHREAD_DB_SO) + 1);
+ path = xmalloc (strlen (obj->name) + (subdir ? strlen (subdir) + 1 : 0)
+ + 1 + strlen (LIBTHREAD_DB_SO) + 1);
cleanup = make_cleanup (xfree, path);
strcpy (path, obj->name);
cp = strrchr (path, '/');
/* This should at minimum hit the first character. */
gdb_assert (cp != NULL);
- strcpy (cp + 1, LIBTHREAD_DB_SO);
+ cp[1] = '\0';
+ if (subdir != NULL)
+ {
+ strcat (cp, subdir);
+ strcat (cp, "/");
+ }
+ strcat (cp, LIBTHREAD_DB_SO);
if (!file_is_auto_load_safe (path, _("auto-load: Loading libthread-db "
"library \"%s\" from $pdir.\n"),
}
/* Handle $pdir in libthread-db-search-path.
- Look for libthread_db in the directory of libpthread.
+ Look for libthread_db in directory(libpthread)/SUBDIR.
+ SUBDIR may be NULL. It may also be something like "../lib64".
The result is true for success. */
static int
-try_thread_db_load_from_pdir (void)
+try_thread_db_load_from_pdir (const char *subdir)
{
struct objfile *obj;
ALL_OBJFILES (obj)
if (libpthread_name_p (obj->name))
{
- if (try_thread_db_load_from_pdir_1 (obj))
+ if (try_thread_db_load_from_pdir_1 (obj, subdir))
return 1;
/* We may have found the separate-debug-info version of
libpthread, and it may live in a directory without a matching
libthread_db. */
if (obj->separate_debug_objfile_backlink != NULL)
- return try_thread_db_load_from_pdir_1 (obj->separate_debug_objfile_backlink);
+ return try_thread_db_load_from_pdir_1 (obj->separate_debug_objfile_backlink,
+ subdir);
return 0;
}
static int
thread_db_load_search (void)
{
- const char *search_path = libthread_db_search_path;
- int rc = 0;
+ VEC (char_ptr) *dir_vec;
+ struct cleanup *cleanups;
+ char *this_dir;
+ int i, rc = 0;
+
+ dir_vec = dirnames_to_char_ptr_vec (libthread_db_search_path);
+ cleanups = make_cleanup_free_char_ptr_vec (dir_vec);
- while (*search_path)
+ for (i = 0; VEC_iterate (char_ptr, dir_vec, i, this_dir); ++i)
{
- const char *end = strchr (search_path, ':');
- const char *this_dir = search_path;
+ const int pdir_len = sizeof ("$pdir") - 1;
size_t this_dir_len;
- if (end)
- {
- this_dir_len = end - search_path;
- search_path += this_dir_len + 1;
- }
- else
- {
- this_dir_len = strlen (this_dir);
- search_path += this_dir_len;
- }
+ this_dir_len = strlen (this_dir);
- if (this_dir_len == sizeof ("$pdir") - 1
- && strncmp (this_dir, "$pdir", this_dir_len) == 0)
+ if (strncmp (this_dir, "$pdir", pdir_len) == 0
+ && (this_dir[pdir_len] == '\0'
+ || this_dir[pdir_len] == '/'))
{
- if (try_thread_db_load_from_pdir ())
+ char *subdir = NULL;
+ struct cleanup *free_subdir_cleanup
+ = make_cleanup (null_cleanup, NULL);
+
+ if (this_dir[pdir_len] == '/')
{
- rc = 1;
- break;
+ subdir = xmalloc (strlen (this_dir));
+ make_cleanup (xfree, subdir);
+ strcpy (subdir, this_dir + pdir_len + 1);
}
+ rc = try_thread_db_load_from_pdir (subdir);
+ do_cleanups (free_subdir_cleanup);
+ if (rc)
+ break;
}
- else if (this_dir_len == sizeof ("$sdir") - 1
- && strncmp (this_dir, "$sdir", this_dir_len) == 0)
+ else if (strcmp (this_dir, "$sdir") == 0)
{
if (try_thread_db_load_from_sdir ())
{
}
}
+ do_cleanups (cleanups);
if (libthread_db_debug)
printf_unfiltered (_("thread_db_load_search returning %d\n"), rc);
return rc;
if (target_has_execution)
check_thread_signals ();
- if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
- return 0; /* A zombie thread -- do not attach. */
-
/* Under GNU/Linux, we have to attach to each and every thread. */
if (target_has_execution
&& tp == NULL)
gdb_assert (ti_p->ti_tid != 0);
private->th = *th_p;
private->tid = ti_p->ti_tid;
+ if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
+ private->dying = 1;
/* Add the thread to GDB's thread list. */
if (tp == NULL)
if (have_threads (ptid))
{
- /* Change ptids back into the higher level PID + TID format. If
- the thread is dead and no longer on the thread list, we will
- get back a dead ptid. This can occur if the thread death
- event gets postponed by other simultaneous events. In such a
- case, we want to just ignore the event and continue on. */
-
- ptid = thread_from_lwp (ptid);
- if (GET_PID (ptid) == -1)
- ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+ /* Fill in the thread's user-level thread id. */
+ thread_from_lwp (ptid);
}
return ptid;
error (_("find_new_threads_callback: cannot get thread info: %s"),
thread_db_err_str (err));
- if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
- return 0; /* A zombie -- ignore. */
-
if (ti.ti_tid == 0)
{
/* A thread ID of zero means that this is the main thread, but
{
td_err_e err = TD_OK;
struct thread_db_info *info;
- int pid = ptid_get_pid (ptid);
int i, loop;
info = get_thread_db_info (GET_PID (ptid));
char *pids;
int i;
- while (isspace (*cs))
- cs++;
+ cs = skip_spaces_const (cs);
if (*cs)
error (_("'info auto-load libthread-db' does not accept any parameters"));
NULL,
&setlist, &showlist);
- add_setshow_zinteger_cmd ("libthread-db", class_maintenance,
- &libthread_db_debug, _("\
+ add_setshow_zuinteger_cmd ("libthread-db", class_maintenance,
+ &libthread_db_debug, _("\
Set libthread-db debugging."), _("\
Show libthread-db debugging."), _("\
When non-zero, libthread-db debugging is enabled."),
- NULL,
- show_libthread_db_debug,
- &setdebuglist, &showdebuglist);
+ NULL,
+ show_libthread_db_debug,
+ &setdebuglist, &showdebuglist);
add_setshow_boolean_cmd ("libthread-db", class_support,
&auto_load_thread_db, _("\