/* Thread management interface, for the remote server for GDB.
- Copyright (C) 2002-2017 Free Software Foundation, Inc.
+ Copyright (C) 2002-2018 Free Software Foundation, Inc.
Contributed by MontaVista Software.
#include "nat/gdb_thread_db.h"
#include "gdb_vecs.h"
#include "nat/linux-procfs.h"
+#include "common/scoped_restore.h"
#ifndef USE_LIBTHREAD_DB_DIRECTLY
#include <dlfcn.h>
}
#endif
+/* Get thread info about PTID, accessing memory via the current
+ thread. */
+
static int
find_one_thread (ptid_t ptid)
{
td_thrhandle_t th;
td_thrinfo_t ti;
td_err_e err;
- struct thread_info *inferior;
struct lwp_info *lwp;
struct thread_db *thread_db = current_process ()->priv->thread_db;
int lwpid = ptid_get_lwp (ptid);
- inferior = (struct thread_info *) find_inferior_id (&all_threads, ptid);
- lwp = get_thread_lwp (inferior);
+ thread_info *thread = find_thread_ptid (ptid);
+ lwp = get_thread_lwp (thread);
if (lwp->thread_known)
return 1;
lwp->thread_known = 1;
lwp->th = th;
+ lwp->thread_handle = ti.ti_tid;
return 1;
}
err = linux_attach_lwp (ptid);
if (err != 0)
{
+ std::string reason = linux_ptrace_attach_fail_reason_string (ptid, err);
+
warning ("Could not attach to thread %ld (LWP %d): %s\n",
- (unsigned long) ti_p->ti_tid, ti_p->ti_lid,
- linux_ptrace_attach_fail_reason_string (ptid, err));
+ (unsigned long) ti_p->ti_tid, ti_p->ti_lid, reason.c_str ());
+
return 0;
}
gdb_assert (lwp != NULL);
lwp->thread_known = 1;
lwp->th = *th_p;
+ lwp->thread_handle = ti_p->ti_tid;
return 1;
}
lwp = get_thread_lwp (thread);
if (!lwp->thread_known)
- find_one_thread (thread->entry.id);
+ find_one_thread (thread->id);
if (!lwp->thread_known)
return TD_NOTHR;
return err;
}
+/* See linux-low.h. */
+
+bool
+thread_db_thread_handle (ptid_t ptid, gdb_byte **handle, int *handle_len)
+{
+ struct thread_db *thread_db;
+ struct lwp_info *lwp;
+ thread_info *thread = find_thread_ptid (ptid);
+
+ if (thread == NULL)
+ return false;
+
+ thread_db = get_thread_process (thread)->priv->thread_db;
+
+ if (thread_db == NULL)
+ return false;
+
+ lwp = get_thread_lwp (thread);
+
+ if (!lwp->thread_known && !find_one_thread (thread->id))
+ return false;
+
+ gdb_assert (lwp->thread_known);
+
+ *handle = (gdb_byte *) &lwp->thread_handle;
+ *handle_len = sizeof (lwp->thread_handle);
+ return true;
+}
+
#ifdef USE_LIBTHREAD_DB_DIRECTLY
static int
static int
thread_db_load_search (void)
{
- VEC (char_ptr) *dir_vec;
- char *this_dir;
- int i, rc = 0;
+ int rc = 0;
if (libthread_db_search_path == NULL)
libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
- dir_vec = dirnames_to_char_ptr_vec (libthread_db_search_path);
+ std::vector<gdb::unique_xmalloc_ptr<char>> dir_vec
+ = dirnames_to_char_ptr_vec (libthread_db_search_path);
- for (i = 0; VEC_iterate (char_ptr, dir_vec, i, this_dir); ++i)
+ for (const gdb::unique_xmalloc_ptr<char> &this_dir_up : dir_vec)
{
+ char *this_dir = this_dir_up.get ();
const int pdir_len = sizeof ("$pdir") - 1;
size_t this_dir_len;
}
}
- free_char_ptr_vec (dir_vec);
if (debug_threads)
debug_printf ("thread_db_load_search returning %d\n", rc);
return rc;
return 0;
}
-static int
-any_thread_of (struct inferior_list_entry *entry, void *args)
-{
- int *pid_p = (int *) args;
-
- if (ptid_get_pid (entry->id) == *pid_p)
- return 1;
-
- return 0;
-}
-
static void
switch_to_process (struct process_info *proc)
{
int pid = pid_of (proc);
- current_thread =
- (struct thread_info *) find_inferior (&all_threads,
- any_thread_of, &pid);
+ current_thread = find_any_thread_of_pid (pid);
}
/* Disconnect from libthread_db and free resources. */
/* Tell server.c to perform default processing. */
return 0;
}
+
+/* See linux-low.h. */
+
+void
+thread_db_notice_clone (struct thread_info *parent_thr, ptid_t child_ptid)
+{
+ process_info *parent_proc = get_thread_process (parent_thr);
+ struct thread_db *thread_db = parent_proc->priv->thread_db;
+
+ /* If the thread layer isn't initialized, return. It may just
+ be that the program uses clone, but does not use libthread_db. */
+ if (thread_db == NULL || !thread_db->all_symbols_looked_up)
+ return;
+
+ /* find_one_thread calls into libthread_db which accesses memory via
+ the current thread. Temporarily switch to a thread we know is
+ stopped. */
+ scoped_restore restore_current_thread
+ = make_scoped_restore (¤t_thread, parent_thr);
+
+ if (!find_one_thread (child_ptid))
+ warning ("Cannot find thread after clone.\n");
+}