static int kill_lwp (int lwpid, int signo);
static int stop_callback (struct lwp_info *lp, void *data);
+static int resume_stopped_resumed_lwps (struct lwp_info *lp, void *data);
static void block_child_signals (sigset_t *prev_mask);
static void restore_child_signals_mask (sigset_t *prev_mask);
status = 0;
}
- if (non_stop)
+ /* If the thread_db layer is active, let it record the user
+ level thread id and status, and add the thread to GDB's
+ list. */
+ if (!thread_db_notice_clone (lp->ptid, new_lp->ptid))
{
- /* Add the new thread to GDB's lists as soon as possible
- so that:
-
- 1) the frontend doesn't have to wait for a stop to
- display them, and,
-
- 2) we tag it with the correct running state. */
-
- /* If the thread_db layer is active, let it know about
- this new thread, and add it to GDB's list. */
- if (!thread_db_attach_lwp (new_lp->ptid))
- {
- /* We're not using thread_db. Add it to GDB's
- list. */
- target_post_attach (ptid_get_lwp (new_lp->ptid));
- add_thread (new_lp->ptid);
- }
+ /* The process is not using thread_db. Add the LWP to
+ GDB's list. */
+ target_post_attach (ptid_get_lwp (new_lp->ptid));
+ add_thread (new_lp->ptid);
+ }
- if (!stopping)
- {
- set_running (new_lp->ptid, 1);
- set_executing (new_lp->ptid, 1);
- /* thread_db_attach_lwp -> lin_lwp_attach_lwp forced
- resume_stop. */
- new_lp->last_resume_kind = resume_continue;
- }
+ if (!stopping)
+ {
+ set_running (new_lp->ptid, 1);
+ set_executing (new_lp->ptid, 1);
+ /* thread_db_attach_lwp -> lin_lwp_attach_lwp forced
+ resume_stop. */
+ new_lp->last_resume_kind = resume_continue;
}
if (status != 0)
stop_callback (lwp, NULL);
}
+/* See linux-nat.h */
+
+void
+linux_stop_and_wait_all_lwps (void)
+{
+ /* Stop all LWP's ... */
+ iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
+
+ /* ... and wait until all of them have reported back that
+ they're no longer running. */
+ iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
+}
+
+/* See linux-nat.h */
+
+void
+linux_unstop_all_lwps (void)
+{
+ iterate_over_lwps (minus_one_ptid,
+ resume_stopped_resumed_lwps, &minus_one_ptid);
+}
+
/* Return non-zero if LWP PID has a pending SIGINT. */
static int
static void thread_db_find_new_threads_1 (ptid_t ptid);
static void thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new);
+static void check_thread_signals (void);
+
+static void record_thread (struct thread_db_info *info,
+ struct thread_info *tp,
+ ptid_t ptid, const td_thrhandle_t *th_p,
+ const td_thrinfo_t *ti_p);
+
/* Add the current inferior to the list of processes using libpthread.
Return a pointer to the newly allocated object that was added to
THREAD_DB_LIST. HANDLE is the handle returned by dlopen'ing
return iterate_over_threads (have_threads_callback, &pid) != NULL;
}
-struct thread_get_info_inout
-{
- struct thread_info *thread_info;
- struct thread_db_info *thread_db_info;
-};
-
-/* A callback function for td_ta_thr_iter, which we use to map all
- threads to LWPs.
-
- THP is a handle to the current thread; if INFOP is not NULL, the
- struct thread_info associated with this thread is returned in
- *INFOP.
-
- If the thread is a zombie, TD_THR_ZOMBIE is returned. Otherwise,
- zero is returned to indicate success. */
-
-static int
-thread_get_info_callback (const td_thrhandle_t *thp, void *argp)
-{
- td_thrinfo_t ti;
- td_err_e err;
- ptid_t thread_ptid;
- struct thread_get_info_inout *inout;
- struct thread_db_info *info;
-
- inout = argp;
- info = inout->thread_db_info;
-
- err = info->td_thr_get_info_p (thp, &ti);
- if (err != TD_OK)
- error (_("thread_get_info_callback: cannot get thread info: %s"),
- thread_db_err_str (err));
-
- if (ti.ti_lid == -1)
- {
- /* We'll get this if a threaded program has a thread call clone
- with CLONE_VM. `clone' sets the pthread LID of the new LWP
- to -1, which ends up clearing the parent thread's LID. */
- return 0;
- }
-
- /* Fill the cache. */
- thread_ptid = ptid_build (info->pid, ti.ti_lid, 0);
- inout->thread_info = find_thread_ptid (thread_ptid);
-
- if (inout->thread_info == NULL)
- {
- /* New thread. Attach to it now (why wait?). */
- if (!have_threads (thread_ptid))
- thread_db_find_new_threads_1 (thread_ptid);
- else
- attach_thread (thread_ptid, thp, &ti);
- inout->thread_info = find_thread_ptid (thread_ptid);
- gdb_assert (inout->thread_info != NULL);
- }
-
- return 0;
-}
\f
/* Fetch the user-level thread id of PTID. */
thread_from_lwp (ptid_t ptid)
{
td_thrhandle_t th;
+ td_thrinfo_t ti;
td_err_e err;
struct thread_db_info *info;
- struct thread_get_info_inout io = {0};
+ struct thread_info *tp;
/* Just in case td_ta_map_lwp2thr doesn't initialize it completely. */
th.th_unique = 0;
error (_("Cannot find user-level thread for LWP %ld: %s"),
ptid_get_lwp (ptid), thread_db_err_str (err));
- /* Long-winded way of fetching the thread info. */
- io.thread_db_info = info;
- io.thread_info = NULL;
- thread_get_info_callback (&th, &io);
+ err = info->td_thr_get_info_p (&th, &ti);
+ if (err != TD_OK)
+ error (_("thread_get_info_callback: cannot get thread info: %s"),
+ thread_db_err_str (err));
+
+ /* Fill the cache. */
+ tp = find_thread_ptid (ptid);
+ record_thread (info, tp, ptid, &th, &ti);
}
\f
-/* Attach to lwp PTID, doing whatever else is required to have this
- LWP under the debugger's control --- e.g., enabling event
- reporting. Returns true on success. */
+/* See linux-nat.h. */
+
int
-thread_db_attach_lwp (ptid_t ptid)
+thread_db_notice_clone (ptid_t parent, ptid_t child)
{
td_thrhandle_t th;
td_thrinfo_t ti;
td_err_e err;
struct thread_db_info *info;
- info = get_thread_db_info (ptid_get_pid (ptid));
+ info = get_thread_db_info (ptid_get_pid (child));
if (info == NULL)
return 0;
- /* This ptid comes from linux-nat.c, which should always fill in the
- LWP. */
- gdb_assert (ptid_get_lwp (ptid) != 0);
+ thread_from_lwp (child);
- /* Access an lwp we know is stopped. */
- info->proc_handle.ptid = ptid;
-
- /* If we have only looked at the first thread before libpthread was
- initialized, we may not know its thread ID yet. Make sure we do
- before we add another thread to the list. */
- if (!have_threads (ptid))
- thread_db_find_new_threads_1 (ptid);
-
- err = info->td_ta_map_lwp2thr_p (info->thread_agent, ptid_get_lwp (ptid),
- &th);
- if (err != TD_OK)
- /* Cannot find user-level thread. */
- return 0;
-
- err = info->td_thr_get_info_p (&th, &ti);
- if (err != TD_OK)
- {
- warning (_("Cannot get thread info: %s"), thread_db_err_str (err));
- return 0;
- }
-
- attach_thread (ptid, &th, &ti);
+ /* If we do not know about the main thread yet, this would be a good
+ time to find it. */
+ thread_from_lwp (parent);
return 1;
}
info->td_thr_tls_get_addr_p = dlsym (info->handle, "td_thr_tls_get_addr");
info->td_thr_tlsbase_p = dlsym (info->handle, "td_thr_tlsbase");
- if (thread_db_find_new_threads_silently (inferior_ptid) != 0)
+ /* It's best to avoid td_ta_thr_iter if possible. That walks data
+ structures in the inferior's address space that may be corrupted,
+ or, if the target is running, may change while we walk them. If
+ there's execution (and /proc is mounted), then we're already
+ attached to all LWPs. Use thread_from_lwp, which uses
+ td_ta_map_lwp2thr instead, which does not walk the thread list.
+
+ td_ta_map_lwp2thr uses ps_get_thread_area, but we can't use that
+ currently on core targets, as it uses ptrace directly. */
+ if (target_has_execution
+ && linux_proc_task_list_dir_exists (ptid_get_pid (inferior_ptid)))
+ {
+ struct lwp_info *lp;
+ int pid = ptid_get_pid (inferior_ptid);
+
+ linux_stop_and_wait_all_lwps ();
+
+ ALL_LWPS (lp)
+ if (ptid_get_pid (lp->ptid) == pid)
+ thread_from_lwp (lp->ptid);
+
+ linux_unstop_all_lwps ();
+ }
+ else if (thread_db_find_new_threads_silently (inferior_ptid) != 0)
{
/* Even if libthread_db initializes, if the thread list is
corrupted, we'd not manage to list any threads. Better reject this
attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
const td_thrinfo_t *ti_p)
{
- struct private_thread_info *private;
struct thread_info *tp;
- td_err_e err;
struct thread_db_info *info;
/* If we're being called after a TD_CREATE event, we may already
}
}
- if (target_has_execution)
- check_thread_signals ();
-
/* Under GNU/Linux, we have to attach to each and every thread. */
if (target_has_execution
&& tp == NULL)
/* Otherwise, we sucessfully attached to the thread. */
}
+ info = get_thread_db_info (ptid_get_pid (ptid));
+ record_thread (info, tp, ptid, th_p, ti_p);
+ return 1;
+}
+
+/* Record a new thread in GDB's thread list. Creates the thread's
+ private info. If TP is NULL, creates a new thread. Otherwise,
+ uses TP. */
+
+static void
+record_thread (struct thread_db_info *info,
+ struct thread_info *tp,
+ ptid_t ptid, const td_thrhandle_t *th_p,
+ const td_thrinfo_t *ti_p)
+{
+ td_err_e err;
+ struct private_thread_info *private;
+ int new_thread = (tp == NULL);
+
+ /* A thread ID of zero may mean the thread library has not
+ initialized yet. Leave private == NULL until the thread library
+ has initialized. */
+ if (ti_p->ti_tid == 0)
+ return;
+
/* Construct the thread's private data. */
private = xmalloc (sizeof (struct private_thread_info));
memset (private, 0, sizeof (struct private_thread_info));
- /* A thread ID of zero may mean the thread library has not initialized
- yet. But we shouldn't even get here if that's the case. FIXME:
- if we change GDB to always have at least one thread in the thread
- list this will have to go somewhere else; maybe private == NULL
- until the thread_db target claims it. */
- gdb_assert (ti_p->ti_tid != 0);
private->th = *th_p;
private->tid = ti_p->ti_tid;
update_thread_state (private, ti_p);
/* Add the thread to GDB's thread list. */
if (tp == NULL)
- add_thread_with_info (ptid, private);
+ tp = add_thread_with_info (ptid, private);
else
tp->private = private;
- info = get_thread_db_info (ptid_get_pid (ptid));
-
/* Enable thread event reporting for this thread, except when
debugging a core file. */
- if (target_has_execution && thread_db_use_events ())
+ if (target_has_execution && thread_db_use_events () && new_thread)
{
err = info->td_thr_event_enable_p (th_p, 1);
if (err != TD_OK)
target_pid_to_str (ptid), thread_db_err_str (err));
}
- return 1;
+ if (target_has_execution)
+ check_thread_signals ();
}
static void
return 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 (ptid))
- thread_db_find_new_threads_1 (ptid);
-
if (ourstatus->kind == TARGET_WAITKIND_STOPPED
&& ourstatus->value.sig == GDB_SIGNAL_TRAP)
/* Check for a thread event. */
check_event (ptid);
- if (have_threads (ptid))
- {
- /* Fill in the thread's user-level thread id. */
- thread_from_lwp (ptid);
- }
+ /* Fill in the thread's user-level thread id and status. */
+ thread_from_lwp (ptid);
return ptid;
}
data.info = info;
data.new_threads = 0;
+ /* See comment in thread_db_update_thread_list. */
+ gdb_assert (!target_has_execution || thread_db_use_events ());
+
TRY_CATCH (except, RETURN_MASK_ERROR)
{
/* Iterate over all user-space threads to discover new threads. */
return 0;
}
+/* Update the thread list using td_ta_thr_iter. */
+
static void
-thread_db_update_thread_list (struct target_ops *ops)
+thread_db_update_thread_list_td_ta_thr_iter (struct target_ops *ops)
{
struct thread_db_info *info;
struct inferior *inf;
thread_db_find_new_threads_1 (thread->ptid);
}
+}
+
+/* Implement the to_update_thread_list target method for this
+ target. */
+
+static void
+thread_db_update_thread_list (struct target_ops *ops)
+{
+ /* It's best to avoid td_ta_thr_iter if possible. That walks data
+ structures in the inferior's address space that may be corrupted,
+ or, if the target is running, the list may change while we walk
+ it. In the latter case, it's possible that a thread exits just
+ at the exact time that causes GDB to get stuck in an infinite
+ loop. To avoid pausing all threads whenever the core wants to
+ refresh the thread list, if the kernel supports clone events
+ (meaning we're always already attached to all LWPs), we use
+ thread_from_lwp immediately when we see an LWP stop. That uses
+ thread_db entry points that do not walk libpthread's thread list,
+ so should be safe, as well as more efficient. */
+ if (target_has_execution && !thread_db_use_events ())
+ ops->beneath->to_update_thread_list (ops->beneath);
+ else
+ thread_db_update_thread_list_td_ta_thr_iter (ops);
if (target_has_execution)
iterate_over_lwps (minus_one_ptid /* iterate over all */,
return beneath->to_get_thread_local_address (beneath, ptid, lm, offset);
}
-/* Callback routine used to find a thread based on the TID part of
- its PTID. */
-
-static int
-thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
-{
- long *tid = (long *) data;
-
- if (thread->private->tid == *tid)
- return 1;
-
- return 0;
-}
-
/* Implement the to_get_ada_task_ptid target method for this target. */
static ptid_t
thread_db_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
{
- struct thread_info *thread_info;
-
- thread_db_find_new_threads_1 (inferior_ptid);
- thread_info = iterate_over_threads (thread_db_find_thread_from_tid, &thread);
-
- gdb_assert (thread_info != NULL);
-
- return (thread_info->ptid);
+ /* NPTL uses a 1:1 model, so the LWP id suffices. */
+ return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0);
}
static void
projects / external / binutils.git / commitdiff