1 /* libthread_db assisted debugging support, generic parts.
2 Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
23 #include "gdb_assert.h"
25 #include "gdb_proc_service.h"
26 #include "gdb_thread_db.h"
29 #include "gdbthread.h"
35 #include "solib-svr4.h"
37 #ifndef LIBTHREAD_DB_SO
38 #define LIBTHREAD_DB_SO "libthread_db.so.1"
41 /* If we're running on GNU/Linux, we must explicitly attach to any new
44 /* FIXME: There is certainly some room for improvements:
46 - Bypass libthread_db when fetching or storing registers for
47 threads bound to a LWP. */
49 /* This module's target vector. */
50 static struct target_ops thread_db_ops
;
52 /* The target vector that we call for things this module can't handle. */
53 static struct target_ops
*target_beneath
;
55 /* Pointer to the next function on the objfile event chain. */
56 static void (*target_new_objfile_chain
) (struct objfile
*objfile
);
58 /* Non-zero if we're using this module's target vector. */
59 static int using_thread_db
;
61 /* Non-zero if we have to keep this module's target vector active
63 static int keep_thread_db
;
65 /* Non-zero if we have determined the signals used by the threads
67 static int thread_signals
;
68 static sigset_t thread_stop_set
;
69 static sigset_t thread_print_set
;
71 /* Structure that identifies the child process for the
72 <proc_service.h> interface. */
73 static struct ps_prochandle proc_handle
;
75 /* Connection to the libthread_db library. */
76 static td_thragent_t
*thread_agent
;
78 /* Pointers to the libthread_db functions. */
80 static td_err_e (*td_init_p
) (void);
82 static td_err_e (*td_ta_new_p
) (struct ps_prochandle
*ps
, td_thragent_t
**ta
);
83 static td_err_e (*td_ta_map_id2thr_p
) (const td_thragent_t
*ta
, thread_t pt
,
84 td_thrhandle_t
*__th
);
85 static td_err_e (*td_ta_map_lwp2thr_p
) (const td_thragent_t
*ta
, lwpid_t lwpid
,
87 static td_err_e (*td_ta_thr_iter_p
) (const td_thragent_t
*ta
,
88 td_thr_iter_f
*callback
,
89 void *cbdata_p
, td_thr_state_e state
,
90 int ti_pri
, sigset_t
*ti_sigmask_p
,
91 unsigned int ti_user_flags
);
92 static td_err_e (*td_ta_event_addr_p
) (const td_thragent_t
*ta
,
93 td_event_e event
, td_notify_t
*ptr
);
94 static td_err_e (*td_ta_set_event_p
) (const td_thragent_t
*ta
,
95 td_thr_events_t
*event
);
96 static td_err_e (*td_ta_event_getmsg_p
) (const td_thragent_t
*ta
,
99 static td_err_e (*td_thr_validate_p
) (const td_thrhandle_t
*th
);
100 static td_err_e (*td_thr_get_info_p
) (const td_thrhandle_t
*th
,
101 td_thrinfo_t
*infop
);
102 static td_err_e (*td_thr_getfpregs_p
) (const td_thrhandle_t
*th
,
103 gdb_prfpregset_t
*regset
);
104 static td_err_e (*td_thr_getgregs_p
) (const td_thrhandle_t
*th
,
106 static td_err_e (*td_thr_setfpregs_p
) (const td_thrhandle_t
*th
,
107 const gdb_prfpregset_t
*fpregs
);
108 static td_err_e (*td_thr_setgregs_p
) (const td_thrhandle_t
*th
,
110 static td_err_e (*td_thr_event_enable_p
) (const td_thrhandle_t
*th
, int event
);
112 static td_err_e (*td_thr_tls_get_addr_p
) (const td_thrhandle_t
*th
,
117 /* Location of the thread creation event breakpoint. The code at this
118 location in the child process will be called by the pthread library
119 whenever a new thread is created. By setting a special breakpoint
120 at this location, GDB can detect when a new thread is created. We
121 obtain this location via the td_ta_event_addr call. */
122 static CORE_ADDR td_create_bp_addr
;
124 /* Location of the thread death event breakpoint. */
125 static CORE_ADDR td_death_bp_addr
;
127 /* Prototypes for local functions. */
128 static void thread_db_find_new_threads (void);
131 /* Building process ids. */
133 #define GET_PID(ptid) ptid_get_pid (ptid)
134 #define GET_LWP(ptid) ptid_get_lwp (ptid)
135 #define GET_THREAD(ptid) ptid_get_tid (ptid)
137 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
138 #define is_thread(ptid) (GET_THREAD (ptid) != 0)
140 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
141 #define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
144 struct private_thread_info
146 /* Cached LWP id. Must come first, see lin-lwp.c. */
152 thread_db_err_str (td_err_e err
)
159 return "generic 'call succeeded'";
161 return "generic error";
163 return "no thread to satisfy query";
165 return "no sync handle to satisfy query";
167 return "no LWP to satisfy query";
169 return "invalid process handle";
171 return "invalid thread handle";
173 return "invalid synchronization handle";
175 return "invalid thread agent";
177 return "invalid key";
179 return "no event message for getmsg";
181 return "FPU register set not available";
183 return "application not linked with libthread";
185 return "requested event is not supported";
187 return "capability not available";
189 return "debugger service failed";
191 return "operation not applicable to";
193 return "no thread-specific data for this thread";
195 return "malloc failed";
197 return "only part of register set was written/read";
199 return "X register set not available for this thread";
201 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
207 thread_db_state_str (td_thr_state_e state
)
214 return "stopped by debugger";
223 case TD_THR_STOPPED_ASLEEP
:
224 return "stopped by debugger AND blocked";
226 snprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
232 /* Convert between user-level thread ids and LWP ids. */
235 thread_from_lwp (ptid_t ptid
)
241 if (GET_LWP (ptid
) == 0)
242 ptid
= BUILD_LWP (GET_PID (ptid
), GET_PID (ptid
));
244 gdb_assert (is_lwp (ptid
));
246 err
= td_ta_map_lwp2thr_p (thread_agent
, GET_LWP (ptid
), &th
);
248 error ("Cannot find user-level thread for LWP %ld: %s",
249 GET_LWP (ptid
), thread_db_err_str (err
));
251 err
= td_thr_get_info_p (&th
, &ti
);
253 error ("Cannot get thread info: %s", thread_db_err_str (err
));
255 return BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
259 lwp_from_thread (ptid_t ptid
)
265 if (!is_thread (ptid
))
268 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
270 error ("Cannot find thread %ld: %s",
271 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
273 err
= td_thr_get_info_p (&th
, &ti
);
275 error ("Cannot get thread info: %s", thread_db_err_str (err
));
277 return BUILD_LWP (ti
.ti_lid
, GET_PID (ptid
));
282 thread_db_init (struct target_ops
*target
)
284 target_beneath
= target
;
288 thread_db_load (void)
293 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
296 fprintf_filtered (gdb_stderr
, "\n\ndlopen failed on '%s' - %s\n",
297 LIBTHREAD_DB_SO
, dlerror ());
298 fprintf_filtered (gdb_stderr
,
299 "GDB will not be able to debug pthreads.\n\n");
303 /* Initialize pointers to the dynamic library functions we will use.
304 Essential functions first. */
306 td_init_p
= dlsym (handle
, "td_init");
307 if (td_init_p
== NULL
)
310 td_ta_new_p
= dlsym (handle
, "td_ta_new");
311 if (td_ta_new_p
== NULL
)
314 td_ta_map_id2thr_p
= dlsym (handle
, "td_ta_map_id2thr");
315 if (td_ta_map_id2thr_p
== NULL
)
318 td_ta_map_lwp2thr_p
= dlsym (handle
, "td_ta_map_lwp2thr");
319 if (td_ta_map_lwp2thr_p
== NULL
)
322 td_ta_thr_iter_p
= dlsym (handle
, "td_ta_thr_iter");
323 if (td_ta_thr_iter_p
== NULL
)
326 td_thr_validate_p
= dlsym (handle
, "td_thr_validate");
327 if (td_thr_validate_p
== NULL
)
330 td_thr_get_info_p
= dlsym (handle
, "td_thr_get_info");
331 if (td_thr_get_info_p
== NULL
)
334 td_thr_getfpregs_p
= dlsym (handle
, "td_thr_getfpregs");
335 if (td_thr_getfpregs_p
== NULL
)
338 td_thr_getgregs_p
= dlsym (handle
, "td_thr_getgregs");
339 if (td_thr_getgregs_p
== NULL
)
342 td_thr_setfpregs_p
= dlsym (handle
, "td_thr_setfpregs");
343 if (td_thr_setfpregs_p
== NULL
)
346 td_thr_setgregs_p
= dlsym (handle
, "td_thr_setgregs");
347 if (td_thr_setgregs_p
== NULL
)
350 /* Initialize the library. */
354 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err
));
358 /* These are not essential. */
359 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
360 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
361 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
362 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
363 td_thr_tls_get_addr_p
= dlsym (handle
, "td_thr_tls_get_addr");
369 enable_thread_event_reporting (void)
371 td_thr_events_t events
;
375 /* We cannot use the thread event reporting facility if these
376 functions aren't available. */
377 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
378 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
381 /* Set the process wide mask saying which events we're interested in. */
382 td_event_emptyset (&events
);
383 td_event_addset (&events
, TD_CREATE
);
385 /* FIXME: kettenis/2000-04-23: The event reporting facility is
386 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
388 td_event_addset (&events
, TD_DEATH
);
391 err
= td_ta_set_event_p (thread_agent
, &events
);
394 warning ("Unable to set global thread event mask: %s",
395 thread_db_err_str (err
));
399 /* Delete previous thread event breakpoints, if any. */
400 remove_thread_event_breakpoints ();
402 /* Get address for thread creation breakpoint. */
403 err
= td_ta_event_addr_p (thread_agent
, TD_CREATE
, ¬ify
);
406 warning ("Unable to get location for thread creation breakpoint: %s",
407 thread_db_err_str (err
));
411 /* Set up the breakpoint. */
412 td_create_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
413 create_thread_event_breakpoint (td_create_bp_addr
);
415 /* Get address for thread death breakpoint. */
416 err
= td_ta_event_addr_p (thread_agent
, TD_DEATH
, ¬ify
);
419 warning ("Unable to get location for thread death breakpoint: %s",
420 thread_db_err_str (err
));
424 /* Set up the breakpoint. */
425 td_death_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
426 create_thread_event_breakpoint (td_death_bp_addr
);
430 disable_thread_event_reporting (void)
432 td_thr_events_t events
;
434 /* Set the process wide mask saying we aren't interested in any
436 td_event_emptyset (&events
);
437 td_ta_set_event_p (thread_agent
, &events
);
439 /* Delete thread event breakpoints, if any. */
440 remove_thread_event_breakpoints ();
441 td_create_bp_addr
= 0;
442 td_death_bp_addr
= 0;
446 check_thread_signals (void)
448 #ifdef GET_THREAD_SIGNALS
454 GET_THREAD_SIGNALS (&mask
);
455 sigemptyset (&thread_stop_set
);
456 sigemptyset (&thread_print_set
);
458 for (i
= 1; i
< NSIG
; i
++)
460 if (sigismember (&mask
, i
))
462 if (signal_stop_update (target_signal_from_host (i
), 0))
463 sigaddset (&thread_stop_set
, i
);
464 if (signal_print_update (target_signal_from_host (i
), 0))
465 sigaddset (&thread_print_set
, i
);
474 disable_thread_signals (void)
476 #ifdef GET_THREAD_SIGNALS
481 for (i
= 1; i
< NSIG
; i
++)
483 if (sigismember (&thread_stop_set
, i
))
484 signal_stop_update (target_signal_from_host (i
), 1);
485 if (sigismember (&thread_print_set
, i
))
486 signal_print_update (target_signal_from_host (i
), 1);
495 thread_db_new_objfile (struct objfile
*objfile
)
499 /* Don't attempt to use thread_db on targets which can not run
501 if (objfile
== NULL
|| !target_has_execution
)
503 /* All symbols have been discarded. If the thread_db target is
504 active, deactivate it now. */
507 gdb_assert (proc_handle
.pid
== 0);
508 unpush_target (&thread_db_ops
);
518 /* Nothing to do. The thread library was already detected and the
519 target vector was already activated. */
522 /* Initialize the structure that identifies the child process. Note
523 that at this point there is no guarantee that we actually have a
525 proc_handle
.pid
= GET_PID (inferior_ptid
);
527 /* Now attempt to open a connection to the thread library. */
528 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
532 /* No thread library was detected. */
536 /* The thread library was detected. Activate the thread_db target. */
537 push_target (&thread_db_ops
);
540 /* If the thread library was detected in the main symbol file
541 itself, we assume that the program was statically linked
542 against the thread library and well have to keep this
543 module's target vector activated until forever... Well, at
544 least until all symbols have been discarded anyway (see
546 if (objfile
== symfile_objfile
)
548 gdb_assert (proc_handle
.pid
== 0);
552 /* We can only poke around if there actually is a child process.
553 If there is no child process alive, postpone the steps below
554 until one has been created. */
555 if (proc_handle
.pid
!= 0)
557 enable_thread_event_reporting ();
558 thread_db_find_new_threads ();
563 warning ("Cannot initialize thread debugging library: %s",
564 thread_db_err_str (err
));
569 if (target_new_objfile_chain
)
570 target_new_objfile_chain (objfile
);
574 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
575 const td_thrinfo_t
*ti_p
, int verbose
)
577 struct thread_info
*tp
;
580 check_thread_signals ();
583 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid
));
585 /* Add the thread to GDB's thread list. */
586 tp
= add_thread (ptid
);
587 tp
->private = xmalloc (sizeof (struct private_thread_info
));
588 tp
->private->lwpid
= ti_p
->ti_lid
;
590 if (ti_p
->ti_state
== TD_THR_UNKNOWN
|| ti_p
->ti_state
== TD_THR_ZOMBIE
)
591 return; /* A zombie thread -- do not attach. */
593 /* Under GNU/Linux, we have to attach to each and every thread. */
595 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
)), 0);
598 /* Enable thread event reporting for this thread. */
599 err
= td_thr_event_enable_p (th_p
, 1);
601 error ("Cannot enable thread event reporting for %s: %s",
602 target_pid_to_str (ptid
), thread_db_err_str (err
));
606 thread_db_attach (char *args
, int from_tty
)
608 target_beneath
->to_attach (args
, from_tty
);
610 /* Destroy thread info; it's no longer valid. */
613 /* The child process is now the actual multi-threaded
614 program. Snatch its process ID... */
615 proc_handle
.pid
= GET_PID (inferior_ptid
);
617 /* ...and perform the remaining initialization steps. */
618 enable_thread_event_reporting ();
619 thread_db_find_new_threads();
623 detach_thread (ptid_t ptid
, int verbose
)
626 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid
));
630 thread_db_detach (char *args
, int from_tty
)
632 disable_thread_event_reporting ();
634 /* There's no need to save & restore inferior_ptid here, since the
635 inferior is supposed to be survive this function call. */
636 inferior_ptid
= lwp_from_thread (inferior_ptid
);
638 /* Forget about the child's process ID. We shouldn't need it
642 target_beneath
->to_detach (args
, from_tty
);
646 thread_db_resume (ptid_t ptid
, int step
, enum target_signal signo
)
648 struct cleanup
*old_chain
= save_inferior_ptid ();
650 if (GET_PID (ptid
) == -1)
651 inferior_ptid
= lwp_from_thread (inferior_ptid
);
652 else if (is_thread (ptid
))
653 ptid
= lwp_from_thread (ptid
);
655 target_beneath
->to_resume (ptid
, step
, signo
);
657 do_cleanups (old_chain
);
660 /* Check if PID is currently stopped at the location of a thread event
661 breakpoint location. If it is, read the event message and act upon
665 check_event (ptid_t ptid
)
672 /* Bail out early if we're not at a thread event breakpoint. */
673 stop_pc
= read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
;
674 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
677 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
683 error ("Cannot get thread event message: %s", thread_db_err_str (err
));
686 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
688 error ("Cannot get thread info: %s", thread_db_err_str (err
));
690 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
696 /* FIXME: kettenis/2000-08-26: Since we use td_ta_event_getmsg,
697 there is no guarantee that the breakpoint will match the
698 event. Should we use td_thr_event_getmsg instead? */
700 if (stop_pc
!= td_create_bp_addr
)
701 error ("Thread creation event doesn't match breakpoint.");
704 /* We may already know about this thread, for instance when the
705 user has issued the `info threads' command before the SIGTRAP
706 for hitting the thread creation breakpoint was reported. */
707 if (!in_thread_list (ptid
))
708 attach_thread (ptid
, msg
.th_p
, &ti
, 1);
713 /* FIXME: See TD_CREATE. */
715 if (stop_pc
!= td_death_bp_addr
)
716 error ("Thread death event doesn't match breakpoint.");
719 if (!in_thread_list (ptid
))
720 error ("Spurious thread death event.");
722 detach_thread (ptid
, 1);
726 error ("Spurious thread event.");
731 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
733 extern ptid_t trap_ptid
;
735 if (GET_PID (ptid
) != -1 && is_thread (ptid
))
736 ptid
= lwp_from_thread (ptid
);
738 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
740 if (proc_handle
.pid
== 0)
741 /* The current child process isn't the actual multi-threaded
742 program yet, so don't try to do any special thread-specific
743 post-processing and bail out early. */
746 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
747 return pid_to_ptid (-1);
749 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
750 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
751 /* Check for a thread event. */
754 if (!ptid_equal (trap_ptid
, null_ptid
))
755 trap_ptid
= thread_from_lwp (trap_ptid
);
757 return thread_from_lwp (ptid
);
761 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
762 struct mem_attrib
*attrib
,
763 struct target_ops
*target
)
765 struct cleanup
*old_chain
= save_inferior_ptid ();
768 if (is_thread (inferior_ptid
))
770 /* FIXME: This seems to be necessary to make sure breakpoints
772 if (!target_thread_alive (inferior_ptid
))
773 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
775 inferior_ptid
= lwp_from_thread (inferior_ptid
);
778 xfer
= target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
780 do_cleanups (old_chain
);
785 thread_db_fetch_registers (int regno
)
789 gdb_prfpregset_t fpregset
;
792 if (!is_thread (inferior_ptid
))
794 /* Pass the request to the target beneath us. */
795 target_beneath
->to_fetch_registers (regno
);
799 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (inferior_ptid
), &th
);
801 error ("Cannot find thread %ld: %s",
802 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
804 err
= td_thr_getgregs_p (&th
, gregset
);
806 error ("Cannot fetch general-purpose registers for thread %ld: %s",
807 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
809 err
= td_thr_getfpregs_p (&th
, &fpregset
);
811 error ("Cannot get floating-point registers for thread %ld: %s",
812 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
814 /* Note that we must call supply_gregset after calling the thread_db
815 routines because the thread_db routines call ps_lgetgregs and
816 friends which clobber GDB's register cache. */
817 supply_gregset ((gdb_gregset_t
*) gregset
);
818 supply_fpregset (&fpregset
);
822 thread_db_store_registers (int regno
)
826 gdb_prfpregset_t fpregset
;
829 if (!is_thread (inferior_ptid
))
831 /* Pass the request to the target beneath us. */
832 target_beneath
->to_store_registers (regno
);
836 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (inferior_ptid
), &th
);
838 error ("Cannot find thread %ld: %s",
839 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
843 char raw
[MAX_REGISTER_RAW_SIZE
];
845 deprecated_read_register_gen (regno
, raw
);
846 thread_db_fetch_registers (-1);
847 supply_register (regno
, raw
);
850 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
851 fill_fpregset (&fpregset
, -1);
853 err
= td_thr_setgregs_p (&th
, gregset
);
855 error ("Cannot store general-purpose registers for thread %ld: %s",
856 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
857 err
= td_thr_setfpregs_p (&th
, &fpregset
);
859 error ("Cannot store floating-point registers for thread %ld: %s",
860 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
864 thread_db_kill (void)
866 /* There's no need to save & restore inferior_ptid here, since the
867 inferior isn't supposed to survive this function call. */
868 inferior_ptid
= lwp_from_thread (inferior_ptid
);
869 target_beneath
->to_kill ();
873 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
)
877 unpush_target (&thread_db_ops
);
881 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
885 thread_db_post_startup_inferior (ptid_t ptid
)
887 if (proc_handle
.pid
== 0)
889 /* The child process is now the actual multi-threaded
890 program. Snatch its process ID... */
891 proc_handle
.pid
= GET_PID (ptid
);
893 /* ...and perform the remaining initialization steps. */
894 enable_thread_event_reporting ();
895 thread_db_find_new_threads ();
900 thread_db_mourn_inferior (void)
902 remove_thread_event_breakpoints ();
904 /* Forget about the child's process ID. We shouldn't need it
908 target_beneath
->to_mourn_inferior ();
912 thread_db_thread_alive (ptid_t ptid
)
918 if (is_thread (ptid
))
920 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
924 err
= td_thr_validate_p (&th
);
928 err
= td_thr_get_info_p (&th
, &ti
);
932 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
933 return 0; /* A zombie thread. */
938 if (target_beneath
->to_thread_alive
)
939 return target_beneath
->to_thread_alive (ptid
);
945 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
951 err
= td_thr_get_info_p (th_p
, &ti
);
953 error ("Cannot get thread info: %s", thread_db_err_str (err
));
955 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
956 return 0; /* A zombie -- ignore. */
958 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
960 if (!in_thread_list (ptid
))
961 attach_thread (ptid
, th_p
, &ti
, 1);
967 thread_db_find_new_threads (void)
971 /* Iterate over all user-space threads to discover new threads. */
972 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
973 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
974 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
976 error ("Cannot find new threads: %s", thread_db_err_str (err
));
980 thread_db_pid_to_str (ptid_t ptid
)
982 if (is_thread (ptid
))
989 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
991 error ("Cannot find thread %ld: %s",
992 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
994 err
= td_thr_get_info_p (&th
, &ti
);
996 error ("Cannot get thread info for thread %ld: %s",
997 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
999 if (ti
.ti_state
== TD_THR_ACTIVE
&& ti
.ti_lid
!= 0)
1001 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
1002 (long) ti
.ti_tid
, ti
.ti_lid
);
1006 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
1007 (long) ti
.ti_tid
, thread_db_state_str (ti
.ti_state
));
1013 if (target_beneath
->to_pid_to_str (ptid
))
1014 return target_beneath
->to_pid_to_str (ptid
);
1016 return normal_pid_to_str (ptid
);
1019 /* Get the address of the thread local variable in OBJFILE which is
1020 stored at OFFSET within the thread local storage for thread PTID. */
1023 thread_db_get_thread_local_address (ptid_t ptid
, struct objfile
*objfile
,
1026 if (is_thread (ptid
))
1028 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1034 /* glibc doesn't provide the needed interface. */
1035 if (! td_thr_tls_get_addr_p
)
1036 error ("Cannot find thread-local variables in this thread library.");
1038 /* Get the address of the link map for this objfile. */
1039 lm
= svr4_fetch_objfile_link_map (objfile
);
1041 /* Whoops, we couldn't find one. Bail out. */
1044 if (objfile_is_library
)
1045 error ("Cannot find shared library `%s' link_map in dynamic"
1046 " linker's module list", objfile
->name
);
1048 error ("Cannot find executable file `%s' link_map in dynamic"
1049 " linker's module list", objfile
->name
);
1052 /* Get info about the thread. */
1053 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
1055 error ("Cannot find thread %ld: %s",
1056 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
1058 /* Finally, get the address of the variable. */
1059 err
= td_thr_tls_get_addr_p (&th
, (void *) lm
, offset
, &address
);
1061 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1062 /* The memory hasn't been allocated, yet. */
1063 if (err
== TD_NOTALLOC
)
1065 /* Now, if libthread_db provided the initialization image's
1066 address, we *could* try to build a non-lvalue value from
1067 the initialization image. */
1068 if (objfile_is_library
)
1069 error ("The inferior has not yet allocated storage for"
1070 " thread-local variables in\n"
1071 "the shared library `%s'\n"
1072 "for the thread %ld",
1073 objfile
->name
, (long) GET_THREAD (ptid
));
1075 error ("The inferior has not yet allocated storage for"
1076 " thread-local variables in\n"
1077 "the executable `%s'\n"
1078 "for the thread %ld",
1079 objfile
->name
, (long) GET_THREAD (ptid
));
1083 /* Something else went wrong. */
1086 if (objfile_is_library
)
1087 error ("Cannot find thread-local storage for thread %ld, "
1088 "shared library %s:\n%s",
1089 (long) GET_THREAD (ptid
),
1091 thread_db_err_str (err
));
1093 error ("Cannot find thread-local storage for thread %ld, "
1094 "executable file %s:\n%s",
1095 (long) GET_THREAD (ptid
),
1097 thread_db_err_str (err
));
1100 /* Cast assuming host == target. Joy. */
1101 return (CORE_ADDR
) address
;
1104 if (target_beneath
->to_get_thread_local_address
)
1105 return target_beneath
->to_get_thread_local_address (ptid
, objfile
, offset
);
1107 error ("Cannot find thread-local values on this target.");
1111 init_thread_db_ops (void)
1113 thread_db_ops
.to_shortname
= "multi-thread";
1114 thread_db_ops
.to_longname
= "multi-threaded child process.";
1115 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1116 thread_db_ops
.to_attach
= thread_db_attach
;
1117 thread_db_ops
.to_detach
= thread_db_detach
;
1118 thread_db_ops
.to_resume
= thread_db_resume
;
1119 thread_db_ops
.to_wait
= thread_db_wait
;
1120 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1121 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1122 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
1123 thread_db_ops
.to_kill
= thread_db_kill
;
1124 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1125 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1126 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1127 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1128 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1129 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1130 thread_db_ops
.to_stratum
= thread_stratum
;
1131 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1132 thread_db_ops
.to_get_thread_local_address
1133 = thread_db_get_thread_local_address
;
1134 thread_db_ops
.to_magic
= OPS_MAGIC
;
1138 _initialize_thread_db (void)
1140 /* Only initialize the module if we can load libthread_db. */
1141 if (thread_db_load ())
1143 init_thread_db_ops ();
1144 add_target (&thread_db_ops
);
1146 /* Add ourselves to objfile event chain. */
1147 target_new_objfile_chain
= target_new_objfile_hook
;
1148 target_new_objfile_hook
= thread_db_new_objfile
;