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