/* libthread_db assisted debugging support, generic parts.
- Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
- 2010 Free Software Foundation, Inc.
+ Copyright (C) 1999-2001, 2003-2012 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcore.h"
#include "observer.h"
#include "linux-nat.h"
+#include "linux-procfs.h"
+#include "linux-osdata.h"
+#include "auto-load.h"
#include <signal.h>
+#include <ctype.h>
#ifdef HAVE_GNU_LIBC_VERSION_H
#include <gnu/libc-version.h>
static char *libthread_db_search_path;
+/* Set to non-zero if thread_db auto-loading is enabled
+ by the "set auto-load libthread-db" command. */
+static int auto_load_thread_db = 1;
+
+/* "show" command for the auto_load_thread_db configuration variable. */
+
+static void
+show_auto_load_thread_db (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Auto-loading of inferior specific libthread_db "
+ "is %s.\n"),
+ value);
+}
+
+static void
+set_libthread_db_search_path (char *ignored, int from_tty,
+ struct cmd_list_element *c)
+{
+ if (*libthread_db_search_path == '\0')
+ {
+ xfree (libthread_db_search_path);
+ libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
+ }
+}
+
+/* If non-zero, print details of libthread_db processing. */
+
+static int libthread_db_debug;
+
+static void
+show_libthread_db_debug (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("libthread-db debugging is %s.\n"), value);
+}
+
/* If we're running on GNU/Linux, we must explicitly attach to any new
threads. */
/* Handle from dlopen for libthread_db.so. */
void *handle;
+ /* Absolute pathname from gdb_realpath to disk file used for dlopen-ing
+ HANDLE. It may be NULL for system library. */
+ char *filename;
+
/* Structure that identifies the child process for the
<proc_service.h> interface. */
struct ps_prochandle proc_handle;
static struct thread_db_info *
add_thread_db_info (void *handle)
{
- int pid;
struct thread_db_info *info;
info = xcalloc (1, sizeof (*info));
info->pid = ptid_get_pid (inferior_ptid);
info->handle = handle;
- info->need_stale_parent_threads_check = 1;
+
+ /* The workaround works by reading from /proc/pid/status, so it is
+ disabled for core files. */
+ if (target_has_execution)
+ info->need_stale_parent_threads_check = 1;
info->next = thread_db_list;
thread_db_list = info;
if (info->handle != NULL)
dlclose (info->handle);
+ xfree (info->filename);
+
if (info_prev)
info_prev->next = info->next;
else
have_threads_callback (struct thread_info *thread, void *args)
{
int pid = * (int *) args;
+
if (ptid_get_pid (thread->ptid) != pid)
return 0;
{
td_thrhandle_t th;
td_err_e err;
- ptid_t thread_ptid;
struct thread_db_info *info;
struct thread_get_info_inout io = {0};
+ /* Just in case td_ta_map_lwp2thr doesn't initialize it completely. */
+ th.th_unique = 0;
+
/* This ptid comes from linux-nat.c, which should always fill in the
LWP. */
gdb_assert (GET_LWP (ptid) != 0);
{
void *sym = dlsym (handle, name);
if (sym == NULL)
- warning (_("Symbol \"%s\" not found in libthread_db: %s"), name, dlerror ());
+ warning (_("Symbol \"%s\" not found in libthread_db: %s"),
+ name, dlerror ());
return sym;
}
enable_thread_event_reporting (void)
{
td_thr_events_t events;
- td_notify_t notify;
td_err_e err;
#ifdef HAVE_GNU_LIBC_VERSION_H
const char *libc_version;
thread_db_find_new_threads_2 (ptid, 1);
}
- if (except.reason < 0 && info_verbose)
- {
- exception_fprintf (gdb_stderr, except,
- "Warning: thread_db_find_new_threads_silently: ");
- }
+ if (except.reason < 0 && libthread_db_debug)
+ {
+ exception_fprintf (gdb_stderr, except,
+ "Warning: thread_db_find_new_threads_silently: ");
+ }
}
/* Lookup a library in which given symbol resides.
return NULL;
}
-/* Attempt to initialize dlopen()ed libthread_db, described by HANDLE.
+/* Attempt to initialize dlopen()ed libthread_db, described by INFO.
Return 1 on success.
Failure could happen if libthread_db does not have symbols we expect,
or when it refuses to work with the current inferior (e.g. due to
err = info->td_init_p ();
if (err != TD_OK)
{
- warning (_("Cannot initialize libthread_db: %s"), thread_db_err_str (err));
+ warning (_("Cannot initialize libthread_db: %s"),
+ thread_db_err_str (err));
return 0;
}
err = info->td_ta_new_p (&info->proc_handle, &info->thread_agent);
if (err != TD_OK)
{
- if (info_verbose)
+ if (libthread_db_debug)
printf_unfiltered (_("td_ta_new failed: %s\n"),
thread_db_err_str (err));
else
if (info->td_ta_map_id2thr_p == NULL)
return 0;
- info->td_ta_map_lwp2thr_p = verbose_dlsym (info->handle, "td_ta_map_lwp2thr");
+ info->td_ta_map_lwp2thr_p = verbose_dlsym (info->handle,
+ "td_ta_map_lwp2thr");
if (info->td_ta_map_lwp2thr_p == NULL)
return 0;
printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
- if (info_verbose || *libthread_db_search_path)
+ if (libthread_db_debug || *libthread_db_search_path)
{
const char *library;
if (thread_db_list->next == NULL)
push_target (&thread_db_ops);
- enable_thread_event_reporting ();
+ /* Enable event reporting, but not when debugging a core file. */
+ if (target_has_execution)
+ enable_thread_event_reporting ();
/* There appears to be a bug in glibc-2.3.6: calls to td_thr_get_info fail
with TD_ERR for statically linked executables if td_thr_get_info is
void *handle;
struct thread_db_info *info;
- if (info_verbose)
+ if (libthread_db_debug)
printf_unfiltered (_("Trying host libthread_db library: %s.\n"),
library);
handle = dlopen (library, RTLD_NOW);
if (handle == NULL)
{
- if (info_verbose)
+ if (libthread_db_debug)
printf_unfiltered (_("dlopen failed: %s.\n"), dlerror ());
return 0;
}
- if (info_verbose && strchr (library, '/') == NULL)
+ if (libthread_db_debug && strchr (library, '/') == NULL)
{
void *td_init;
info = add_thread_db_info (handle);
+ /* Do not save system library name, that one is always trusted. */
+ if (strchr (library, '/') != NULL)
+ info->filename = gdb_realpath (library);
+
if (try_thread_db_load_1 (info))
return 1;
return 0;
}
+/* Subroutine of try_thread_db_load_from_pdir to simplify it.
+ Try loading libthread_db from the same directory as OBJ.
+ The result is true for success. */
+
+static int
+try_thread_db_load_from_pdir_1 (struct objfile *obj)
+{
+ struct cleanup *cleanup;
+ char *path, *cp;
+ int result;
+
+ if (obj->name[0] != '/')
+ {
+ warning (_("Expected absolute pathname for libpthread in the"
+ " inferior, but got %s."), obj->name);
+ return 0;
+ }
+
+ path = xmalloc (strlen (obj->name) + 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);
+
+ if (!file_is_auto_load_safe (path, _("auto-load: Loading libthread-db "
+ "library \"%s\" from $pdir.\n"),
+ path))
+ result = 0;
+ else
+ result = try_thread_db_load (path);
+
+ do_cleanups (cleanup);
+ return result;
+}
+
+/* Handle $pdir in libthread-db-search-path.
+ Look for libthread_db in the directory of libpthread.
+ The result is true for success. */
+
+static int
+try_thread_db_load_from_pdir (void)
+{
+ struct objfile *obj;
+
+ if (!auto_load_thread_db)
+ return 0;
+
+ ALL_OBJFILES (obj)
+ if (libpthread_name_p (obj->name))
+ {
+ if (try_thread_db_load_from_pdir_1 (obj))
+ 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 0;
+ }
+
+ return 0;
+}
+
+/* Handle $sdir in libthread-db-search-path.
+ Look for libthread_db in the system dirs, or wherever a plain
+ dlopen(file_without_path) will look.
+ The result is true for success. */
+
+static int
+try_thread_db_load_from_sdir (void)
+{
+ return try_thread_db_load (LIBTHREAD_DB_SO);
+}
+
+/* Try to load libthread_db from directory DIR of length DIR_LEN.
+ The result is true for success. */
+
+static int
+try_thread_db_load_from_dir (const char *dir, size_t dir_len)
+{
+ struct cleanup *cleanup;
+ char *path;
+ int result;
+
+ if (!auto_load_thread_db)
+ return 0;
+
+ path = xmalloc (dir_len + 1 + strlen (LIBTHREAD_DB_SO) + 1);
+ cleanup = make_cleanup (xfree, path);
+
+ memcpy (path, dir, dir_len);
+ path[dir_len] = '/';
+ strcpy (path + dir_len + 1, LIBTHREAD_DB_SO);
+
+ if (!file_is_auto_load_safe (path, _("auto-load: Loading libthread-db "
+ "library \"%s\" from explicit "
+ "directory.\n"),
+ path))
+ result = 0;
+ else
+ result = try_thread_db_load (path);
+
+ do_cleanups (cleanup);
+ return result;
+}
/* Search libthread_db_search_path for libthread_db which "agrees"
- to work on current inferior. */
+ to work on current inferior.
+ The result is true for success. */
static int
thread_db_load_search (void)
{
- char path[PATH_MAX];
const char *search_path = libthread_db_search_path;
int rc = 0;
while (*search_path)
{
const char *end = strchr (search_path, ':');
+ const char *this_dir = search_path;
+ size_t this_dir_len;
+
if (end)
{
- size_t len = end - search_path;
- if (len + 1 + strlen (LIBTHREAD_DB_SO) + 1 > sizeof (path))
- {
- char *cp = xmalloc (len + 1);
- memcpy (cp, search_path, len);
- cp[len] = '\0';
- warning (_("libthread_db_search_path component too long,"
- " ignored: %s."), cp);
- xfree (cp);
- search_path += len + 1;
- continue;
- }
- memcpy (path, search_path, len);
- path[len] = '\0';
- search_path += len + 1;
+ this_dir_len = end - search_path;
+ search_path += this_dir_len + 1;
}
else
{
- size_t len = strlen (search_path);
+ this_dir_len = strlen (this_dir);
+ search_path += this_dir_len;
+ }
- if (len + 1 + strlen (LIBTHREAD_DB_SO) + 1 > sizeof (path))
- {
- warning (_("libthread_db_search_path component too long,"
- " ignored: %s."), search_path);
- break;
- }
- memcpy (path, search_path, len + 1);
- search_path += len;
+ if (this_dir_len == sizeof ("$pdir") - 1
+ && strncmp (this_dir, "$pdir", this_dir_len) == 0)
+ {
+ if (try_thread_db_load_from_pdir ())
+ {
+ rc = 1;
+ break;
+ }
}
- strcat (path, "/");
- strcat (path, LIBTHREAD_DB_SO);
- if (try_thread_db_load (path))
+ else if (this_dir_len == sizeof ("$sdir") - 1
+ && strncmp (this_dir, "$sdir", this_dir_len) == 0)
{
- rc = 1;
- break;
+ if (try_thread_db_load_from_sdir ())
+ {
+ rc = 1;
+ break;
+ }
+ }
+ else
+ {
+ if (try_thread_db_load_from_dir (this_dir, this_dir_len))
+ {
+ rc = 1;
+ break;
+ }
}
}
- if (rc == 0)
- rc = try_thread_db_load (LIBTHREAD_DB_SO);
+
+ if (libthread_db_debug)
+ printf_unfiltered (_("thread_db_load_search returning %d\n"), rc);
return rc;
}
+/* Return non-zero if the inferior has a libpthread. */
+
+static int
+has_libpthread (void)
+{
+ struct objfile *obj;
+
+ ALL_OBJFILES (obj)
+ if (libpthread_name_p (obj->name))
+ return 1;
+
+ return 0;
+}
+
/* Attempt to load and initialize libthread_db.
- Return 1 on success.
- */
+ Return 1 on success. */
static int
thread_db_load (void)
{
- struct objfile *obj;
struct thread_db_info *info;
info = get_thread_db_info (GET_PID (inferior_ptid));
if (info != NULL)
return 1;
- /* Don't attempt to use thread_db on targets which can not run
- (executables not running yet, core files) for now. */
- if (!target_has_execution)
+ /* Don't attempt to use thread_db on executables not running
+ yet. */
+ if (!target_has_registers)
return 0;
/* Don't attempt to use thread_db for remote targets. */
- if (!target_can_run (¤t_target))
+ if (!(target_can_run (¤t_target) || core_bfd))
return 0;
if (thread_db_load_search ())
return 1;
- /* None of the libthread_db's on our search path, not the system default
- ones worked. If the executable is dynamically linked against
- libpthread, try loading libthread_db from the same directory. */
-
- ALL_OBJFILES (obj)
- if (libpthread_name_p (obj->name))
- {
- char path[PATH_MAX], *cp;
-
- gdb_assert (strlen (obj->name) < sizeof (path));
- strcpy (path, obj->name);
- cp = strrchr (path, '/');
-
- if (cp == NULL)
- {
- warning (_("Expected absolute pathname for libpthread in the"
- " inferior, but got %s."), path);
- }
- else if (cp + 1 + strlen (LIBTHREAD_DB_SO) + 1 > path + sizeof (path))
- {
- warning (_("Unexpected: path to libpthread in the inferior is"
- " too long: %s"), path);
- }
- else
- {
- strcpy (cp + 1, LIBTHREAD_DB_SO);
- if (try_thread_db_load (path))
- return 1;
- }
- warning (_("Unable to find libthread_db matching inferior's thread"
- " library, thread debugging will not be available."));
- return 0;
+ /* We couldn't find a libthread_db.
+ If the inferior has a libpthread warn the user. */
+ if (has_libpthread ())
+ {
+ warning (_("Unable to find libthread_db matching inferior's thread"
+ " library, thread debugging will not be available."));
+ return 0;
}
+
/* Either this executable isn't using libpthread at all, or it is
statically linked. Since we can't easily distinguish these two cases,
no warning is issued. */
static void
check_thread_signals (void)
{
-#ifdef GET_THREAD_SIGNALS
if (!thread_signals)
{
sigset_t mask;
int i;
- GET_THREAD_SIGNALS (&mask);
+ lin_thread_get_thread_signals (&mask);
sigemptyset (&thread_stop_set);
sigemptyset (&thread_print_set);
{
if (sigismember (&mask, i))
{
- if (signal_stop_update (target_signal_from_host (i), 0))
+ if (signal_stop_update (gdb_signal_from_host (i), 0))
sigaddset (&thread_stop_set, i);
- if (signal_print_update (target_signal_from_host (i), 0))
+ if (signal_print_update (gdb_signal_from_host (i), 0))
sigaddset (&thread_print_set, i);
thread_signals = 1;
}
}
}
-#endif
}
/* Check whether thread_db is usable. This function is called when
void
check_for_thread_db (void)
{
- td_err_e err;
- static void *last_loaded;
-
/* Do nothing if we couldn't load libthread_db.so.1. */
if (!thread_db_load ())
return;
}
+/* This function is called via the new_objfile observer. */
+
static void
thread_db_new_objfile (struct objfile *objfile)
{
/* This observer must always be called with inferior_ptid set
correctly. */
- if (objfile != NULL)
+ if (objfile != NULL
+ /* Only check for thread_db if we loaded libpthread,
+ or if this is the main symbol file.
+ We need to check OBJF_MAINLINE to handle the case of debugging
+ a statically linked executable AND the symbol file is specified AFTER
+ the exec file is loaded (e.g., gdb -c core ; file foo).
+ For dynamically linked executables, libpthread can be near the end
+ of the list of shared libraries to load, and in an app of several
+ thousand shared libraries, this can otherwise be painful. */
+ && ((objfile->flags & OBJF_MAINLINE) != 0
+ || libpthread_name_p (objfile->name)))
check_for_thread_db ();
}
+/* This function is called via the inferior_created observer.
+ This handles the case of debugging statically linked executables. */
+
+static void
+thread_db_inferior_created (struct target_ops *target, int from_tty)
+{
+ check_for_thread_db ();
+}
+
/* Attach to a new thread. This function is called when we receive a
TD_CREATE event or when we iterate over all threads and find one
that wasn't already in our list. Returns true on success. */
const td_thrinfo_t *ti_p)
{
struct private_thread_info *private;
- struct thread_info *tp = NULL;
+ struct thread_info *tp;
td_err_e err;
struct thread_db_info *info;
thread ID. In the first case we don't need to do anything; in
the second case we should discard information about the dead
thread and attach to the new one. */
- if (in_thread_list (ptid))
+ tp = find_thread_ptid (ptid);
+ if (tp != NULL)
{
- tp = find_thread_ptid (ptid);
- gdb_assert (tp != NULL);
-
/* If tp->private is NULL, then GDB is already attached to this
thread, but we do not know anything about it. We can learn
about it here. This can only happen if we have some other
}
}
- check_thread_signals ();
+ 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 (tp == NULL
- && lin_lwp_attach_lwp (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid))) < 0)
- return 0;
+ if (target_has_execution
+ && tp == NULL)
+ {
+ int res;
+
+ res = lin_lwp_attach_lwp (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)));
+ if (res < 0)
+ {
+ /* Error, stop iterating. */
+ return 0;
+ }
+ else if (res > 0)
+ {
+ /* Pretend this thread doesn't exist yet, and keep
+ iterating. */
+ return 1;
+ }
+
+ /* Otherwise, we sucessfully attached to the thread. */
+ }
/* Construct the thread's private data. */
private = xmalloc (sizeof (struct private_thread_info));
/* Add the thread to GDB's thread list. */
if (tp == NULL)
- tp = add_thread_with_info (ptid, private);
+ add_thread_with_info (ptid, private);
else
tp->private = private;
info = get_thread_db_info (GET_PID (ptid));
- /* Enable thread event reporting for this thread. */
- err = info->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));
+ /* Enable thread event reporting for this thread, except when
+ debugging a core file. */
+ if (target_has_execution)
+ {
+ err = info->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 1;
}
if (info)
{
- disable_thread_event_reporting (info);
-
- /* Delete the old thread event breakpoints. Note that unlike
- when mourning, we can remove them here because there's still
- a live inferior to poke at. In any case, GDB will not try to
- insert anything in the inferior when removing a
- breakpoint. */
- remove_thread_event_breakpoints ();
+ if (target_has_execution)
+ {
+ disable_thread_event_reporting (info);
+
+ /* Delete the old thread event breakpoints. Note that
+ unlike when mourning, we can remove them here because
+ there's still a live inferior to poke at. In any case,
+ GDB will not try to insert anything in the inferior when
+ removing a breakpoint. */
+ remove_thread_event_breakpoints ();
+ }
delete_thread_db_info (GET_PID (inferior_ptid));
}
thread_db_find_new_threads_1 (ptid);
if (ourstatus->kind == TARGET_WAITKIND_STOPPED
- && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
+ && ourstatus->value.sig == GDB_SIGNAL_TRAP)
/* Check for a thread event. */
check_event (ptid);
need this glibc bug workaround. */
info->need_stale_parent_threads_check = 0;
- err = info->td_thr_event_enable_p (th_p, 1);
- if (err != TD_OK)
- error (_("Cannot enable thread event reporting for LWP %d: %s"),
- (int) ti.ti_lid, thread_db_err_str (err));
+ if (target_has_execution)
+ {
+ err = info->td_thr_event_enable_p (th_p, 1);
+ if (err != TD_OK)
+ error (_("Cannot enable thread event reporting for LWP %d: %s"),
+ (int) ti.ti_lid, thread_db_err_str (err));
+ }
return 0;
}
if (info->need_stale_parent_threads_check)
{
int tgid = linux_proc_get_tgid (ti.ti_lid);
+
if (tgid != -1 && tgid != info->pid)
return 0;
}
TD_THR_ANY_USER_FLAGS);
}
- if (info_verbose)
+ if (libthread_db_debug)
{
if (except.reason < 0)
exception_fprintf (gdb_stderr, except,
thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new)
{
td_err_e err;
- struct lwp_info *lp;
struct thread_db_info *info;
int pid = ptid_get_pid (ptid);
int i, loop;
- /* In linux, we can only read memory through a stopped lwp. */
- ALL_LWPS (lp, ptid)
- if (lp->stopped && ptid_get_pid (lp->ptid) == pid)
- break;
-
- if (!lp)
- /* There is no stopped thread. Bail out. */
- return;
-
info = get_thread_db_info (GET_PID (ptid));
/* Access an lwp we know is stopped. */
}
else
{
- td_err_e err;
-
find_new_threads_once (info, 0, &err);
if (err != TD_OK)
error (_("Cannot find new threads: %s"), thread_db_err_str (err));
static int
update_thread_core (struct lwp_info *info, void *closure)
{
- info->core = linux_nat_core_of_thread_1 (info->ptid);
+ info->core = linux_common_core_of_thread (info->ptid);
return 0;
}
thread_db_find_new_threads (struct target_ops *ops)
{
struct thread_db_info *info;
+ struct inferior *inf;
- info = get_thread_db_info (GET_PID (inferior_ptid));
+ ALL_INFERIORS (inf)
+ {
+ struct thread_info *thread;
- if (info == NULL)
- return;
+ if (inf->pid == 0)
+ continue;
- thread_db_find_new_threads_1 (inferior_ptid);
+ info = get_thread_db_info (inf->pid);
+ if (info == NULL)
+ continue;
+
+ thread = any_live_thread_of_process (inf->pid);
+ if (thread == NULL || thread->executing)
+ continue;
+
+ thread_db_find_new_threads_1 (thread->ptid);
+ }
- iterate_over_lwps (minus_one_ptid /* iterate over all */,
- update_thread_core, NULL);
+ if (target_has_execution)
+ iterate_over_lwps (minus_one_ptid /* iterate over all */,
+ update_thread_core, NULL);
}
static char *
static void
thread_db_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum target_signal signo)
+ ptid_t ptid, int step, enum gdb_signal signo)
{
struct target_ops *beneath = find_target_beneath (ops);
struct thread_db_info *info;
beneath->to_resume (beneath, ptid, step, signo);
}
+/* qsort helper function for info_auto_load_libthread_db, sort the
+ thread_db_info pointers primarily by their FILENAME and secondarily by their
+ PID, both in ascending order. */
+
+static int
+info_auto_load_libthread_db_compare (const void *ap, const void *bp)
+{
+ struct thread_db_info *a = *(struct thread_db_info **) ap;
+ struct thread_db_info *b = *(struct thread_db_info **) bp;
+ int retval;
+
+ retval = strcmp (a->filename, b->filename);
+ if (retval)
+ return retval;
+
+ return (a->pid > b->pid) - (a->pid - b->pid);
+}
+
+/* Implement 'info auto-load libthread-db'. */
+
+static void
+info_auto_load_libthread_db (char *args, int from_tty)
+{
+ struct ui_out *uiout = current_uiout;
+ const char *cs = args ? args : "";
+ struct thread_db_info *info, **array;
+ unsigned info_count, unique_filenames;
+ size_t max_filename_len, max_pids_len, pids_len;
+ struct cleanup *back_to;
+ char *pids;
+ int i;
+
+ while (isspace (*cs))
+ cs++;
+ if (*cs)
+ error (_("'info auto-load libthread-db' does not accept any parameters"));
+
+ info_count = 0;
+ for (info = thread_db_list; info; info = info->next)
+ if (info->filename != NULL)
+ info_count++;
+
+ array = xmalloc (sizeof (*array) * info_count);
+ back_to = make_cleanup (xfree, array);
+
+ info_count = 0;
+ for (info = thread_db_list; info; info = info->next)
+ if (info->filename != NULL)
+ array[info_count++] = info;
+
+ /* Sort ARRAY by filenames and PIDs. */
+
+ qsort (array, info_count, sizeof (*array),
+ info_auto_load_libthread_db_compare);
+
+ /* Calculate the number of unique filenames (rows) and the maximum string
+ length of PIDs list for the unique filenames (columns). */
+
+ unique_filenames = 0;
+ max_filename_len = 0;
+ max_pids_len = 0;
+ pids_len = 0;
+ for (i = 0; i < info_count; i++)
+ {
+ int pid = array[i]->pid;
+ size_t this_pid_len;
+
+ for (this_pid_len = 0; pid != 0; pid /= 10)
+ this_pid_len++;
+
+ if (i == 0 || strcmp (array[i - 1]->filename, array[i]->filename) != 0)
+ {
+ unique_filenames++;
+ max_filename_len = max (max_filename_len,
+ strlen (array[i]->filename));
+
+ if (i > 0)
+ {
+ pids_len -= strlen (", ");
+ max_pids_len = max (max_pids_len, pids_len);
+ }
+ pids_len = 0;
+ }
+ pids_len += this_pid_len + strlen (", ");
+ }
+ if (i)
+ {
+ pids_len -= strlen (", ");
+ max_pids_len = max (max_pids_len, pids_len);
+ }
+
+ /* Table header shifted right by preceding "libthread-db: " would not match
+ its columns. */
+ if (info_count > 0 && args == auto_load_info_scripts_pattern_nl)
+ ui_out_text (uiout, "\n");
+
+ make_cleanup_ui_out_table_begin_end (uiout, 2, unique_filenames,
+ "LinuxThreadDbTable");
+
+ ui_out_table_header (uiout, max_filename_len, ui_left, "filename",
+ "Filename");
+ ui_out_table_header (uiout, pids_len, ui_left, "PIDs", "Pids");
+ ui_out_table_body (uiout);
+
+ pids = xmalloc (max_pids_len + 1);
+ make_cleanup (xfree, pids);
+
+ /* Note I is incremented inside the cycle, not at its end. */
+ for (i = 0; i < info_count;)
+ {
+ struct cleanup *chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+ char *pids_end;
+
+ info = array[i];
+ ui_out_field_string (uiout, "filename", info->filename);
+ pids_end = pids;
+
+ while (i < info_count && strcmp (info->filename, array[i]->filename) == 0)
+ {
+ if (pids_end != pids)
+ {
+ *pids_end++ = ',';
+ *pids_end++ = ' ';
+ }
+ pids_end += xsnprintf (pids_end, &pids[max_pids_len + 1] - pids_end,
+ "%u", array[i]->pid);
+ gdb_assert (pids_end < &pids[max_pids_len + 1]);
+
+ i++;
+ }
+ *pids_end = '\0';
+
+ ui_out_field_string (uiout, "pids", pids);
+
+ ui_out_text (uiout, "\n");
+ do_cleanups (chain);
+ }
+
+ do_cleanups (back_to);
+
+ if (info_count == 0)
+ ui_out_message (uiout, 0, _("No auto-loaded libthread-db.\n"));
+}
+
static void
init_thread_db_ops (void)
{
executable -- there could be mutiple versions of glibc,
compiled with LinuxThreads or NPTL, and until there is
a running inferior, we can't tell which libthread_db is
- the correct one to load. */
+ the correct one to load. */
libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
Set search path for libthread_db."), _("\
Show the current search path or libthread_db."), _("\
This path is used to search for libthread_db to be loaded into \
-gdb itself."),
- NULL,
+gdb itself.\n\
+Its value is a colon (':') separate list of directories to search.\n\
+Setting the search path to an empty list resets it to its default value."),
+ set_libthread_db_search_path,
NULL,
&setlist, &showlist);
+
+ add_setshow_zinteger_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);
+
+ add_setshow_boolean_cmd ("libthread-db", class_support,
+ &auto_load_thread_db, _("\
+Enable or disable auto-loading of inferior specific libthread_db."), _("\
+Show whether auto-loading inferior specific libthread_db is enabled."), _("\
+If enabled, libthread_db will be searched in 'set libthread-db-search-path'\n\
+locations to load libthread_db compatible with the inferior.\n\
+Standard system libthread_db still gets loaded even with this option off.\n\
+This options has security implications for untrusted inferiors."),
+ NULL, show_auto_load_thread_db,
+ auto_load_set_cmdlist_get (),
+ auto_load_show_cmdlist_get ());
+
+ add_cmd ("libthread-db", class_info, info_auto_load_libthread_db,
+ _("Print the list of loaded inferior specific libthread_db.\n\
+Usage: info auto-load libthread-db"),
+ auto_load_info_cmdlist_get ());
+
/* Add ourselves to objfile event chain. */
observer_attach_new_objfile (thread_db_new_objfile);
+
+ /* Add ourselves to inferior_created event chain.
+ This is needed to handle debugging statically linked programs where
+ the new_objfile observer won't get called for libpthread. */
+ observer_attach_inferior_created (thread_db_inferior_created);
}
projects / thirdparty / binutils-gdb.git / blobdiff