/* libthread_db assisted debugging support, generic parts.
- Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2006
+ Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
This file is part of GDB.
#include "regcache.h"
#include "solib-svr4.h"
#include "gdbcore.h"
+#include "observer.h"
#include "linux-nat.h"
+#include <signal.h>
+
#ifdef HAVE_GNU_LIBC_VERSION_H
#include <gnu/libc-version.h>
#endif
/* If we're running on GNU/Linux, we must explicitly attach to any new
threads. */
-/* FIXME: There is certainly some room for improvements:
- - Cache LWP ids.
- - Bypass libthread_db when fetching or storing registers for
- threads bound to a LWP. */
-
/* This module's target vector. */
static struct target_ops thread_db_ops;
/* The target vector that we call for things this module can't handle. */
static struct target_ops *target_beneath;
-/* Pointer to the next function on the objfile event chain. */
-static void (*target_new_objfile_chain) (struct objfile * objfile);
-
/* Non-zero if we're using this module's target vector. */
static int using_thread_db;
static td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
static td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
td_thrinfo_t *infop);
-static td_err_e (*td_thr_getfpregs_p) (const td_thrhandle_t *th,
- gdb_prfpregset_t *regset);
-static td_err_e (*td_thr_getgregs_p) (const td_thrhandle_t *th,
- prgregset_t gregs);
-static td_err_e (*td_thr_setfpregs_p) (const td_thrhandle_t *th,
- const gdb_prfpregset_t *fpregs);
-static td_err_e (*td_thr_setgregs_p) (const td_thrhandle_t *th,
- prgregset_t gregs);
static td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th,
int event);
return "only part of register set was written/read";
case TD_NOXREGS:
return "X register set not available for this thread";
+#ifdef THREAD_DB_HAS_TD_NOTALLOC
+ case TD_NOTALLOC:
+ return "thread has not yet allocated TLS for given module";
+#endif
+#ifdef THREAD_DB_HAS_TD_VERSION
+ case TD_VERSION:
+ return "versions of libpthread and libthread_db do not match";
+#endif
+#ifdef THREAD_DB_HAS_TD_NOTLS
+ case TD_NOTLS:
+ return "there is no TLS segment in the given module";
+#endif
default:
snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
return buf;
}
}
+\f
+/* Return 1 if any threads have been registered. There may be none if
+ the threading library is not fully initialized yet. */
-static char *
-thread_db_state_str (td_thr_state_e state)
+static int
+have_threads_callback (struct thread_info *thread, void *dummy)
{
- static char buf[64];
+ return 1;
+}
- switch (state)
- {
- case TD_THR_STOPPED:
- return "stopped by debugger";
- case TD_THR_RUN:
- return "runnable";
- case TD_THR_ACTIVE:
- return "active";
- case TD_THR_ZOMBIE:
- return "zombie";
- case TD_THR_SLEEP:
- return "sleeping";
- case TD_THR_STOPPED_ASLEEP:
- return "stopped by debugger AND blocked";
- default:
- snprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
- return buf;
- }
+static int
+have_threads (void)
+{
+ return iterate_over_threads (have_threads_callback, NULL) != NULL;
}
-\f
+
/* A callback function for td_ta_thr_iter, which we use to map all
threads to LWPs.
else
thread_info->private->th_valid = 1;
}
-
-static td_thrinfo_t *
-thread_db_get_info (struct thread_info *thread_info)
-{
- td_err_e err;
-
- if (thread_info->private->ti_valid)
- return &thread_info->private->ti;
-
- if (!thread_info->private->th_valid)
- thread_db_map_id2thr (thread_info, 1);
-
- err =
- td_thr_get_info_p (&thread_info->private->th, &thread_info->private->ti);
- if (err != TD_OK)
- error (_("thread_db_get_info: cannot get thread info: %s"),
- thread_db_err_str (err));
-
- thread_info->private->ti_valid = 1;
- return &thread_info->private->ti;
-}
\f
/* Convert between user-level thread ids and LWP ids. */
if (td_thr_get_info_p == NULL)
return 0;
- td_thr_getfpregs_p = verbose_dlsym (handle, "td_thr_getfpregs");
- if (td_thr_getfpregs_p == NULL)
- return 0;
-
- td_thr_getgregs_p = verbose_dlsym (handle, "td_thr_getgregs");
- if (td_thr_getgregs_p == NULL)
- return 0;
-
- td_thr_setfpregs_p = verbose_dlsym (handle, "td_thr_setfpregs");
- if (td_thr_setfpregs_p == NULL)
- return 0;
-
- td_thr_setgregs_p = verbose_dlsym (handle, "td_thr_setgregs");
- if (td_thr_setgregs_p == NULL)
- return 0;
-
/* Initialize the library. */
err = td_init_p ();
if (err != TD_OK)
td_event_addset (&events, TD_CREATE);
#ifdef HAVE_GNU_LIBC_VERSION_H
- /* FIXME: kettenis/2000-04-23: The event reporting facility is
- broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
- now. */
+ /* The event reporting facility is broken for TD_DEATH events in
+ glibc 2.1.3, so don't enable it if we have glibc but a lower
+ version. */
libc_version = gnu_get_libc_version ();
if (sscanf (libc_version, "%d.%d", &libc_major, &libc_minor) == 2
&& (libc_major > 2 || (libc_major == 2 && libc_minor > 1)))
td_err_e err;
static int already_loaded;
+ /* Do nothing if we couldn't load libthread_db.so.1. */
+ if (td_ta_new_p == NULL)
+ return;
+
/* First time through, report that libthread_db was successfuly
loaded. Can't print this in in thread_db_load as, at that stage,
the interpreter and it's console haven't started. */
if (!target_has_execution)
return;
+ /* Don't attempt to use thread_db for remote targets. */
+ if (!target_can_run (¤t_target))
+ return;
+
/* Initialize the structure that identifies the child process. */
proc_handle.pid = GET_PID (inferior_ptid);
{
if (objfile != NULL)
check_for_thread_db ();
-
- if (target_new_objfile_chain)
- target_new_objfile_chain (objfile);
}
/* Attach to a new thread. This function is called when we receive a
check_thread_signals ();
+ if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
+ return; /* A zombie thread -- do not attach. */
+
+ /* Under GNU/Linux, we have to attach to each and every thread. */
+ if (lin_lwp_attach_lwp (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)), 0) < 0)
+ return;
+
/* Add the thread to GDB's thread list. */
tp = add_thread (ptid);
tp->private = xmalloc (sizeof (struct private_thread_info));
if (verbose)
printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid));
- if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
- return; /* A zombie thread -- do not attach. */
-
- /* Under GNU/Linux, we have to attach to each and every thread. */
-#ifdef ATTACH_LWP
- ATTACH_LWP (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)), 0);
-#endif
-
/* Enable thread event reporting for this thread. */
err = td_thr_event_enable_p (th_p, 1);
if (err != TD_OK)
target_pid_to_str (ptid), thread_db_err_str (err));
}
-static void
-thread_db_attach (char *args, int from_tty)
-{
- target_beneath->to_attach (args, from_tty);
-
- /* Destroy thread info; it's no longer valid. */
- init_thread_list ();
-
- /* The child process is now the actual multi-threaded
- program. Snatch its process ID... */
- proc_handle.pid = GET_PID (inferior_ptid);
-
- /* ...and perform the remaining initialization steps. */
- enable_thread_event_reporting ();
- thread_db_find_new_threads ();
-}
-
static void
detach_thread (ptid_t ptid, int verbose)
{
disable_thread_event_reporting ();
/* There's no need to save & restore inferior_ptid here, since the
- inferior is supposed to be survive this function call. */
+ inferior is not supposed to survive this function call. */
inferior_ptid = lwp_from_thread (inferior_ptid);
- /* Forget about the child's process ID. We shouldn't need it
- anymore. */
- proc_handle.pid = 0;
-
target_beneath->to_detach (args, from_tty);
+
+ /* Should this be done by detach_command? */
+ target_mourn_inferior ();
}
static int
int loop = 0;
/* Bail out early if we're not at a thread event breakpoint. */
- stop_pc = read_pc_pid (ptid) - DECR_PC_AFTER_BREAK;
+ stop_pc = read_pc_pid (ptid) - gdbarch_decr_pc_after_break (current_gdbarch);
if (stop_pc != td_create_bp_addr && stop_pc != td_death_bp_addr)
return;
ptid = target_beneath->to_wait (ptid, ourstatus);
- if (proc_handle.pid == 0)
- /* The current child process isn't the actual multi-threaded
- program yet, so don't try to do any special thread-specific
- post-processing and bail out early. */
- return ptid;
-
- if (ourstatus->kind == TARGET_WAITKIND_EXITED)
+ if (ourstatus->kind == TARGET_WAITKIND_EXITED
+ || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
return pid_to_ptid (-1);
- if (ourstatus->kind == TARGET_WAITKIND_STOPPED
- && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
- /* Check for a thread event. */
- check_event (ptid);
-
- if (!ptid_equal (trap_ptid, null_ptid))
- trap_ptid = thread_from_lwp (trap_ptid);
-
- /* Change the ptid 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;
-
- return ptid;
-}
-
-static LONGEST
-thread_db_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
-{
- struct cleanup *old_chain = save_inferior_ptid ();
- LONGEST xfer;
-
- if (is_thread (inferior_ptid))
+ if (ourstatus->kind == TARGET_WAITKIND_EXECD)
{
- /* FIXME: This seems to be necessary to make sure breakpoints
- are removed. */
- if (!target_thread_alive (inferior_ptid))
- inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
- else
- inferior_ptid = lwp_from_thread (inferior_ptid);
- }
-
- xfer = target_beneath->to_xfer_partial (ops, object, annex,
- readbuf, writebuf, offset, len);
-
- do_cleanups (old_chain);
- return xfer;
-}
+ remove_thread_event_breakpoints ();
+ unpush_target (&thread_db_ops);
+ using_thread_db = 0;
-static void
-thread_db_fetch_registers (int regno)
-{
- struct thread_info *thread_info;
- prgregset_t gregset;
- gdb_prfpregset_t fpregset;
- td_err_e err;
-
- if (!is_thread (inferior_ptid))
- {
- /* Pass the request to the target beneath us. */
- target_beneath->to_fetch_registers (regno);
- return;
+ return pid_to_ptid (GET_PID (ptid));
}
- thread_info = find_thread_pid (inferior_ptid);
- thread_db_map_id2thr (thread_info, 1);
-
- err = td_thr_getgregs_p (&thread_info->private->th, gregset);
- if (err != TD_OK)
- error (_("Cannot fetch general-purpose registers for thread %ld: %s"),
- (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
-
- err = td_thr_getfpregs_p (&thread_info->private->th, &fpregset);
- if (err != TD_OK)
- error (_("Cannot get floating-point registers for thread %ld: %s"),
- (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
-
- /* Note that we must call supply_gregset after calling the thread_db
- routines because the thread_db routines call ps_lgetgregs and
- friends which clobber GDB's register cache. */
- supply_gregset ((gdb_gregset_t *) gregset);
- supply_fpregset (&fpregset);
-}
-
-static void
-thread_db_store_registers (int regno)
-{
- prgregset_t gregset;
- gdb_prfpregset_t fpregset;
- td_err_e err;
- struct thread_info *thread_info;
-
- if (!is_thread (inferior_ptid))
- {
- /* Pass the request to the target beneath us. */
- target_beneath->to_store_registers (regno);
- return;
- }
+ /* If we do not know about the main thread yet, this would be a good time to
+ find it. */
+ if (ourstatus->kind == TARGET_WAITKIND_STOPPED && !have_threads ())
+ thread_db_find_new_threads ();
- thread_info = find_thread_pid (inferior_ptid);
- thread_db_map_id2thr (thread_info, 1);
+ if (ourstatus->kind == TARGET_WAITKIND_STOPPED
+ && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
+ /* Check for a thread event. */
+ check_event (ptid);
- if (regno != -1)
+ if (have_threads ())
{
- gdb_byte raw[MAX_REGISTER_SIZE];
-
- deprecated_read_register_gen (regno, raw);
- thread_db_fetch_registers (-1);
- regcache_raw_supply (current_regcache, regno, raw);
+ /* 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. */
+
+ if (!ptid_equal (trap_ptid, null_ptid))
+ trap_ptid = thread_from_lwp (trap_ptid);
+
+ ptid = thread_from_lwp (ptid);
+ if (GET_PID (ptid) == -1)
+ ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
}
- fill_gregset ((gdb_gregset_t *) gregset, -1);
- fill_fpregset (&fpregset, -1);
-
- err = td_thr_setgregs_p (&thread_info->private->th, gregset);
- if (err != TD_OK)
- error (_("Cannot store general-purpose registers for thread %ld: %s"),
- (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
- err = td_thr_setfpregs_p (&thread_info->private->th, &fpregset);
- if (err != TD_OK)
- error (_("Cannot store floating-point registers for thread %ld: %s"),
- (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
+ return ptid;
}
static void
target_beneath->to_kill ();
}
-static void
-thread_db_create_inferior (char *exec_file, char *allargs, char **env,
- int from_tty)
-{
- unpush_target (&thread_db_ops);
- using_thread_db = 0;
- target_beneath->to_create_inferior (exec_file, allargs, env, from_tty);
-}
-
-static void
-thread_db_post_startup_inferior (ptid_t ptid)
-{
- if (proc_handle.pid == 0)
- {
- /* The child process is now the actual multi-threaded
- program. Snatch its process ID... */
- proc_handle.pid = GET_PID (ptid);
-
- /* ...and perform the remaining initialization steps. */
- enable_thread_event_reporting ();
- thread_db_find_new_threads ();
- }
-}
-
static void
thread_db_mourn_inferior (void)
{
using_thread_db = 0;
}
-static int
-thread_db_thread_alive (ptid_t ptid)
-{
- td_thrhandle_t th;
- td_err_e err;
-
- if (is_thread (ptid))
- {
- struct thread_info *thread_info;
- thread_info = find_thread_pid (ptid);
-
- thread_db_map_id2thr (thread_info, 0);
- if (!thread_info->private->th_valid)
- return 0;
-
- err = td_thr_validate_p (&thread_info->private->th);
- if (err != TD_OK)
- return 0;
-
- if (!thread_info->private->ti_valid)
- {
- err =
- td_thr_get_info_p (&thread_info->private->th,
- &thread_info->private->ti);
- if (err != TD_OK)
- return 0;
- thread_info->private->ti_valid = 1;
- }
-
- if (thread_info->private->ti.ti_state == TD_THR_UNKNOWN
- || thread_info->private->ti.ti_state == TD_THR_ZOMBIE)
- return 0; /* A zombie thread. */
-
- return 1;
- }
-
- if (target_beneath->to_thread_alive)
- return target_beneath->to_thread_alive (ptid);
-
- return 0;
-}
-
static int
find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
{
ptid = ptid_build (GET_PID (inferior_ptid), ti.ti_lid, ti.ti_tid);
+ if (ti.ti_tid == 0)
+ {
+ /* A thread ID of zero means that this is the main thread, but
+ glibc has not yet initialized thread-local storage and the
+ pthread library. We do not know what the thread's TID will
+ be yet. Just enable event reporting and otherwise ignore
+ it. */
+
+ err = td_thr_event_enable_p (th_p, 1);
+ if (err != TD_OK)
+ error (_("Cannot enable thread event reporting for %s: %s"),
+ target_pid_to_str (ptid), thread_db_err_str (err));
+
+ return 0;
+ }
+
if (!in_thread_list (ptid))
attach_thread (ptid, th_p, &ti, 1);
if (is_thread (ptid))
{
static char buf[64];
- td_thrinfo_t *ti_p;
- td_err_e err;
struct thread_info *thread_info;
thread_info = find_thread_pid (ptid);
- thread_db_map_id2thr (thread_info, 0);
- if (!thread_info->private->th_valid)
- {
- snprintf (buf, sizeof (buf), "Thread %ld (Missing)",
- GET_THREAD (ptid));
- return buf;
- }
-
- ti_p = thread_db_get_info (thread_info);
-
- if (ti_p->ti_state == TD_THR_ACTIVE && ti_p->ti_lid != 0)
- {
- snprintf (buf, sizeof (buf), "Thread %ld (LWP %d)",
- (long) ti_p->ti_tid, ti_p->ti_lid);
- }
+ if (thread_info == NULL)
+ snprintf (buf, sizeof (buf), "Thread 0x%lx (LWP %ld) (Missing)",
+ GET_THREAD (ptid), GET_LWP (ptid));
else
- {
- snprintf (buf, sizeof (buf), "Thread %ld (%s)",
- (long) ti_p->ti_tid,
- thread_db_state_str (ti_p->ti_state));
- }
+ snprintf (buf, sizeof (buf), "Thread 0x%lx (LWP %ld)",
+ GET_THREAD (ptid), GET_LWP (ptid));
return buf;
}
return normal_pid_to_str (ptid);
}
+/* Return a string describing the state of the thread specified by
+ INFO. */
+
+static char *
+thread_db_extra_thread_info (struct thread_info *info)
+{
+ if (info->private->dying)
+ return "Exiting";
+
+ return NULL;
+}
+
+/* Return 1 if this thread has the same LWP as the passed PTID. */
+
+static int
+same_ptid_callback (struct thread_info *thread, void *arg)
+{
+ ptid_t *ptid_p = arg;
+
+ return GET_LWP (thread->ptid) == GET_LWP (*ptid_p);
+}
+
/* Get the address of the thread local variable in load module LM which
is stored at OFFSET within the thread local storage for thread PTID. */
CORE_ADDR lm,
CORE_ADDR offset)
{
+ /* If we have not discovered any threads yet, check now. */
+ if (!is_thread (ptid) && !have_threads ())
+ thread_db_find_new_threads ();
+
+ /* Try to find a matching thread if we still have the LWP ID instead
+ of the thread ID. */
+ if (!is_thread (ptid))
+ {
+ struct thread_info *thread;
+
+ thread = iterate_over_threads (same_ptid_callback, &ptid);
+ if (thread != NULL)
+ ptid = thread->ptid;
+ }
+
if (is_thread (ptid))
{
td_err_e err;
/* Get info about the thread. */
thread_info = find_thread_pid (ptid);
+ gdb_assert (thread_info);
thread_db_map_id2thr (thread_info, 1);
/* Finally, get the address of the variable. */
- err = td_thr_tls_get_addr_p (&thread_info->private->th, (void *) lm,
+ err = td_thr_tls_get_addr_p (&thread_info->private->th,
+ (void *)(size_t) lm,
offset, &address);
#ifdef THREAD_DB_HAS_TD_NOTALLOC
thread_db_ops.to_shortname = "multi-thread";
thread_db_ops.to_longname = "multi-threaded child process.";
thread_db_ops.to_doc = "Threads and pthreads support.";
- thread_db_ops.to_attach = thread_db_attach;
thread_db_ops.to_detach = thread_db_detach;
thread_db_ops.to_resume = thread_db_resume;
thread_db_ops.to_wait = thread_db_wait;
- thread_db_ops.to_fetch_registers = thread_db_fetch_registers;
- thread_db_ops.to_store_registers = thread_db_store_registers;
- thread_db_ops.to_xfer_partial = thread_db_xfer_partial;
thread_db_ops.to_kill = thread_db_kill;
- thread_db_ops.to_create_inferior = thread_db_create_inferior;
- thread_db_ops.to_post_startup_inferior = thread_db_post_startup_inferior;
thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
- thread_db_ops.to_thread_alive = thread_db_thread_alive;
thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
thread_db_ops.to_stratum = thread_stratum;
thread_db_ops.to_has_thread_control = tc_schedlock;
thread_db_ops.to_get_thread_local_address
= thread_db_get_thread_local_address;
+ thread_db_ops.to_extra_thread_info = thread_db_extra_thread_info;
thread_db_ops.to_magic = OPS_MAGIC;
}
add_target (&thread_db_ops);
/* Add ourselves to objfile event chain. */
- target_new_objfile_chain = deprecated_target_new_objfile_hook;
- deprecated_target_new_objfile_hook = thread_db_new_objfile;
+ observer_attach_new_objfile (thread_db_new_objfile);
}
}