linux-thread-db.c revision 1.5
1/* libthread_db assisted debugging support, generic parts. 2 3 Copyright (C) 1999-2015 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20#include "defs.h" 21#include <dlfcn.h> 22#include "gdb_proc_service.h" 23#include "nat/gdb_thread_db.h" 24#include "gdb_vecs.h" 25#include "bfd.h" 26#include "command.h" 27#include "gdbcmd.h" 28#include "gdbthread.h" 29#include "inferior.h" 30#include "infrun.h" 31#include "symfile.h" 32#include "objfiles.h" 33#include "target.h" 34#include "regcache.h" 35#include "solib.h" 36#include "solib-svr4.h" 37#include "gdbcore.h" 38#include "observer.h" 39#include "linux-nat.h" 40#include "nat/linux-procfs.h" 41#include "nat/linux-ptrace.h" 42#include "nat/linux-osdata.h" 43#include "auto-load.h" 44#include "cli/cli-utils.h" 45#include <signal.h> 46#include <ctype.h> 47#include "nat/linux-namespaces.h" 48 49/* GNU/Linux libthread_db support. 50 51 libthread_db is a library, provided along with libpthread.so, which 52 exposes the internals of the thread library to a debugger. It 53 allows GDB to find existing threads, new threads as they are 54 created, thread IDs (usually, the result of pthread_self), and 55 thread-local variables. 56 57 The libthread_db interface originates on Solaris, where it is 58 both more powerful and more complicated. This implementation 59 only works for LinuxThreads and NPTL, the two glibc threading 60 libraries. It assumes that each thread is permanently assigned 61 to a single light-weight process (LWP). 62 63 libthread_db-specific information is stored in the "private" field 64 of struct thread_info. When the field is NULL we do not yet have 65 information about the new thread; this could be temporary (created, 66 but the thread library's data structures do not reflect it yet) 67 or permanent (created using clone instead of pthread_create). 68 69 Process IDs managed by linux-thread-db.c match those used by 70 linux-nat.c: a common PID for all processes, an LWP ID for each 71 thread, and no TID. We save the TID in private. Keeping it out 72 of the ptid_t prevents thread IDs changing when libpthread is 73 loaded or unloaded. */ 74 75static char *libthread_db_search_path; 76 77/* Set to non-zero if thread_db auto-loading is enabled 78 by the "set auto-load libthread-db" command. */ 79static int auto_load_thread_db = 1; 80 81/* Returns true if we need to use thread_db thread create/death event 82 breakpoints to learn about threads. */ 83 84static int 85thread_db_use_events (void) 86{ 87 /* Not necessary if the kernel supports clone events. */ 88 return !linux_supports_traceclone (); 89} 90 91/* "show" command for the auto_load_thread_db configuration variable. */ 92 93static void 94show_auto_load_thread_db (struct ui_file *file, int from_tty, 95 struct cmd_list_element *c, const char *value) 96{ 97 fprintf_filtered (file, _("Auto-loading of inferior specific libthread_db " 98 "is %s.\n"), 99 value); 100} 101 102static void 103set_libthread_db_search_path (char *ignored, int from_tty, 104 struct cmd_list_element *c) 105{ 106 if (*libthread_db_search_path == '\0') 107 { 108 xfree (libthread_db_search_path); 109 libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH); 110 } 111} 112 113/* If non-zero, print details of libthread_db processing. */ 114 115static unsigned int libthread_db_debug; 116 117static void 118show_libthread_db_debug (struct ui_file *file, int from_tty, 119 struct cmd_list_element *c, const char *value) 120{ 121 fprintf_filtered (file, _("libthread-db debugging is %s.\n"), value); 122} 123 124/* If we're running on GNU/Linux, we must explicitly attach to any new 125 threads. */ 126 127/* This module's target vector. */ 128static struct target_ops thread_db_ops; 129 130/* Non-zero if we have determined the signals used by the threads 131 library. */ 132static int thread_signals; 133static sigset_t thread_stop_set; 134static sigset_t thread_print_set; 135 136struct thread_db_info 137{ 138 struct thread_db_info *next; 139 140 /* Process id this object refers to. */ 141 int pid; 142 143 /* Handle from dlopen for libthread_db.so. */ 144 void *handle; 145 146 /* Absolute pathname from gdb_realpath to disk file used for dlopen-ing 147 HANDLE. It may be NULL for system library. */ 148 char *filename; 149 150 /* Structure that identifies the child process for the 151 <proc_service.h> interface. */ 152 struct ps_prochandle proc_handle; 153 154 /* Connection to the libthread_db library. */ 155 td_thragent_t *thread_agent; 156 157 /* True if we need to apply the workaround for glibc/BZ5983. When 158 we catch a PTRACE_O_TRACEFORK, and go query the child's thread 159 list, nptl_db returns the parent's threads in addition to the new 160 (single) child thread. If this flag is set, we do extra work to 161 be able to ignore such stale entries. */ 162 int need_stale_parent_threads_check; 163 164 /* Location of the thread creation event breakpoint. The code at 165 this location in the child process will be called by the pthread 166 library whenever a new thread is created. By setting a special 167 breakpoint at this location, GDB can detect when a new thread is 168 created. We obtain this location via the td_ta_event_addr 169 call. */ 170 CORE_ADDR td_create_bp_addr; 171 172 /* Location of the thread death event breakpoint. */ 173 CORE_ADDR td_death_bp_addr; 174 175 /* Pointers to the libthread_db functions. */ 176 177 td_err_e (*td_init_p) (void); 178 179 td_err_e (*td_ta_new_p) (struct ps_prochandle * ps, 180 td_thragent_t **ta); 181 td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta, 182 lwpid_t lwpid, td_thrhandle_t *th); 183 td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta, 184 td_thr_iter_f *callback, void *cbdata_p, 185 td_thr_state_e state, int ti_pri, 186 sigset_t *ti_sigmask_p, 187 unsigned int ti_user_flags); 188 td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta, 189 td_event_e event, td_notify_t *ptr); 190 td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta, 191 td_thr_events_t *event); 192 td_err_e (*td_ta_clear_event_p) (const td_thragent_t *ta, 193 td_thr_events_t *event); 194 td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta, 195 td_event_msg_t *msg); 196 197 td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th, 198 td_thrinfo_t *infop); 199 td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th, 200 int event); 201 202 td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th, 203 psaddr_t map_address, 204 size_t offset, psaddr_t *address); 205 td_err_e (*td_thr_tlsbase_p) (const td_thrhandle_t *th, 206 unsigned long int modid, 207 psaddr_t *base); 208}; 209 210/* List of known processes using thread_db, and the required 211 bookkeeping. */ 212struct thread_db_info *thread_db_list; 213 214static void thread_db_find_new_threads_1 (ptid_t ptid); 215static void thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new); 216 217static void check_thread_signals (void); 218 219static void record_thread (struct thread_db_info *info, 220 struct thread_info *tp, 221 ptid_t ptid, const td_thrhandle_t *th_p, 222 const td_thrinfo_t *ti_p); 223 224/* Add the current inferior to the list of processes using libpthread. 225 Return a pointer to the newly allocated object that was added to 226 THREAD_DB_LIST. HANDLE is the handle returned by dlopen'ing 227 LIBTHREAD_DB_SO. */ 228 229static struct thread_db_info * 230add_thread_db_info (void *handle) 231{ 232 struct thread_db_info *info; 233 234 info = xcalloc (1, sizeof (*info)); 235 info->pid = ptid_get_pid (inferior_ptid); 236 info->handle = handle; 237 238 /* The workaround works by reading from /proc/pid/status, so it is 239 disabled for core files. */ 240 if (target_has_execution) 241 info->need_stale_parent_threads_check = 1; 242 243 info->next = thread_db_list; 244 thread_db_list = info; 245 246 return info; 247} 248 249/* Return the thread_db_info object representing the bookkeeping 250 related to process PID, if any; NULL otherwise. */ 251 252static struct thread_db_info * 253get_thread_db_info (int pid) 254{ 255 struct thread_db_info *info; 256 257 for (info = thread_db_list; info; info = info->next) 258 if (pid == info->pid) 259 return info; 260 261 return NULL; 262} 263 264/* When PID has exited or has been detached, we no longer want to keep 265 track of it as using libpthread. Call this function to discard 266 thread_db related info related to PID. Note that this closes 267 LIBTHREAD_DB_SO's dlopen'ed handle. */ 268 269static void 270delete_thread_db_info (int pid) 271{ 272 struct thread_db_info *info, *info_prev; 273 274 info_prev = NULL; 275 276 for (info = thread_db_list; info; info_prev = info, info = info->next) 277 if (pid == info->pid) 278 break; 279 280 if (info == NULL) 281 return; 282 283 if (info->handle != NULL) 284 dlclose (info->handle); 285 286 xfree (info->filename); 287 288 if (info_prev) 289 info_prev->next = info->next; 290 else 291 thread_db_list = info->next; 292 293 xfree (info); 294} 295 296/* Prototypes for local functions. */ 297static int attach_thread (ptid_t ptid, const td_thrhandle_t *th_p, 298 const td_thrinfo_t *ti_p); 299static void detach_thread (ptid_t ptid); 300 301 302/* Use "struct private_thread_info" to cache thread state. This is 303 a substantial optimization. */ 304 305struct private_thread_info 306{ 307 /* Flag set when we see a TD_DEATH event for this thread. */ 308 unsigned int dying:1; 309 310 /* Cached thread state. */ 311 td_thrhandle_t th; 312 thread_t tid; 313}; 314 315 316static char * 317thread_db_err_str (td_err_e err) 318{ 319 static char buf[64]; 320 321 switch (err) 322 { 323 case TD_OK: 324 return "generic 'call succeeded'"; 325 case TD_ERR: 326 return "generic error"; 327 case TD_NOTHR: 328 return "no thread to satisfy query"; 329 case TD_NOSV: 330 return "no sync handle to satisfy query"; 331 case TD_NOLWP: 332 return "no LWP to satisfy query"; 333 case TD_BADPH: 334 return "invalid process handle"; 335 case TD_BADTH: 336 return "invalid thread handle"; 337 case TD_BADSH: 338 return "invalid synchronization handle"; 339 case TD_BADTA: 340 return "invalid thread agent"; 341 case TD_BADKEY: 342 return "invalid key"; 343 case TD_NOMSG: 344 return "no event message for getmsg"; 345 case TD_NOFPREGS: 346 return "FPU register set not available"; 347 case TD_NOLIBTHREAD: 348 return "application not linked with libthread"; 349 case TD_NOEVENT: 350 return "requested event is not supported"; 351 case TD_NOCAPAB: 352 return "capability not available"; 353 case TD_DBERR: 354 return "debugger service failed"; 355 case TD_NOAPLIC: 356 return "operation not applicable to"; 357 case TD_NOTSD: 358 return "no thread-specific data for this thread"; 359 case TD_MALLOC: 360 return "malloc failed"; 361 case TD_PARTIALREG: 362 return "only part of register set was written/read"; 363 case TD_NOXREGS: 364 return "X register set not available for this thread"; 365#ifdef THREAD_DB_HAS_TD_NOTALLOC 366 case TD_NOTALLOC: 367 return "thread has not yet allocated TLS for given module"; 368#endif 369#ifdef THREAD_DB_HAS_TD_VERSION 370 case TD_VERSION: 371 return "versions of libpthread and libthread_db do not match"; 372#endif 373#ifdef THREAD_DB_HAS_TD_NOTLS 374 case TD_NOTLS: 375 return "there is no TLS segment in the given module"; 376#endif 377 default: 378 snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err); 379 return buf; 380 } 381} 382 383/* Return 1 if any threads have been registered. There may be none if 384 the threading library is not fully initialized yet. */ 385 386static int 387have_threads_callback (struct thread_info *thread, void *args) 388{ 389 int pid = * (int *) args; 390 391 if (ptid_get_pid (thread->ptid) != pid) 392 return 0; 393 394 return thread->priv != NULL; 395} 396 397static int 398have_threads (ptid_t ptid) 399{ 400 int pid = ptid_get_pid (ptid); 401 402 return iterate_over_threads (have_threads_callback, &pid) != NULL; 403} 404 405 406/* Fetch the user-level thread id of PTID. */ 407 408static void 409thread_from_lwp (ptid_t ptid) 410{ 411 td_thrhandle_t th; 412 td_thrinfo_t ti; 413 td_err_e err; 414 struct thread_db_info *info; 415 struct thread_info *tp; 416 417 /* Just in case td_ta_map_lwp2thr doesn't initialize it completely. */ 418 th.th_unique = 0; 419 420 /* This ptid comes from linux-nat.c, which should always fill in the 421 LWP. */ 422 gdb_assert (ptid_get_lwp (ptid) != 0); 423 424 info = get_thread_db_info (ptid_get_pid (ptid)); 425 426 /* Access an lwp we know is stopped. */ 427 info->proc_handle.ptid = ptid; 428 err = info->td_ta_map_lwp2thr_p (info->thread_agent, ptid_get_lwp (ptid), 429 &th); 430 if (err != TD_OK) 431 error (_("Cannot find user-level thread for LWP %ld: %s"), 432 ptid_get_lwp (ptid), thread_db_err_str (err)); 433 434 err = info->td_thr_get_info_p (&th, &ti); 435 if (err != TD_OK) 436 error (_("thread_get_info_callback: cannot get thread info: %s"), 437 thread_db_err_str (err)); 438 439 /* Fill the cache. */ 440 tp = find_thread_ptid (ptid); 441 record_thread (info, tp, ptid, &th, &ti); 442} 443 444 445/* See linux-nat.h. */ 446 447int 448thread_db_notice_clone (ptid_t parent, ptid_t child) 449{ 450 td_thrhandle_t th; 451 td_thrinfo_t ti; 452 td_err_e err; 453 struct thread_db_info *info; 454 455 info = get_thread_db_info (ptid_get_pid (child)); 456 457 if (info == NULL) 458 return 0; 459 460 thread_from_lwp (child); 461 462 /* If we do not know about the main thread yet, this would be a good 463 time to find it. */ 464 thread_from_lwp (parent); 465 return 1; 466} 467 468static void * 469verbose_dlsym (void *handle, const char *name) 470{ 471 void *sym = dlsym (handle, name); 472 if (sym == NULL) 473 warning (_("Symbol \"%s\" not found in libthread_db: %s"), 474 name, dlerror ()); 475 return sym; 476} 477 478static td_err_e 479enable_thread_event (int event, CORE_ADDR *bp) 480{ 481 td_notify_t notify; 482 td_err_e err; 483 struct thread_db_info *info; 484 485 info = get_thread_db_info (ptid_get_pid (inferior_ptid)); 486 487 /* Access an lwp we know is stopped. */ 488 info->proc_handle.ptid = inferior_ptid; 489 490 /* Get the breakpoint address for thread EVENT. */ 491 err = info->td_ta_event_addr_p (info->thread_agent, event, ¬ify); 492 if (err != TD_OK) 493 return err; 494 495 /* Set up the breakpoint. */ 496 gdb_assert (exec_bfd); 497 (*bp) = (gdbarch_convert_from_func_ptr_addr 498 (target_gdbarch (), 499 /* Do proper sign extension for the target. */ 500 (bfd_get_sign_extend_vma (exec_bfd) > 0 501 ? (CORE_ADDR) (intptr_t) notify.u.bptaddr 502 : (CORE_ADDR) (uintptr_t) notify.u.bptaddr), 503 ¤t_target)); 504 create_thread_event_breakpoint (target_gdbarch (), *bp); 505 506 return TD_OK; 507} 508 509/* Verify inferior's '\0'-terminated symbol VER_SYMBOL starts with "%d.%d" and 510 return 1 if this version is lower (and not equal) to 511 VER_MAJOR_MIN.VER_MINOR_MIN. Return 0 in all other cases. */ 512 513static int 514inferior_has_bug (const char *ver_symbol, int ver_major_min, int ver_minor_min) 515{ 516 struct bound_minimal_symbol version_msym; 517 CORE_ADDR version_addr; 518 char *version; 519 int err, got, retval = 0; 520 521 version_msym = lookup_minimal_symbol (ver_symbol, NULL, NULL); 522 if (version_msym.minsym == NULL) 523 return 0; 524 525 version_addr = BMSYMBOL_VALUE_ADDRESS (version_msym); 526 got = target_read_string (version_addr, &version, 32, &err); 527 if (err == 0 && memchr (version, 0, got) == &version[got -1]) 528 { 529 int major, minor; 530 531 retval = (sscanf (version, "%d.%d", &major, &minor) == 2 532 && (major < ver_major_min 533 || (major == ver_major_min && minor < ver_minor_min))); 534 } 535 xfree (version); 536 537 return retval; 538} 539 540static void 541enable_thread_event_reporting (void) 542{ 543 td_thr_events_t events; 544 td_err_e err; 545 struct thread_db_info *info; 546 547 info = get_thread_db_info (ptid_get_pid (inferior_ptid)); 548 549 /* We cannot use the thread event reporting facility if these 550 functions aren't available. */ 551 if (info->td_ta_event_addr_p == NULL 552 || info->td_ta_set_event_p == NULL 553 || info->td_ta_event_getmsg_p == NULL 554 || info->td_thr_event_enable_p == NULL) 555 return; 556 557 /* Set the process wide mask saying which events we're interested in. */ 558 td_event_emptyset (&events); 559 td_event_addset (&events, TD_CREATE); 560 561 /* There is a bug fixed between linuxthreads 2.1.3 and 2.2 by 562 commit 2e4581e4fba917f1779cd0a010a45698586c190a 563 * manager.c (pthread_exited): Correctly report event as TD_REAP 564 instead of TD_DEATH. Fix comments. 565 where event reporting facility is broken for TD_DEATH events, 566 so don't enable it if we have glibc but a lower version. */ 567 if (!inferior_has_bug ("__linuxthreads_version", 2, 2)) 568 td_event_addset (&events, TD_DEATH); 569 570 err = info->td_ta_set_event_p (info->thread_agent, &events); 571 if (err != TD_OK) 572 { 573 warning (_("Unable to set global thread event mask: %s"), 574 thread_db_err_str (err)); 575 return; 576 } 577 578 /* Delete previous thread event breakpoints, if any. */ 579 remove_thread_event_breakpoints (); 580 info->td_create_bp_addr = 0; 581 info->td_death_bp_addr = 0; 582 583 /* Set up the thread creation event. */ 584 err = enable_thread_event (TD_CREATE, &info->td_create_bp_addr); 585 if (err != TD_OK) 586 { 587 warning (_("Unable to get location for thread creation breakpoint: %s"), 588 thread_db_err_str (err)); 589 return; 590 } 591 592 /* Set up the thread death event. */ 593 err = enable_thread_event (TD_DEATH, &info->td_death_bp_addr); 594 if (err != TD_OK) 595 { 596 warning (_("Unable to get location for thread death breakpoint: %s"), 597 thread_db_err_str (err)); 598 return; 599 } 600} 601 602/* Similar as thread_db_find_new_threads_1, but try to silently ignore errors 603 if appropriate. 604 605 Return 1 if the caller should abort libthread_db initialization. Return 0 606 otherwise. */ 607 608static int 609thread_db_find_new_threads_silently (ptid_t ptid) 610{ 611 612 TRY 613 { 614 thread_db_find_new_threads_2 (ptid, 1); 615 } 616 617 CATCH (except, RETURN_MASK_ERROR) 618 { 619 if (libthread_db_debug) 620 exception_fprintf (gdb_stdlog, except, 621 "Warning: thread_db_find_new_threads_silently: "); 622 623 /* There is a bug fixed between nptl 2.6.1 and 2.7 by 624 commit 7d9d8bd18906fdd17364f372b160d7ab896ce909 625 where calls to td_thr_get_info fail with TD_ERR for statically linked 626 executables if td_thr_get_info is called before glibc has initialized 627 itself. 628 629 If the nptl bug is NOT present in the inferior and still thread_db 630 reports an error return 1. It means the inferior has corrupted thread 631 list and GDB should fall back only to LWPs. 632 633 If the nptl bug is present in the inferior return 0 to silently ignore 634 such errors, and let gdb enumerate threads again later. In such case 635 GDB cannot properly display LWPs if the inferior thread list is 636 corrupted. For core files it does not apply, no 'later enumeration' 637 is possible. */ 638 639 if (!target_has_execution || !inferior_has_bug ("nptl_version", 2, 7)) 640 { 641 exception_fprintf (gdb_stderr, except, 642 _("Warning: couldn't activate thread debugging " 643 "using libthread_db: ")); 644 return 1; 645 } 646 } 647 END_CATCH 648 649 return 0; 650} 651 652/* Lookup a library in which given symbol resides. 653 Note: this is looking in GDB process, not in the inferior. 654 Returns library name, or NULL. */ 655 656static const char * 657dladdr_to_soname (const void *addr) 658{ 659 Dl_info info; 660 661 if (dladdr (addr, &info) != 0) 662 return info.dli_fname; 663 return NULL; 664} 665 666/* Attempt to initialize dlopen()ed libthread_db, described by INFO. 667 Return 1 on success. 668 Failure could happen if libthread_db does not have symbols we expect, 669 or when it refuses to work with the current inferior (e.g. due to 670 version mismatch between libthread_db and libpthread). */ 671 672static int 673try_thread_db_load_1 (struct thread_db_info *info) 674{ 675 td_err_e err; 676 677 /* Initialize pointers to the dynamic library functions we will use. 678 Essential functions first. */ 679 680 info->td_init_p = verbose_dlsym (info->handle, "td_init"); 681 if (info->td_init_p == NULL) 682 return 0; 683 684 err = info->td_init_p (); 685 if (err != TD_OK) 686 { 687 warning (_("Cannot initialize libthread_db: %s"), 688 thread_db_err_str (err)); 689 return 0; 690 } 691 692 info->td_ta_new_p = verbose_dlsym (info->handle, "td_ta_new"); 693 if (info->td_ta_new_p == NULL) 694 return 0; 695 696 /* Initialize the structure that identifies the child process. */ 697 info->proc_handle.ptid = inferior_ptid; 698 699 /* Now attempt to open a connection to the thread library. */ 700 err = info->td_ta_new_p (&info->proc_handle, &info->thread_agent); 701 if (err != TD_OK) 702 { 703 if (libthread_db_debug) 704 fprintf_unfiltered (gdb_stdlog, _("td_ta_new failed: %s\n"), 705 thread_db_err_str (err)); 706 else 707 switch (err) 708 { 709 case TD_NOLIBTHREAD: 710#ifdef THREAD_DB_HAS_TD_VERSION 711 case TD_VERSION: 712#endif 713 /* The errors above are not unexpected and silently ignored: 714 they just mean we haven't found correct version of 715 libthread_db yet. */ 716 break; 717 default: 718 warning (_("td_ta_new failed: %s"), thread_db_err_str (err)); 719 } 720 return 0; 721 } 722 723 info->td_ta_map_lwp2thr_p = verbose_dlsym (info->handle, 724 "td_ta_map_lwp2thr"); 725 if (info->td_ta_map_lwp2thr_p == NULL) 726 return 0; 727 728 info->td_ta_thr_iter_p = verbose_dlsym (info->handle, "td_ta_thr_iter"); 729 if (info->td_ta_thr_iter_p == NULL) 730 return 0; 731 732 info->td_thr_get_info_p = verbose_dlsym (info->handle, "td_thr_get_info"); 733 if (info->td_thr_get_info_p == NULL) 734 return 0; 735 736 /* These are not essential. */ 737 info->td_ta_event_addr_p = dlsym (info->handle, "td_ta_event_addr"); 738 info->td_ta_set_event_p = dlsym (info->handle, "td_ta_set_event"); 739 info->td_ta_clear_event_p = dlsym (info->handle, "td_ta_clear_event"); 740 info->td_ta_event_getmsg_p = dlsym (info->handle, "td_ta_event_getmsg"); 741 info->td_thr_event_enable_p = dlsym (info->handle, "td_thr_event_enable"); 742 info->td_thr_tls_get_addr_p = dlsym (info->handle, "td_thr_tls_get_addr"); 743 info->td_thr_tlsbase_p = dlsym (info->handle, "td_thr_tlsbase"); 744 745 /* It's best to avoid td_ta_thr_iter if possible. That walks data 746 structures in the inferior's address space that may be corrupted, 747 or, if the target is running, may change while we walk them. If 748 there's execution (and /proc is mounted), then we're already 749 attached to all LWPs. Use thread_from_lwp, which uses 750 td_ta_map_lwp2thr instead, which does not walk the thread list. 751 752 td_ta_map_lwp2thr uses ps_get_thread_area, but we can't use that 753 currently on core targets, as it uses ptrace directly. */ 754 if (target_has_execution 755 && linux_proc_task_list_dir_exists (ptid_get_pid (inferior_ptid))) 756 { 757 struct lwp_info *lp; 758 int pid = ptid_get_pid (inferior_ptid); 759 760 linux_stop_and_wait_all_lwps (); 761 762 ALL_LWPS (lp) 763 if (ptid_get_pid (lp->ptid) == pid) 764 thread_from_lwp (lp->ptid); 765 766 linux_unstop_all_lwps (); 767 } 768 else if (thread_db_find_new_threads_silently (inferior_ptid) != 0) 769 { 770 /* Even if libthread_db initializes, if the thread list is 771 corrupted, we'd not manage to list any threads. Better reject this 772 thread_db, and fall back to at least listing LWPs. */ 773 return 0; 774 } 775 776 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n")); 777 778 if (*libthread_db_search_path || libthread_db_debug) 779 { 780 struct ui_file *file; 781 const char *library; 782 783 library = dladdr_to_soname (*info->td_ta_new_p); 784 if (library == NULL) 785 library = LIBTHREAD_DB_SO; 786 787 /* If we'd print this to gdb_stdout when debug output is 788 disabled, still print it to gdb_stdout if debug output is 789 enabled. User visible output should not depend on debug 790 settings. */ 791 file = *libthread_db_search_path != '\0' ? gdb_stdout : gdb_stdlog; 792 fprintf_unfiltered (file, _("Using host libthread_db library \"%s\".\n"), 793 library); 794 } 795 796 /* The thread library was detected. Activate the thread_db target 797 if this is the first process using it. */ 798 if (thread_db_list->next == NULL) 799 push_target (&thread_db_ops); 800 801 /* Enable event reporting, but not when debugging a core file. */ 802 if (target_has_execution && thread_db_use_events ()) 803 enable_thread_event_reporting (); 804 805 return 1; 806} 807 808/* Attempt to use LIBRARY as libthread_db. LIBRARY could be absolute, 809 relative, or just LIBTHREAD_DB. */ 810 811static int 812try_thread_db_load (const char *library, int check_auto_load_safe) 813{ 814 void *handle; 815 struct thread_db_info *info; 816 817 if (libthread_db_debug) 818 fprintf_unfiltered (gdb_stdlog, 819 _("Trying host libthread_db library: %s.\n"), 820 library); 821 822 if (check_auto_load_safe) 823 { 824 if (access (library, R_OK) != 0) 825 { 826 /* Do not print warnings by file_is_auto_load_safe if the library does 827 not exist at this place. */ 828 if (libthread_db_debug) 829 fprintf_unfiltered (gdb_stdlog, _("open failed: %s.\n"), 830 safe_strerror (errno)); 831 return 0; 832 } 833 834 if (!file_is_auto_load_safe (library, _("auto-load: Loading libthread-db " 835 "library \"%s\" from explicit " 836 "directory.\n"), 837 library)) 838 return 0; 839 } 840 841 handle = dlopen (library, RTLD_NOW); 842 if (handle == NULL) 843 { 844 if (libthread_db_debug) 845 fprintf_unfiltered (gdb_stdlog, _("dlopen failed: %s.\n"), dlerror ()); 846 return 0; 847 } 848 849 if (libthread_db_debug && strchr (library, '/') == NULL) 850 { 851 void *td_init; 852 853 td_init = dlsym (handle, "td_init"); 854 if (td_init != NULL) 855 { 856 const char *const libpath = dladdr_to_soname (td_init); 857 858 if (libpath != NULL) 859 fprintf_unfiltered (gdb_stdlog, _("Host %s resolved to: %s.\n"), 860 library, libpath); 861 } 862 } 863 864 info = add_thread_db_info (handle); 865 866 /* Do not save system library name, that one is always trusted. */ 867 if (strchr (library, '/') != NULL) 868 info->filename = gdb_realpath (library); 869 870 if (try_thread_db_load_1 (info)) 871 return 1; 872 873 /* This library "refused" to work on current inferior. */ 874 delete_thread_db_info (ptid_get_pid (inferior_ptid)); 875 return 0; 876} 877 878/* Subroutine of try_thread_db_load_from_pdir to simplify it. 879 Try loading libthread_db in directory(OBJ)/SUBDIR. 880 SUBDIR may be NULL. It may also be something like "../lib64". 881 The result is true for success. */ 882 883static int 884try_thread_db_load_from_pdir_1 (struct objfile *obj, const char *subdir) 885{ 886 struct cleanup *cleanup; 887 char *path, *cp; 888 int result; 889 const char *obj_name = objfile_name (obj); 890 891 if (obj_name[0] != '/') 892 { 893 warning (_("Expected absolute pathname for libpthread in the" 894 " inferior, but got %s."), obj_name); 895 return 0; 896 } 897 898 path = xmalloc (strlen (obj_name) + (subdir ? strlen (subdir) + 1 : 0) 899 + 1 + strlen (LIBTHREAD_DB_SO) + 1); 900 cleanup = make_cleanup (xfree, path); 901 902 strcpy (path, obj_name); 903 cp = strrchr (path, '/'); 904 /* This should at minimum hit the first character. */ 905 gdb_assert (cp != NULL); 906 cp[1] = '\0'; 907 if (subdir != NULL) 908 { 909 strcat (cp, subdir); 910 strcat (cp, "/"); 911 } 912 strcat (cp, LIBTHREAD_DB_SO); 913 914 result = try_thread_db_load (path, 1); 915 916 do_cleanups (cleanup); 917 return result; 918} 919 920/* Handle $pdir in libthread-db-search-path. 921 Look for libthread_db in directory(libpthread)/SUBDIR. 922 SUBDIR may be NULL. It may also be something like "../lib64". 923 The result is true for success. */ 924 925static int 926try_thread_db_load_from_pdir (const char *subdir) 927{ 928 struct objfile *obj; 929 930 if (!auto_load_thread_db) 931 return 0; 932 933 ALL_OBJFILES (obj) 934 if (libpthread_name_p (objfile_name (obj))) 935 { 936 if (try_thread_db_load_from_pdir_1 (obj, subdir)) 937 return 1; 938 939 /* We may have found the separate-debug-info version of 940 libpthread, and it may live in a directory without a matching 941 libthread_db. */ 942 if (obj->separate_debug_objfile_backlink != NULL) 943 return try_thread_db_load_from_pdir_1 (obj->separate_debug_objfile_backlink, 944 subdir); 945 946 return 0; 947 } 948 949 return 0; 950} 951 952/* Handle $sdir in libthread-db-search-path. 953 Look for libthread_db in the system dirs, or wherever a plain 954 dlopen(file_without_path) will look. 955 The result is true for success. */ 956 957static int 958try_thread_db_load_from_sdir (void) 959{ 960 return try_thread_db_load (LIBTHREAD_DB_SO, 0); 961} 962 963/* Try to load libthread_db from directory DIR of length DIR_LEN. 964 The result is true for success. */ 965 966static int 967try_thread_db_load_from_dir (const char *dir, size_t dir_len) 968{ 969 struct cleanup *cleanup; 970 char *path; 971 int result; 972 973 if (!auto_load_thread_db) 974 return 0; 975 976 path = xmalloc (dir_len + 1 + strlen (LIBTHREAD_DB_SO) + 1); 977 cleanup = make_cleanup (xfree, path); 978 979 memcpy (path, dir, dir_len); 980 path[dir_len] = '/'; 981 strcpy (path + dir_len + 1, LIBTHREAD_DB_SO); 982 983 result = try_thread_db_load (path, 1); 984 985 do_cleanups (cleanup); 986 return result; 987} 988 989/* Search libthread_db_search_path for libthread_db which "agrees" 990 to work on current inferior. 991 The result is true for success. */ 992 993static int 994thread_db_load_search (void) 995{ 996 VEC (char_ptr) *dir_vec; 997 struct cleanup *cleanups; 998 char *this_dir; 999 int i, rc = 0; 1000 1001 dir_vec = dirnames_to_char_ptr_vec (libthread_db_search_path); 1002 cleanups = make_cleanup_free_char_ptr_vec (dir_vec); 1003 1004 for (i = 0; VEC_iterate (char_ptr, dir_vec, i, this_dir); ++i) 1005 { 1006 const int pdir_len = sizeof ("$pdir") - 1; 1007 size_t this_dir_len; 1008 1009 this_dir_len = strlen (this_dir); 1010 1011 if (strncmp (this_dir, "$pdir", pdir_len) == 0 1012 && (this_dir[pdir_len] == '\0' 1013 || this_dir[pdir_len] == '/')) 1014 { 1015 char *subdir = NULL; 1016 struct cleanup *free_subdir_cleanup 1017 = make_cleanup (null_cleanup, NULL); 1018 1019 if (this_dir[pdir_len] == '/') 1020 { 1021 subdir = xmalloc (strlen (this_dir)); 1022 make_cleanup (xfree, subdir); 1023 strcpy (subdir, this_dir + pdir_len + 1); 1024 } 1025 rc = try_thread_db_load_from_pdir (subdir); 1026 do_cleanups (free_subdir_cleanup); 1027 if (rc) 1028 break; 1029 } 1030 else if (strcmp (this_dir, "$sdir") == 0) 1031 { 1032 if (try_thread_db_load_from_sdir ()) 1033 { 1034 rc = 1; 1035 break; 1036 } 1037 } 1038 else 1039 { 1040 if (try_thread_db_load_from_dir (this_dir, this_dir_len)) 1041 { 1042 rc = 1; 1043 break; 1044 } 1045 } 1046 } 1047 1048 do_cleanups (cleanups); 1049 if (libthread_db_debug) 1050 fprintf_unfiltered (gdb_stdlog, 1051 _("thread_db_load_search returning %d\n"), rc); 1052 return rc; 1053} 1054 1055/* Return non-zero if the inferior has a libpthread. */ 1056 1057static int 1058has_libpthread (void) 1059{ 1060 struct objfile *obj; 1061 1062 ALL_OBJFILES (obj) 1063 if (libpthread_name_p (objfile_name (obj))) 1064 return 1; 1065 1066 return 0; 1067} 1068 1069/* Attempt to load and initialize libthread_db. 1070 Return 1 on success. */ 1071 1072static int 1073thread_db_load (void) 1074{ 1075 struct thread_db_info *info; 1076 1077 info = get_thread_db_info (ptid_get_pid (inferior_ptid)); 1078 1079 if (info != NULL) 1080 return 1; 1081 1082 /* Don't attempt to use thread_db on executables not running 1083 yet. */ 1084 if (!target_has_registers) 1085 return 0; 1086 1087 /* Don't attempt to use thread_db for remote targets. */ 1088 if (!(target_can_run (¤t_target) || core_bfd)) 1089 return 0; 1090 1091 if (thread_db_load_search ()) 1092 return 1; 1093 1094 /* We couldn't find a libthread_db. 1095 If the inferior has a libpthread warn the user. */ 1096 if (has_libpthread ()) 1097 { 1098 warning (_("Unable to find libthread_db matching inferior's thread" 1099 " library, thread debugging will not be available.")); 1100 return 0; 1101 } 1102 1103 /* Either this executable isn't using libpthread at all, or it is 1104 statically linked. Since we can't easily distinguish these two cases, 1105 no warning is issued. */ 1106 return 0; 1107} 1108 1109static void 1110disable_thread_event_reporting (struct thread_db_info *info) 1111{ 1112 if (info->td_ta_clear_event_p != NULL) 1113 { 1114 td_thr_events_t events; 1115 1116 /* Set the process wide mask saying we aren't interested in any 1117 events anymore. */ 1118 td_event_fillset (&events); 1119 info->td_ta_clear_event_p (info->thread_agent, &events); 1120 } 1121 1122 info->td_create_bp_addr = 0; 1123 info->td_death_bp_addr = 0; 1124} 1125 1126static void 1127check_thread_signals (void) 1128{ 1129 if (!thread_signals) 1130 { 1131 sigset_t mask; 1132 int i; 1133 1134 lin_thread_get_thread_signals (&mask); 1135 sigemptyset (&thread_stop_set); 1136 sigemptyset (&thread_print_set); 1137 1138 for (i = 1; i < NSIG; i++) 1139 { 1140 if (sigismember (&mask, i)) 1141 { 1142 if (signal_stop_update (gdb_signal_from_host (i), 0)) 1143 sigaddset (&thread_stop_set, i); 1144 if (signal_print_update (gdb_signal_from_host (i), 0)) 1145 sigaddset (&thread_print_set, i); 1146 thread_signals = 1; 1147 } 1148 } 1149 } 1150} 1151 1152/* Check whether thread_db is usable. This function is called when 1153 an inferior is created (or otherwise acquired, e.g. attached to) 1154 and when new shared libraries are loaded into a running process. */ 1155 1156void 1157check_for_thread_db (void) 1158{ 1159 /* Do nothing if we couldn't load libthread_db.so.1. */ 1160 if (!thread_db_load ()) 1161 return; 1162} 1163 1164/* This function is called via the new_objfile observer. */ 1165 1166static void 1167thread_db_new_objfile (struct objfile *objfile) 1168{ 1169 /* This observer must always be called with inferior_ptid set 1170 correctly. */ 1171 1172 if (objfile != NULL 1173 /* libpthread with separate debug info has its debug info file already 1174 loaded (and notified without successful thread_db initialization) 1175 the time observer_notify_new_objfile is called for the library itself. 1176 Static executables have their separate debug info loaded already 1177 before the inferior has started. */ 1178 && objfile->separate_debug_objfile_backlink == NULL 1179 /* Only check for thread_db if we loaded libpthread, 1180 or if this is the main symbol file. 1181 We need to check OBJF_MAINLINE to handle the case of debugging 1182 a statically linked executable AND the symbol file is specified AFTER 1183 the exec file is loaded (e.g., gdb -c core ; file foo). 1184 For dynamically linked executables, libpthread can be near the end 1185 of the list of shared libraries to load, and in an app of several 1186 thousand shared libraries, this can otherwise be painful. */ 1187 && ((objfile->flags & OBJF_MAINLINE) != 0 1188 || libpthread_name_p (objfile_name (objfile)))) 1189 check_for_thread_db (); 1190} 1191 1192static void 1193check_pid_namespace_match (void) 1194{ 1195 /* Check is only relevant for local targets targets. */ 1196 if (target_can_run (¤t_target)) 1197 { 1198 /* If the child is in a different PID namespace, its idea of its 1199 PID will differ from our idea of its PID. When we scan the 1200 child's thread list, we'll mistakenly think it has no threads 1201 since the thread PID fields won't match the PID we give to 1202 libthread_db. */ 1203 if (!linux_ns_same (ptid_get_pid (inferior_ptid), LINUX_NS_PID)) 1204 { 1205 warning (_ ("Target and debugger are in different PID " 1206 "namespaces; thread lists and other data are " 1207 "likely unreliable")); 1208 } 1209 } 1210} 1211 1212/* This function is called via the inferior_created observer. 1213 This handles the case of debugging statically linked executables. */ 1214 1215static void 1216thread_db_inferior_created (struct target_ops *target, int from_tty) 1217{ 1218 check_pid_namespace_match (); 1219 check_for_thread_db (); 1220} 1221 1222/* Update the thread's state (what's displayed in "info threads"), 1223 from libthread_db thread state information. */ 1224 1225static void 1226update_thread_state (struct private_thread_info *priv, 1227 const td_thrinfo_t *ti_p) 1228{ 1229 priv->dying = (ti_p->ti_state == TD_THR_UNKNOWN 1230 || ti_p->ti_state == TD_THR_ZOMBIE); 1231} 1232 1233/* Attach to a new thread. This function is called when we receive a 1234 TD_CREATE event or when we iterate over all threads and find one 1235 that wasn't already in our list. Returns true on success. */ 1236 1237static int 1238attach_thread (ptid_t ptid, const td_thrhandle_t *th_p, 1239 const td_thrinfo_t *ti_p) 1240{ 1241 struct thread_info *tp; 1242 struct thread_db_info *info; 1243 1244 /* If we're being called after a TD_CREATE event, we may already 1245 know about this thread. There are two ways this can happen. We 1246 may have iterated over all threads between the thread creation 1247 and the TD_CREATE event, for instance when the user has issued 1248 the `info threads' command before the SIGTRAP for hitting the 1249 thread creation breakpoint was reported. Alternatively, the 1250 thread may have exited and a new one been created with the same 1251 thread ID. In the first case we don't need to do anything; in 1252 the second case we should discard information about the dead 1253 thread and attach to the new one. */ 1254 tp = find_thread_ptid (ptid); 1255 if (tp != NULL) 1256 { 1257 /* If tp->priv is NULL, then GDB is already attached to this 1258 thread, but we do not know anything about it. We can learn 1259 about it here. This can only happen if we have some other 1260 way besides libthread_db to notice new threads (i.e. 1261 PTRACE_EVENT_CLONE); assume the same mechanism notices thread 1262 exit, so this can not be a stale thread recreated with the 1263 same ID. */ 1264 if (tp->priv != NULL) 1265 { 1266 if (!tp->priv->dying) 1267 return 0; 1268 1269 delete_thread (ptid); 1270 tp = NULL; 1271 } 1272 } 1273 1274 /* Under GNU/Linux, we have to attach to each and every thread. */ 1275 if (target_has_execution 1276 && tp == NULL) 1277 { 1278 int res; 1279 1280 res = lin_lwp_attach_lwp (ptid_build (ptid_get_pid (ptid), 1281 ti_p->ti_lid, 0)); 1282 if (res < 0) 1283 { 1284 /* Error, stop iterating. */ 1285 return 0; 1286 } 1287 else if (res > 0) 1288 { 1289 /* Pretend this thread doesn't exist yet, and keep 1290 iterating. */ 1291 return 1; 1292 } 1293 1294 /* Otherwise, we sucessfully attached to the thread. */ 1295 } 1296 1297 info = get_thread_db_info (ptid_get_pid (ptid)); 1298 record_thread (info, tp, ptid, th_p, ti_p); 1299 return 1; 1300} 1301 1302/* Record a new thread in GDB's thread list. Creates the thread's 1303 private info. If TP is NULL, creates a new thread. Otherwise, 1304 uses TP. */ 1305 1306static void 1307record_thread (struct thread_db_info *info, 1308 struct thread_info *tp, 1309 ptid_t ptid, const td_thrhandle_t *th_p, 1310 const td_thrinfo_t *ti_p) 1311{ 1312 td_err_e err; 1313 struct private_thread_info *priv; 1314 int new_thread = (tp == NULL); 1315 1316 /* A thread ID of zero may mean the thread library has not 1317 initialized yet. Leave private == NULL until the thread library 1318 has initialized. */ 1319 if (ti_p->ti_tid == 0) 1320 return; 1321 1322 /* Construct the thread's private data. */ 1323 priv = xmalloc (sizeof (struct private_thread_info)); 1324 memset (priv, 0, sizeof (struct private_thread_info)); 1325 1326 priv->th = *th_p; 1327 priv->tid = ti_p->ti_tid; 1328 update_thread_state (priv, ti_p); 1329 1330 /* Add the thread to GDB's thread list. If we already know about a 1331 thread with this PTID, but it's marked exited, then the kernel 1332 reused the tid of an old thread. */ 1333 if (tp == NULL || tp->state == THREAD_EXITED) 1334 tp = add_thread_with_info (ptid, priv); 1335 else 1336 tp->priv = priv; 1337 1338 /* Enable thread event reporting for this thread, except when 1339 debugging a core file. */ 1340 if (target_has_execution && thread_db_use_events () && new_thread) 1341 { 1342 err = info->td_thr_event_enable_p (th_p, 1); 1343 if (err != TD_OK) 1344 error (_("Cannot enable thread event reporting for %s: %s"), 1345 target_pid_to_str (ptid), thread_db_err_str (err)); 1346 } 1347 1348 if (target_has_execution) 1349 check_thread_signals (); 1350} 1351 1352static void 1353detach_thread (ptid_t ptid) 1354{ 1355 struct thread_info *thread_info; 1356 1357 /* Don't delete the thread now, because it still reports as active 1358 until it has executed a few instructions after the event 1359 breakpoint - if we deleted it now, "info threads" would cause us 1360 to re-attach to it. Just mark it as having had a TD_DEATH 1361 event. This means that we won't delete it from our thread list 1362 until we notice that it's dead (via prune_threads), or until 1363 something re-uses its thread ID. We'll report the thread exit 1364 when the underlying LWP dies. */ 1365 thread_info = find_thread_ptid (ptid); 1366 gdb_assert (thread_info != NULL && thread_info->priv != NULL); 1367 thread_info->priv->dying = 1; 1368} 1369 1370static void 1371thread_db_detach (struct target_ops *ops, const char *args, int from_tty) 1372{ 1373 struct target_ops *target_beneath = find_target_beneath (ops); 1374 struct thread_db_info *info; 1375 1376 info = get_thread_db_info (ptid_get_pid (inferior_ptid)); 1377 1378 if (info) 1379 { 1380 if (target_has_execution && thread_db_use_events ()) 1381 { 1382 disable_thread_event_reporting (info); 1383 1384 /* Delete the old thread event breakpoints. Note that 1385 unlike when mourning, we can remove them here because 1386 there's still a live inferior to poke at. In any case, 1387 GDB will not try to insert anything in the inferior when 1388 removing a breakpoint. */ 1389 remove_thread_event_breakpoints (); 1390 } 1391 1392 delete_thread_db_info (ptid_get_pid (inferior_ptid)); 1393 } 1394 1395 target_beneath->to_detach (target_beneath, args, from_tty); 1396 1397 /* NOTE: From this point on, inferior_ptid is null_ptid. */ 1398 1399 /* If there are no more processes using libpthread, detach the 1400 thread_db target ops. */ 1401 if (!thread_db_list) 1402 unpush_target (&thread_db_ops); 1403} 1404 1405/* Check if PID is currently stopped at the location of a thread event 1406 breakpoint location. If it is, read the event message and act upon 1407 the event. */ 1408 1409static void 1410check_event (ptid_t ptid) 1411{ 1412 struct regcache *regcache = get_thread_regcache (ptid); 1413 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1414 td_event_msg_t msg; 1415 td_thrinfo_t ti; 1416 td_err_e err; 1417 CORE_ADDR stop_pc; 1418 int loop = 0; 1419 struct thread_db_info *info; 1420 1421 info = get_thread_db_info (ptid_get_pid (ptid)); 1422 1423 /* Bail out early if we're not at a thread event breakpoint. */ 1424 stop_pc = regcache_read_pc (regcache); 1425 if (!target_supports_stopped_by_sw_breakpoint ()) 1426 stop_pc -= gdbarch_decr_pc_after_break (gdbarch); 1427 1428 if (stop_pc != info->td_create_bp_addr 1429 && stop_pc != info->td_death_bp_addr) 1430 return; 1431 1432 /* Access an lwp we know is stopped. */ 1433 info->proc_handle.ptid = ptid; 1434 1435 /* If we have only looked at the first thread before libpthread was 1436 initialized, we may not know its thread ID yet. Make sure we do 1437 before we add another thread to the list. */ 1438 if (!have_threads (ptid)) 1439 thread_db_find_new_threads_1 (ptid); 1440 1441 /* If we are at a create breakpoint, we do not know what new lwp 1442 was created and cannot specifically locate the event message for it. 1443 We have to call td_ta_event_getmsg() to get 1444 the latest message. Since we have no way of correlating whether 1445 the event message we get back corresponds to our breakpoint, we must 1446 loop and read all event messages, processing them appropriately. 1447 This guarantees we will process the correct message before continuing 1448 from the breakpoint. 1449 1450 Currently, death events are not enabled. If they are enabled, 1451 the death event can use the td_thr_event_getmsg() interface to 1452 get the message specifically for that lwp and avoid looping 1453 below. */ 1454 1455 loop = 1; 1456 1457 do 1458 { 1459 err = info->td_ta_event_getmsg_p (info->thread_agent, &msg); 1460 if (err != TD_OK) 1461 { 1462 if (err == TD_NOMSG) 1463 return; 1464 1465 error (_("Cannot get thread event message: %s"), 1466 thread_db_err_str (err)); 1467 } 1468 1469 err = info->td_thr_get_info_p (msg.th_p, &ti); 1470 if (err != TD_OK) 1471 error (_("Cannot get thread info: %s"), thread_db_err_str (err)); 1472 1473 ptid = ptid_build (ptid_get_pid (ptid), ti.ti_lid, 0); 1474 1475 switch (msg.event) 1476 { 1477 case TD_CREATE: 1478 /* Call attach_thread whether or not we already know about a 1479 thread with this thread ID. */ 1480 attach_thread (ptid, msg.th_p, &ti); 1481 1482 break; 1483 1484 case TD_DEATH: 1485 1486 if (!in_thread_list (ptid)) 1487 error (_("Spurious thread death event.")); 1488 1489 detach_thread (ptid); 1490 1491 break; 1492 1493 default: 1494 error (_("Spurious thread event.")); 1495 } 1496 } 1497 while (loop); 1498} 1499 1500static ptid_t 1501thread_db_wait (struct target_ops *ops, 1502 ptid_t ptid, struct target_waitstatus *ourstatus, 1503 int options) 1504{ 1505 struct thread_db_info *info; 1506 struct target_ops *beneath = find_target_beneath (ops); 1507 1508 ptid = beneath->to_wait (beneath, ptid, ourstatus, options); 1509 1510 if (ourstatus->kind == TARGET_WAITKIND_IGNORE) 1511 return ptid; 1512 1513 if (ourstatus->kind == TARGET_WAITKIND_EXITED 1514 || ourstatus->kind == TARGET_WAITKIND_SIGNALLED) 1515 return ptid; 1516 1517 info = get_thread_db_info (ptid_get_pid (ptid)); 1518 1519 /* If this process isn't using thread_db, we're done. */ 1520 if (info == NULL) 1521 return ptid; 1522 1523 if (ourstatus->kind == TARGET_WAITKIND_EXECD) 1524 { 1525 /* New image, it may or may not end up using thread_db. Assume 1526 not unless we find otherwise. */ 1527 delete_thread_db_info (ptid_get_pid (ptid)); 1528 if (!thread_db_list) 1529 unpush_target (&thread_db_ops); 1530 1531 /* Thread event breakpoints are deleted by 1532 update_breakpoints_after_exec. */ 1533 1534 return ptid; 1535 } 1536 1537 if (ourstatus->kind == TARGET_WAITKIND_STOPPED 1538 && ourstatus->value.sig == GDB_SIGNAL_TRAP) 1539 /* Check for a thread event. */ 1540 check_event (ptid); 1541 1542 /* Fill in the thread's user-level thread id and status. */ 1543 thread_from_lwp (ptid); 1544 1545 return ptid; 1546} 1547 1548static void 1549thread_db_mourn_inferior (struct target_ops *ops) 1550{ 1551 struct target_ops *target_beneath = find_target_beneath (ops); 1552 1553 delete_thread_db_info (ptid_get_pid (inferior_ptid)); 1554 1555 target_beneath->to_mourn_inferior (target_beneath); 1556 1557 /* Delete the old thread event breakpoints. Do this after mourning 1558 the inferior, so that we don't try to uninsert them. */ 1559 remove_thread_event_breakpoints (); 1560 1561 /* Detach thread_db target ops. */ 1562 if (!thread_db_list) 1563 unpush_target (ops); 1564} 1565 1566struct callback_data 1567{ 1568 struct thread_db_info *info; 1569 int new_threads; 1570}; 1571 1572static int 1573find_new_threads_callback (const td_thrhandle_t *th_p, void *data) 1574{ 1575 td_thrinfo_t ti; 1576 td_err_e err; 1577 ptid_t ptid; 1578 struct thread_info *tp; 1579 struct callback_data *cb_data = data; 1580 struct thread_db_info *info = cb_data->info; 1581 1582 err = info->td_thr_get_info_p (th_p, &ti); 1583 if (err != TD_OK) 1584 error (_("find_new_threads_callback: cannot get thread info: %s"), 1585 thread_db_err_str (err)); 1586 1587 if (ti.ti_lid == -1) 1588 { 1589 /* A thread with kernel thread ID -1 is either a thread that 1590 exited and was joined, or a thread that is being created but 1591 hasn't started yet, and that is reusing the tcb/stack of a 1592 thread that previously exited and was joined. (glibc marks 1593 terminated and joined threads with kernel thread ID -1. See 1594 glibc PR17707. */ 1595 if (libthread_db_debug) 1596 fprintf_unfiltered (gdb_stdlog, 1597 "thread_db: skipping exited and " 1598 "joined thread (0x%lx)\n", ti.ti_tid); 1599 return 0; 1600 } 1601 1602 if (ti.ti_tid == 0) 1603 { 1604 /* A thread ID of zero means that this is the main thread, but 1605 glibc has not yet initialized thread-local storage and the 1606 pthread library. We do not know what the thread's TID will 1607 be yet. Just enable event reporting and otherwise ignore 1608 it. */ 1609 1610 /* In that case, we're not stopped in a fork syscall and don't 1611 need this glibc bug workaround. */ 1612 info->need_stale_parent_threads_check = 0; 1613 1614 if (target_has_execution && thread_db_use_events ()) 1615 { 1616 err = info->td_thr_event_enable_p (th_p, 1); 1617 if (err != TD_OK) 1618 error (_("Cannot enable thread event reporting for LWP %d: %s"), 1619 (int) ti.ti_lid, thread_db_err_str (err)); 1620 } 1621 1622 return 0; 1623 } 1624 1625 /* Ignore stale parent threads, caused by glibc/BZ5983. This is a 1626 bit expensive, as it needs to open /proc/pid/status, so try to 1627 avoid doing the work if we know we don't have to. */ 1628 if (info->need_stale_parent_threads_check) 1629 { 1630 int tgid = linux_proc_get_tgid (ti.ti_lid); 1631 1632 if (tgid != -1 && tgid != info->pid) 1633 return 0; 1634 } 1635 1636 ptid = ptid_build (info->pid, ti.ti_lid, 0); 1637 tp = find_thread_ptid (ptid); 1638 if (tp == NULL || tp->priv == NULL) 1639 { 1640 if (attach_thread (ptid, th_p, &ti)) 1641 cb_data->new_threads += 1; 1642 else 1643 /* Problem attaching this thread; perhaps it exited before we 1644 could attach it? 1645 This could mean that the thread list inside glibc itself is in 1646 inconsistent state, and libthread_db could go on looping forever 1647 (observed with glibc-2.3.6). To prevent that, terminate 1648 iteration: thread_db_find_new_threads_2 will retry. */ 1649 return 1; 1650 } 1651 else if (target_has_execution && !thread_db_use_events ()) 1652 { 1653 /* Need to update this if not using the libthread_db events 1654 (particularly, the TD_DEATH event). */ 1655 update_thread_state (tp->priv, &ti); 1656 } 1657 1658 return 0; 1659} 1660 1661/* Helper for thread_db_find_new_threads_2. 1662 Returns number of new threads found. */ 1663 1664static int 1665find_new_threads_once (struct thread_db_info *info, int iteration, 1666 td_err_e *errp) 1667{ 1668 struct callback_data data; 1669 td_err_e err = TD_ERR; 1670 1671 data.info = info; 1672 data.new_threads = 0; 1673 1674 /* See comment in thread_db_update_thread_list. */ 1675 gdb_assert (!target_has_execution || thread_db_use_events ()); 1676 1677 TRY 1678 { 1679 /* Iterate over all user-space threads to discover new threads. */ 1680 err = info->td_ta_thr_iter_p (info->thread_agent, 1681 find_new_threads_callback, 1682 &data, 1683 TD_THR_ANY_STATE, 1684 TD_THR_LOWEST_PRIORITY, 1685 TD_SIGNO_MASK, 1686 TD_THR_ANY_USER_FLAGS); 1687 } 1688 CATCH (except, RETURN_MASK_ERROR) 1689 { 1690 if (libthread_db_debug) 1691 { 1692 exception_fprintf (gdb_stdlog, except, 1693 "Warning: find_new_threads_once: "); 1694 } 1695 } 1696 END_CATCH 1697 1698 if (libthread_db_debug) 1699 { 1700 fprintf_unfiltered (gdb_stdlog, 1701 _("Found %d new threads in iteration %d.\n"), 1702 data.new_threads, iteration); 1703 } 1704 1705 if (errp != NULL) 1706 *errp = err; 1707 1708 return data.new_threads; 1709} 1710 1711/* Search for new threads, accessing memory through stopped thread 1712 PTID. If UNTIL_NO_NEW is true, repeat searching until several 1713 searches in a row do not discover any new threads. */ 1714 1715static void 1716thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new) 1717{ 1718 td_err_e err = TD_OK; 1719 struct thread_db_info *info; 1720 int i, loop; 1721 1722 info = get_thread_db_info (ptid_get_pid (ptid)); 1723 1724 /* Access an lwp we know is stopped. */ 1725 info->proc_handle.ptid = ptid; 1726 1727 if (until_no_new) 1728 { 1729 /* Require 4 successive iterations which do not find any new threads. 1730 The 4 is a heuristic: there is an inherent race here, and I have 1731 seen that 2 iterations in a row are not always sufficient to 1732 "capture" all threads. */ 1733 for (i = 0, loop = 0; loop < 4 && err == TD_OK; ++i, ++loop) 1734 if (find_new_threads_once (info, i, &err) != 0) 1735 { 1736 /* Found some new threads. Restart the loop from beginning. */ 1737 loop = -1; 1738 } 1739 } 1740 else 1741 find_new_threads_once (info, 0, &err); 1742 1743 if (err != TD_OK) 1744 error (_("Cannot find new threads: %s"), thread_db_err_str (err)); 1745} 1746 1747static void 1748thread_db_find_new_threads_1 (ptid_t ptid) 1749{ 1750 thread_db_find_new_threads_2 (ptid, 0); 1751} 1752 1753static int 1754update_thread_core (struct lwp_info *info, void *closure) 1755{ 1756 info->core = linux_common_core_of_thread (info->ptid); 1757 return 0; 1758} 1759 1760/* Update the thread list using td_ta_thr_iter. */ 1761 1762static void 1763thread_db_update_thread_list_td_ta_thr_iter (struct target_ops *ops) 1764{ 1765 struct thread_db_info *info; 1766 struct inferior *inf; 1767 1768 prune_threads (); 1769 1770 ALL_INFERIORS (inf) 1771 { 1772 struct thread_info *thread; 1773 1774 if (inf->pid == 0) 1775 continue; 1776 1777 info = get_thread_db_info (inf->pid); 1778 if (info == NULL) 1779 continue; 1780 1781 thread = any_live_thread_of_process (inf->pid); 1782 if (thread == NULL || thread->executing) 1783 continue; 1784 1785 thread_db_find_new_threads_1 (thread->ptid); 1786 } 1787} 1788 1789/* Implement the to_update_thread_list target method for this 1790 target. */ 1791 1792static void 1793thread_db_update_thread_list (struct target_ops *ops) 1794{ 1795 /* It's best to avoid td_ta_thr_iter if possible. That walks data 1796 structures in the inferior's address space that may be corrupted, 1797 or, if the target is running, the list may change while we walk 1798 it. In the latter case, it's possible that a thread exits just 1799 at the exact time that causes GDB to get stuck in an infinite 1800 loop. To avoid pausing all threads whenever the core wants to 1801 refresh the thread list, if the kernel supports clone events 1802 (meaning we're always already attached to all LWPs), we use 1803 thread_from_lwp immediately when we see an LWP stop. That uses 1804 thread_db entry points that do not walk libpthread's thread list, 1805 so should be safe, as well as more efficient. */ 1806 if (target_has_execution && !thread_db_use_events ()) 1807 ops->beneath->to_update_thread_list (ops->beneath); 1808 else 1809 thread_db_update_thread_list_td_ta_thr_iter (ops); 1810 1811 if (target_has_execution) 1812 iterate_over_lwps (minus_one_ptid /* iterate over all */, 1813 update_thread_core, NULL); 1814} 1815 1816static char * 1817thread_db_pid_to_str (struct target_ops *ops, ptid_t ptid) 1818{ 1819 struct thread_info *thread_info = find_thread_ptid (ptid); 1820 struct target_ops *beneath; 1821 1822 if (thread_info != NULL && thread_info->priv != NULL) 1823 { 1824 static char buf[64]; 1825 thread_t tid; 1826 1827 tid = thread_info->priv->tid; 1828 snprintf (buf, sizeof (buf), "Thread 0x%lx (LWP %ld)", 1829 tid, ptid_get_lwp (ptid)); 1830 1831 return buf; 1832 } 1833 1834 beneath = find_target_beneath (ops); 1835 return beneath->to_pid_to_str (beneath, ptid); 1836} 1837 1838/* Return a string describing the state of the thread specified by 1839 INFO. */ 1840 1841static char * 1842thread_db_extra_thread_info (struct target_ops *self, 1843 struct thread_info *info) 1844{ 1845 if (info->priv == NULL) 1846 return NULL; 1847 1848 if (info->priv->dying) 1849 return "Exiting"; 1850 1851 return NULL; 1852} 1853 1854/* Get the address of the thread local variable in load module LM which 1855 is stored at OFFSET within the thread local storage for thread PTID. */ 1856 1857static CORE_ADDR 1858thread_db_get_thread_local_address (struct target_ops *ops, 1859 ptid_t ptid, 1860 CORE_ADDR lm, 1861 CORE_ADDR offset) 1862{ 1863 struct thread_info *thread_info; 1864 struct target_ops *beneath; 1865 1866 /* If we have not discovered any threads yet, check now. */ 1867 if (!have_threads (ptid)) 1868 thread_db_find_new_threads_1 (ptid); 1869 1870 /* Find the matching thread. */ 1871 thread_info = find_thread_ptid (ptid); 1872 1873 if (thread_info != NULL && thread_info->priv != NULL) 1874 { 1875 td_err_e err; 1876 psaddr_t address; 1877 struct thread_db_info *info; 1878 1879 info = get_thread_db_info (ptid_get_pid (ptid)); 1880 1881 /* Finally, get the address of the variable. */ 1882 if (lm != 0) 1883 { 1884 /* glibc doesn't provide the needed interface. */ 1885 if (!info->td_thr_tls_get_addr_p) 1886 throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR, 1887 _("No TLS library support")); 1888 1889 /* Note the cast through uintptr_t: this interface only works if 1890 a target address fits in a psaddr_t, which is a host pointer. 1891 So a 32-bit debugger can not access 64-bit TLS through this. */ 1892 err = info->td_thr_tls_get_addr_p (&thread_info->priv->th, 1893 (psaddr_t)(uintptr_t) lm, 1894 offset, &address); 1895 } 1896 else 1897 { 1898 /* If glibc doesn't provide the needed interface throw an error 1899 that LM is zero - normally cases it should not be. */ 1900 if (!info->td_thr_tlsbase_p) 1901 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR, 1902 _("TLS load module not found")); 1903 1904 /* This code path handles the case of -static -pthread executables: 1905 https://sourceware.org/ml/libc-help/2014-03/msg00024.html 1906 For older GNU libc r_debug.r_map is NULL. For GNU libc after 1907 PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL. 1908 The constant number 1 depends on GNU __libc_setup_tls 1909 initialization of l_tls_modid to 1. */ 1910 err = info->td_thr_tlsbase_p (&thread_info->priv->th, 1911 1, &address); 1912 address = (char *) address + offset; 1913 } 1914 1915#ifdef THREAD_DB_HAS_TD_NOTALLOC 1916 /* The memory hasn't been allocated, yet. */ 1917 if (err == TD_NOTALLOC) 1918 /* Now, if libthread_db provided the initialization image's 1919 address, we *could* try to build a non-lvalue value from 1920 the initialization image. */ 1921 throw_error (TLS_NOT_ALLOCATED_YET_ERROR, 1922 _("TLS not allocated yet")); 1923#endif 1924 1925 /* Something else went wrong. */ 1926 if (err != TD_OK) 1927 throw_error (TLS_GENERIC_ERROR, 1928 (("%s")), thread_db_err_str (err)); 1929 1930 /* Cast assuming host == target. Joy. */ 1931 /* Do proper sign extension for the target. */ 1932 gdb_assert (exec_bfd); 1933 return (bfd_get_sign_extend_vma (exec_bfd) > 0 1934 ? (CORE_ADDR) (intptr_t) address 1935 : (CORE_ADDR) (uintptr_t) address); 1936 } 1937 1938 beneath = find_target_beneath (ops); 1939 return beneath->to_get_thread_local_address (beneath, ptid, lm, offset); 1940} 1941 1942/* Implement the to_get_ada_task_ptid target method for this target. */ 1943 1944static ptid_t 1945thread_db_get_ada_task_ptid (struct target_ops *self, long lwp, long thread) 1946{ 1947 /* NPTL uses a 1:1 model, so the LWP id suffices. */ 1948 return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0); 1949} 1950 1951static void 1952thread_db_resume (struct target_ops *ops, 1953 ptid_t ptid, int step, enum gdb_signal signo) 1954{ 1955 struct target_ops *beneath = find_target_beneath (ops); 1956 struct thread_db_info *info; 1957 1958 if (ptid_equal (ptid, minus_one_ptid)) 1959 info = get_thread_db_info (ptid_get_pid (inferior_ptid)); 1960 else 1961 info = get_thread_db_info (ptid_get_pid (ptid)); 1962 1963 /* This workaround is only needed for child fork lwps stopped in a 1964 PTRACE_O_TRACEFORK event. When the inferior is resumed, the 1965 workaround can be disabled. */ 1966 if (info) 1967 info->need_stale_parent_threads_check = 0; 1968 1969 beneath->to_resume (beneath, ptid, step, signo); 1970} 1971 1972/* qsort helper function for info_auto_load_libthread_db, sort the 1973 thread_db_info pointers primarily by their FILENAME and secondarily by their 1974 PID, both in ascending order. */ 1975 1976static int 1977info_auto_load_libthread_db_compare (const void *ap, const void *bp) 1978{ 1979 struct thread_db_info *a = *(struct thread_db_info **) ap; 1980 struct thread_db_info *b = *(struct thread_db_info **) bp; 1981 int retval; 1982 1983 retval = strcmp (a->filename, b->filename); 1984 if (retval) 1985 return retval; 1986 1987 return (a->pid > b->pid) - (a->pid - b->pid); 1988} 1989 1990/* Implement 'info auto-load libthread-db'. */ 1991 1992static void 1993info_auto_load_libthread_db (char *args, int from_tty) 1994{ 1995 struct ui_out *uiout = current_uiout; 1996 const char *cs = args ? args : ""; 1997 struct thread_db_info *info, **array; 1998 unsigned info_count, unique_filenames; 1999 size_t max_filename_len, max_pids_len, pids_len; 2000 struct cleanup *back_to; 2001 char *pids; 2002 int i; 2003 2004 cs = skip_spaces_const (cs); 2005 if (*cs) 2006 error (_("'info auto-load libthread-db' does not accept any parameters")); 2007 2008 info_count = 0; 2009 for (info = thread_db_list; info; info = info->next) 2010 if (info->filename != NULL) 2011 info_count++; 2012 2013 array = xmalloc (sizeof (*array) * info_count); 2014 back_to = make_cleanup (xfree, array); 2015 2016 info_count = 0; 2017 for (info = thread_db_list; info; info = info->next) 2018 if (info->filename != NULL) 2019 array[info_count++] = info; 2020 2021 /* Sort ARRAY by filenames and PIDs. */ 2022 2023 qsort (array, info_count, sizeof (*array), 2024 info_auto_load_libthread_db_compare); 2025 2026 /* Calculate the number of unique filenames (rows) and the maximum string 2027 length of PIDs list for the unique filenames (columns). */ 2028 2029 unique_filenames = 0; 2030 max_filename_len = 0; 2031 max_pids_len = 0; 2032 pids_len = 0; 2033 for (i = 0; i < info_count; i++) 2034 { 2035 int pid = array[i]->pid; 2036 size_t this_pid_len; 2037 2038 for (this_pid_len = 0; pid != 0; pid /= 10) 2039 this_pid_len++; 2040 2041 if (i == 0 || strcmp (array[i - 1]->filename, array[i]->filename) != 0) 2042 { 2043 unique_filenames++; 2044 max_filename_len = max (max_filename_len, 2045 strlen (array[i]->filename)); 2046 2047 if (i > 0) 2048 { 2049 pids_len -= strlen (", "); 2050 max_pids_len = max (max_pids_len, pids_len); 2051 } 2052 pids_len = 0; 2053 } 2054 pids_len += this_pid_len + strlen (", "); 2055 } 2056 if (i) 2057 { 2058 pids_len -= strlen (", "); 2059 max_pids_len = max (max_pids_len, pids_len); 2060 } 2061 2062 /* Table header shifted right by preceding "libthread-db: " would not match 2063 its columns. */ 2064 if (info_count > 0 && args == auto_load_info_scripts_pattern_nl) 2065 ui_out_text (uiout, "\n"); 2066 2067 make_cleanup_ui_out_table_begin_end (uiout, 2, unique_filenames, 2068 "LinuxThreadDbTable"); 2069 2070 ui_out_table_header (uiout, max_filename_len, ui_left, "filename", 2071 "Filename"); 2072 ui_out_table_header (uiout, pids_len, ui_left, "PIDs", "Pids"); 2073 ui_out_table_body (uiout); 2074 2075 pids = xmalloc (max_pids_len + 1); 2076 make_cleanup (xfree, pids); 2077 2078 /* Note I is incremented inside the cycle, not at its end. */ 2079 for (i = 0; i < info_count;) 2080 { 2081 struct cleanup *chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 2082 char *pids_end; 2083 2084 info = array[i]; 2085 ui_out_field_string (uiout, "filename", info->filename); 2086 pids_end = pids; 2087 2088 while (i < info_count && strcmp (info->filename, array[i]->filename) == 0) 2089 { 2090 if (pids_end != pids) 2091 { 2092 *pids_end++ = ','; 2093 *pids_end++ = ' '; 2094 } 2095 pids_end += xsnprintf (pids_end, &pids[max_pids_len + 1] - pids_end, 2096 "%u", array[i]->pid); 2097 gdb_assert (pids_end < &pids[max_pids_len + 1]); 2098 2099 i++; 2100 } 2101 *pids_end = '\0'; 2102 2103 ui_out_field_string (uiout, "pids", pids); 2104 2105 ui_out_text (uiout, "\n"); 2106 do_cleanups (chain); 2107 } 2108 2109 do_cleanups (back_to); 2110 2111 if (info_count == 0) 2112 ui_out_message (uiout, 0, _("No auto-loaded libthread-db.\n")); 2113} 2114 2115static void 2116init_thread_db_ops (void) 2117{ 2118 thread_db_ops.to_shortname = "multi-thread"; 2119 thread_db_ops.to_longname = "multi-threaded child process."; 2120 thread_db_ops.to_doc = "Threads and pthreads support."; 2121 thread_db_ops.to_detach = thread_db_detach; 2122 thread_db_ops.to_wait = thread_db_wait; 2123 thread_db_ops.to_resume = thread_db_resume; 2124 thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior; 2125 thread_db_ops.to_update_thread_list = thread_db_update_thread_list; 2126 thread_db_ops.to_pid_to_str = thread_db_pid_to_str; 2127 thread_db_ops.to_stratum = thread_stratum; 2128 thread_db_ops.to_has_thread_control = tc_schedlock; 2129 thread_db_ops.to_get_thread_local_address 2130 = thread_db_get_thread_local_address; 2131 thread_db_ops.to_extra_thread_info = thread_db_extra_thread_info; 2132 thread_db_ops.to_get_ada_task_ptid = thread_db_get_ada_task_ptid; 2133 thread_db_ops.to_magic = OPS_MAGIC; 2134 2135 complete_target_initialization (&thread_db_ops); 2136} 2137 2138/* Provide a prototype to silence -Wmissing-prototypes. */ 2139extern initialize_file_ftype _initialize_thread_db; 2140 2141void 2142_initialize_thread_db (void) 2143{ 2144 init_thread_db_ops (); 2145 2146 /* Defer loading of libthread_db.so until inferior is running. 2147 This allows gdb to load correct libthread_db for a given 2148 executable -- there could be mutiple versions of glibc, 2149 compiled with LinuxThreads or NPTL, and until there is 2150 a running inferior, we can't tell which libthread_db is 2151 the correct one to load. */ 2152 2153 libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH); 2154 2155 add_setshow_optional_filename_cmd ("libthread-db-search-path", 2156 class_support, 2157 &libthread_db_search_path, _("\ 2158Set search path for libthread_db."), _("\ 2159Show the current search path or libthread_db."), _("\ 2160This path is used to search for libthread_db to be loaded into \ 2161gdb itself.\n\ 2162Its value is a colon (':') separate list of directories to search.\n\ 2163Setting the search path to an empty list resets it to its default value."), 2164 set_libthread_db_search_path, 2165 NULL, 2166 &setlist, &showlist); 2167 2168 add_setshow_zuinteger_cmd ("libthread-db", class_maintenance, 2169 &libthread_db_debug, _("\ 2170Set libthread-db debugging."), _("\ 2171Show libthread-db debugging."), _("\ 2172When non-zero, libthread-db debugging is enabled."), 2173 NULL, 2174 show_libthread_db_debug, 2175 &setdebuglist, &showdebuglist); 2176 2177 add_setshow_boolean_cmd ("libthread-db", class_support, 2178 &auto_load_thread_db, _("\ 2179Enable or disable auto-loading of inferior specific libthread_db."), _("\ 2180Show whether auto-loading inferior specific libthread_db is enabled."), _("\ 2181If enabled, libthread_db will be searched in 'set libthread-db-search-path'\n\ 2182locations to load libthread_db compatible with the inferior.\n\ 2183Standard system libthread_db still gets loaded even with this option off.\n\ 2184This options has security implications for untrusted inferiors."), 2185 NULL, show_auto_load_thread_db, 2186 auto_load_set_cmdlist_get (), 2187 auto_load_show_cmdlist_get ()); 2188 2189 add_cmd ("libthread-db", class_info, info_auto_load_libthread_db, 2190 _("Print the list of loaded inferior specific libthread_db.\n\ 2191Usage: info auto-load libthread-db"), 2192 auto_load_info_cmdlist_get ()); 2193 2194 /* Add ourselves to objfile event chain. */ 2195 observer_attach_new_objfile (thread_db_new_objfile); 2196 2197 /* Add ourselves to inferior_created event chain. 2198 This is needed to handle debugging statically linked programs where 2199 the new_objfile observer won't get called for libpthread. */ 2200 observer_attach_inferior_created (thread_db_inferior_created); 2201} 2202