/* Connection to the libthread_db library. */
static td_thragent_t *thread_agent;
+static void thread_db_find_new_threads (void);
static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data);
static char *
td_event_msg_t msg;
td_err_e err;
struct inferior_linux_data *tdata;
+ struct thread_info *inferior;
+ struct process_info *process;
if (debug_threads)
fprintf (stderr, "Thread creation event.\n");
fprintf (stderr, "thread getmsg err: %s\n",
thread_db_err_str (err));
+ /* If we do not know about the main thread yet, this would be a good time to
+ find it. We need to do this to pick up the main thread before any newly
+ created threads. */
+ inferior = (struct thread_info *) all_threads.head;
+ process = get_thread_process (inferior);
+ if (process->thread_known == 0)
+ thread_db_find_new_threads ();
+
/* msg.event == TD_EVENT_CREATE */
find_new_threads_callback (msg.th_p, NULL);
{
inferior = (struct thread_info *) all_threads.head;
process = get_thread_process (inferior);
+
if (process->thread_known == 0)
{
+ /* If the new thread ID is zero, a final thread ID will be
+ available later. Do not enable thread debugging yet. */
+ if (ti_p->ti_tid == 0)
+ {
+ err = td_thr_event_enable (th_p, 1);
+ if (err != TD_OK)
+ error ("Cannot enable thread event reporting for %d: %s",
+ ti_p->ti_lid, thread_db_err_str (err));
+ return;
+ }
+
+ if (process->lwpid != ti_p->ti_lid)
+ fatal ("PID mismatch! Expected %ld, got %ld",
+ (long) process->lwpid, (long) ti_p->ti_lid);
+
/* Switch to indexing the threads list by TID. */
change_inferior_id (&all_threads, ti_p->ti_tid);
goto found;
process = get_thread_process (thread);
if (!process->thread_known)
+ thread_db_find_new_threads ();
+ if (!process->thread_known)
return TD_NOTHR;
/* Note the cast through uintptr_t: this interface only works if
}
}
\f
+/* Return 1 if any threads have been registered. There may be none if
+ the threading library is not fully initialized yet. */
+
+static int
+have_threads_callback (struct thread_info *thread, void *dummy)
+{
+ return 1;
+}
+
+static int
+have_threads (void)
+{
+ return iterate_over_threads (have_threads_callback, NULL) != NULL;
+}
+
/* A callback function for td_ta_thr_iter, which we use to map all
threads to LWPs.
}
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)
{
struct thread_info *thread_info;
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
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
|| ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
return pid_to_ptid (-1);
return pid_to_ptid (GET_PID (ptid));
}
+ /* 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 ();
+
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);
+ if (have_threads ())
+ {
+ /* 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;
+ }
- /* 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 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)
{
/* Forget about the child's process ID. We shouldn't need it
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);
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;
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_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_find_new_threads = thread_db_find_new_threads;
thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
projects / platform / upstream / binutils.git / commitdiff