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 ("thread_from_lwp: cannot get thread info: %s",
254 thread_db_err_str (err
));
256 return BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
260 lwp_from_thread (ptid_t ptid
)
266 if (!is_thread (ptid
))
269 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
271 error ("Cannot find thread %ld: %s",
272 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
274 err
= td_thr_get_info_p (&th
, &ti
);
276 error ("lwp_from_thread: cannot get thread info: %s",
277 thread_db_err_str (err
));
279 return BUILD_LWP (ti
.ti_lid
, GET_PID (ptid
));
284 thread_db_init (struct target_ops
*target
)
286 target_beneath
= target
;
290 thread_db_load (void)
295 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
298 fprintf_filtered (gdb_stderr
, "\n\ndlopen failed on '%s' - %s\n",
299 LIBTHREAD_DB_SO
, dlerror ());
300 fprintf_filtered (gdb_stderr
,
301 "GDB will not be able to debug pthreads.\n\n");
305 /* Initialize pointers to the dynamic library functions we will use.
306 Essential functions first. */
308 td_init_p
= dlsym (handle
, "td_init");
309 if (td_init_p
== NULL
)
312 td_ta_new_p
= dlsym (handle
, "td_ta_new");
313 if (td_ta_new_p
== NULL
)
316 td_ta_map_id2thr_p
= dlsym (handle
, "td_ta_map_id2thr");
317 if (td_ta_map_id2thr_p
== NULL
)
320 td_ta_map_lwp2thr_p
= dlsym (handle
, "td_ta_map_lwp2thr");
321 if (td_ta_map_lwp2thr_p
== NULL
)
324 td_ta_thr_iter_p
= dlsym (handle
, "td_ta_thr_iter");
325 if (td_ta_thr_iter_p
== NULL
)
328 td_thr_validate_p
= dlsym (handle
, "td_thr_validate");
329 if (td_thr_validate_p
== NULL
)
332 td_thr_get_info_p
= dlsym (handle
, "td_thr_get_info");
333 if (td_thr_get_info_p
== NULL
)
336 td_thr_getfpregs_p
= dlsym (handle
, "td_thr_getfpregs");
337 if (td_thr_getfpregs_p
== NULL
)
340 td_thr_getgregs_p
= dlsym (handle
, "td_thr_getgregs");
341 if (td_thr_getgregs_p
== NULL
)
344 td_thr_setfpregs_p
= dlsym (handle
, "td_thr_setfpregs");
345 if (td_thr_setfpregs_p
== NULL
)
348 td_thr_setgregs_p
= dlsym (handle
, "td_thr_setgregs");
349 if (td_thr_setgregs_p
== NULL
)
352 /* Initialize the library. */
356 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err
));
360 /* These are not essential. */
361 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
362 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
363 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
364 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
365 td_thr_tls_get_addr_p
= dlsym (handle
, "td_thr_tls_get_addr");
371 enable_thread_event_reporting (void)
373 td_thr_events_t events
;
377 /* We cannot use the thread event reporting facility if these
378 functions aren't available. */
379 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
380 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
383 /* Set the process wide mask saying which events we're interested in. */
384 td_event_emptyset (&events
);
385 td_event_addset (&events
, TD_CREATE
);
387 /* FIXME: kettenis/2000-04-23: The event reporting facility is
388 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
390 td_event_addset (&events
, TD_DEATH
);
393 err
= td_ta_set_event_p (thread_agent
, &events
);
396 warning ("Unable to set global thread event mask: %s",
397 thread_db_err_str (err
));
401 /* Delete previous thread event breakpoints, if any. */
402 remove_thread_event_breakpoints ();
404 /* Get address for thread creation breakpoint. */
405 err
= td_ta_event_addr_p (thread_agent
, TD_CREATE
, ¬ify
);
408 warning ("Unable to get location for thread creation breakpoint: %s",
409 thread_db_err_str (err
));
413 /* Set up the breakpoint. */
414 td_create_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
415 create_thread_event_breakpoint (td_create_bp_addr
);
417 /* Get address for thread death breakpoint. */
418 err
= td_ta_event_addr_p (thread_agent
, TD_DEATH
, ¬ify
);
421 warning ("Unable to get location for thread death breakpoint: %s",
422 thread_db_err_str (err
));
426 /* Set up the breakpoint. */
427 td_death_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
428 create_thread_event_breakpoint (td_death_bp_addr
);
432 disable_thread_event_reporting (void)
434 td_thr_events_t events
;
436 /* Set the process wide mask saying we aren't interested in any
438 td_event_emptyset (&events
);
439 td_ta_set_event_p (thread_agent
, &events
);
441 /* Delete thread event breakpoints, if any. */
442 remove_thread_event_breakpoints ();
443 td_create_bp_addr
= 0;
444 td_death_bp_addr
= 0;
448 check_thread_signals (void)
450 #ifdef GET_THREAD_SIGNALS
456 GET_THREAD_SIGNALS (&mask
);
457 sigemptyset (&thread_stop_set
);
458 sigemptyset (&thread_print_set
);
460 for (i
= 1; i
< NSIG
; i
++)
462 if (sigismember (&mask
, i
))
464 if (signal_stop_update (target_signal_from_host (i
), 0))
465 sigaddset (&thread_stop_set
, i
);
466 if (signal_print_update (target_signal_from_host (i
), 0))
467 sigaddset (&thread_print_set
, i
);
476 disable_thread_signals (void)
478 #ifdef GET_THREAD_SIGNALS
483 for (i
= 1; i
< NSIG
; i
++)
485 if (sigismember (&thread_stop_set
, i
))
486 signal_stop_update (target_signal_from_host (i
), 1);
487 if (sigismember (&thread_print_set
, i
))
488 signal_print_update (target_signal_from_host (i
), 1);
497 thread_db_new_objfile (struct objfile
*objfile
)
501 /* Don't attempt to use thread_db on targets which can not run
503 if (objfile
== NULL
|| !target_has_execution
)
505 /* All symbols have been discarded. If the thread_db target is
506 active, deactivate it now. */
509 gdb_assert (proc_handle
.pid
== 0);
510 unpush_target (&thread_db_ops
);
520 /* Nothing to do. The thread library was already detected and the
521 target vector was already activated. */
524 /* Initialize the structure that identifies the child process. Note
525 that at this point there is no guarantee that we actually have a
527 proc_handle
.pid
= GET_PID (inferior_ptid
);
529 /* Now attempt to open a connection to the thread library. */
530 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
534 /* No thread library was detected. */
538 /* The thread library was detected. Activate the thread_db target. */
539 push_target (&thread_db_ops
);
542 /* If the thread library was detected in the main symbol file
543 itself, we assume that the program was statically linked
544 against the thread library and well have to keep this
545 module's target vector activated until forever... Well, at
546 least until all symbols have been discarded anyway (see
548 if (objfile
== symfile_objfile
)
550 gdb_assert (proc_handle
.pid
== 0);
554 /* We can only poke around if there actually is a child process.
555 If there is no child process alive, postpone the steps below
556 until one has been created. */
557 if (proc_handle
.pid
!= 0)
559 enable_thread_event_reporting ();
560 thread_db_find_new_threads ();
565 warning ("Cannot initialize thread debugging library: %s",
566 thread_db_err_str (err
));
571 if (target_new_objfile_chain
)
572 target_new_objfile_chain (objfile
);
576 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
577 const td_thrinfo_t
*ti_p
, int verbose
)
579 struct thread_info
*tp
;
582 check_thread_signals ();
585 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid
));
587 /* Add the thread to GDB's thread list. */
588 tp
= add_thread (ptid
);
589 tp
->private = xmalloc (sizeof (struct private_thread_info
));
590 tp
->private->lwpid
= ti_p
->ti_lid
;
592 if (ti_p
->ti_state
== TD_THR_UNKNOWN
|| ti_p
->ti_state
== TD_THR_ZOMBIE
)
593 return; /* A zombie thread -- do not attach. */
595 /* Under GNU/Linux, we have to attach to each and every thread. */
597 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
)), 0);
600 /* Enable thread event reporting for this thread. */
601 err
= td_thr_event_enable_p (th_p
, 1);
603 error ("Cannot enable thread event reporting for %s: %s",
604 target_pid_to_str (ptid
), thread_db_err_str (err
));
608 thread_db_attach (char *args
, int from_tty
)
610 target_beneath
->to_attach (args
, from_tty
);
612 /* Destroy thread info; it's no longer valid. */
615 /* The child process is now the actual multi-threaded
616 program. Snatch its process ID... */
617 proc_handle
.pid
= GET_PID (inferior_ptid
);
619 /* ...and perform the remaining initialization steps. */
620 enable_thread_event_reporting ();
621 thread_db_find_new_threads();
625 detach_thread (ptid_t ptid
, int verbose
)
628 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid
));
632 thread_db_detach (char *args
, int from_tty
)
634 disable_thread_event_reporting ();
636 /* There's no need to save & restore inferior_ptid here, since the
637 inferior is supposed to be survive this function call. */
638 inferior_ptid
= lwp_from_thread (inferior_ptid
);
640 /* Forget about the child's process ID. We shouldn't need it
644 target_beneath
->to_detach (args
, from_tty
);
648 thread_db_resume (ptid_t ptid
, int step
, enum target_signal signo
)
650 struct cleanup
*old_chain
= save_inferior_ptid ();
652 if (GET_PID (ptid
) == -1)
653 inferior_ptid
= lwp_from_thread (inferior_ptid
);
654 else if (is_thread (ptid
))
655 ptid
= lwp_from_thread (ptid
);
657 target_beneath
->to_resume (ptid
, step
, signo
);
659 do_cleanups (old_chain
);
662 /* Check if PID is currently stopped at the location of a thread event
663 breakpoint location. If it is, read the event message and act upon
667 check_event (ptid_t ptid
)
674 /* Bail out early if we're not at a thread event breakpoint. */
675 stop_pc
= read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
;
676 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
679 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
685 error ("Cannot get thread event message: %s", thread_db_err_str (err
));
688 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
690 error ("check_event: cannot get thread info: %s",
691 thread_db_err_str (err
));
693 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
699 /* FIXME: kettenis/2000-08-26: Since we use td_ta_event_getmsg,
700 there is no guarantee that the breakpoint will match the
701 event. Should we use td_thr_event_getmsg instead? */
703 if (stop_pc
!= td_create_bp_addr
)
704 error ("Thread creation event doesn't match breakpoint.");
707 /* We may already know about this thread, for instance when the
708 user has issued the `info threads' command before the SIGTRAP
709 for hitting the thread creation breakpoint was reported. */
710 if (!in_thread_list (ptid
))
711 attach_thread (ptid
, msg
.th_p
, &ti
, 1);
716 /* FIXME: See TD_CREATE. */
718 if (stop_pc
!= td_death_bp_addr
)
719 error ("Thread death event doesn't match breakpoint.");
722 if (!in_thread_list (ptid
))
723 error ("Spurious thread death event.");
725 detach_thread (ptid
, 1);
729 error ("Spurious thread event.");
734 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
736 extern ptid_t trap_ptid
;
738 if (GET_PID (ptid
) != -1 && is_thread (ptid
))
739 ptid
= lwp_from_thread (ptid
);
741 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
743 if (proc_handle
.pid
== 0)
744 /* The current child process isn't the actual multi-threaded
745 program yet, so don't try to do any special thread-specific
746 post-processing and bail out early. */
749 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
750 return pid_to_ptid (-1);
752 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
753 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
754 /* Check for a thread event. */
757 if (!ptid_equal (trap_ptid
, null_ptid
))
758 trap_ptid
= thread_from_lwp (trap_ptid
);
760 return thread_from_lwp (ptid
);
764 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
765 struct mem_attrib
*attrib
,
766 struct target_ops
*target
)
768 struct cleanup
*old_chain
= save_inferior_ptid ();
771 if (is_thread (inferior_ptid
))
773 /* FIXME: This seems to be necessary to make sure breakpoints
775 if (!target_thread_alive (inferior_ptid
))
776 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
778 inferior_ptid
= lwp_from_thread (inferior_ptid
);
781 xfer
= target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
783 do_cleanups (old_chain
);
788 thread_db_fetch_registers (int regno
)
792 gdb_prfpregset_t fpregset
;
795 if (!is_thread (inferior_ptid
))
797 /* Pass the request to the target beneath us. */
798 target_beneath
->to_fetch_registers (regno
);
802 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (inferior_ptid
), &th
);
804 error ("Cannot find thread %ld: %s",
805 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
807 err
= td_thr_getgregs_p (&th
, gregset
);
809 error ("Cannot fetch general-purpose registers for thread %ld: %s",
810 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
812 err
= td_thr_getfpregs_p (&th
, &fpregset
);
814 error ("Cannot get floating-point registers for thread %ld: %s",
815 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
817 /* Note that we must call supply_gregset after calling the thread_db
818 routines because the thread_db routines call ps_lgetgregs and
819 friends which clobber GDB's register cache. */
820 supply_gregset ((gdb_gregset_t
*) gregset
);
821 supply_fpregset (&fpregset
);
825 thread_db_store_registers (int regno
)
829 gdb_prfpregset_t fpregset
;
832 if (!is_thread (inferior_ptid
))
834 /* Pass the request to the target beneath us. */
835 target_beneath
->to_store_registers (regno
);
839 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (inferior_ptid
), &th
);
841 error ("Cannot find thread %ld: %s",
842 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
846 char raw
[MAX_REGISTER_RAW_SIZE
];
848 deprecated_read_register_gen (regno
, raw
);
849 thread_db_fetch_registers (-1);
850 supply_register (regno
, raw
);
853 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
854 fill_fpregset (&fpregset
, -1);
856 err
= td_thr_setgregs_p (&th
, gregset
);
858 error ("Cannot store general-purpose registers for thread %ld: %s",
859 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
860 err
= td_thr_setfpregs_p (&th
, &fpregset
);
862 error ("Cannot store floating-point registers for thread %ld: %s",
863 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
867 thread_db_kill (void)
869 /* There's no need to save & restore inferior_ptid here, since the
870 inferior isn't supposed to survive this function call. */
871 inferior_ptid
= lwp_from_thread (inferior_ptid
);
872 target_beneath
->to_kill ();
876 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
)
880 unpush_target (&thread_db_ops
);
884 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
888 thread_db_post_startup_inferior (ptid_t ptid
)
890 if (proc_handle
.pid
== 0)
892 /* The child process is now the actual multi-threaded
893 program. Snatch its process ID... */
894 proc_handle
.pid
= GET_PID (ptid
);
896 /* ...and perform the remaining initialization steps. */
897 enable_thread_event_reporting ();
898 thread_db_find_new_threads ();
903 thread_db_mourn_inferior (void)
905 remove_thread_event_breakpoints ();
907 /* Forget about the child's process ID. We shouldn't need it
911 target_beneath
->to_mourn_inferior ();
915 thread_db_thread_alive (ptid_t ptid
)
921 if (is_thread (ptid
))
923 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
927 err
= td_thr_validate_p (&th
);
931 err
= td_thr_get_info_p (&th
, &ti
);
935 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
936 return 0; /* A zombie thread. */
941 if (target_beneath
->to_thread_alive
)
942 return target_beneath
->to_thread_alive (ptid
);
948 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
954 err
= td_thr_get_info_p (th_p
, &ti
);
956 error ("find_new_threads_callback: cannot get thread info: %s",
957 thread_db_err_str (err
));
959 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
960 return 0; /* A zombie -- ignore. */
962 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
964 if (!in_thread_list (ptid
))
965 attach_thread (ptid
, th_p
, &ti
, 1);
971 thread_db_find_new_threads (void)
975 /* Iterate over all user-space threads to discover new threads. */
976 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
977 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
978 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
980 error ("Cannot find new threads: %s", thread_db_err_str (err
));
984 thread_db_pid_to_str (ptid_t ptid
)
986 if (is_thread (ptid
))
993 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
995 error ("Cannot find thread %ld: %s",
996 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
998 err
= td_thr_get_info_p (&th
, &ti
);
1000 error ("thread_db_pid_to_str: cannot get thread info for %ld: %s",
1001 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
1003 if (ti
.ti_state
== TD_THR_ACTIVE
&& ti
.ti_lid
!= 0)
1005 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
1006 (long) ti
.ti_tid
, ti
.ti_lid
);
1010 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
1011 (long) ti
.ti_tid
, thread_db_state_str (ti
.ti_state
));
1017 if (target_beneath
->to_pid_to_str (ptid
))
1018 return target_beneath
->to_pid_to_str (ptid
);
1020 return normal_pid_to_str (ptid
);
1023 /* Get the address of the thread local variable in OBJFILE which is
1024 stored at OFFSET within the thread local storage for thread PTID. */
1027 thread_db_get_thread_local_address (ptid_t ptid
, struct objfile
*objfile
,
1030 if (is_thread (ptid
))
1032 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1038 /* glibc doesn't provide the needed interface. */
1039 if (! td_thr_tls_get_addr_p
)
1040 error ("Cannot find thread-local variables in this thread library.");
1042 /* Get the address of the link map for this objfile. */
1043 lm
= svr4_fetch_objfile_link_map (objfile
);
1045 /* Whoops, we couldn't find one. Bail out. */
1048 if (objfile_is_library
)
1049 error ("Cannot find shared library `%s' link_map in dynamic"
1050 " linker's module list", objfile
->name
);
1052 error ("Cannot find executable file `%s' link_map in dynamic"
1053 " linker's module list", objfile
->name
);
1056 /* Get info about the thread. */
1057 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
1059 error ("Cannot find thread %ld: %s",
1060 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
1062 /* Finally, get the address of the variable. */
1063 err
= td_thr_tls_get_addr_p (&th
, (void *) lm
, offset
, &address
);
1065 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1066 /* The memory hasn't been allocated, yet. */
1067 if (err
== TD_NOTALLOC
)
1069 /* Now, if libthread_db provided the initialization image's
1070 address, we *could* try to build a non-lvalue value from
1071 the initialization image. */
1072 if (objfile_is_library
)
1073 error ("The inferior has not yet allocated storage for"
1074 " thread-local variables in\n"
1075 "the shared library `%s'\n"
1076 "for the thread %ld",
1077 objfile
->name
, (long) GET_THREAD (ptid
));
1079 error ("The inferior has not yet allocated storage for"
1080 " thread-local variables in\n"
1081 "the executable `%s'\n"
1082 "for the thread %ld",
1083 objfile
->name
, (long) GET_THREAD (ptid
));
1087 /* Something else went wrong. */
1090 if (objfile_is_library
)
1091 error ("Cannot find thread-local storage for thread %ld, "
1092 "shared library %s:\n%s",
1093 (long) GET_THREAD (ptid
),
1095 thread_db_err_str (err
));
1097 error ("Cannot find thread-local storage for thread %ld, "
1098 "executable file %s:\n%s",
1099 (long) GET_THREAD (ptid
),
1101 thread_db_err_str (err
));
1104 /* Cast assuming host == target. Joy. */
1105 return (CORE_ADDR
) address
;
1108 if (target_beneath
->to_get_thread_local_address
)
1109 return target_beneath
->to_get_thread_local_address (ptid
, objfile
, offset
);
1111 error ("Cannot find thread-local values on this target.");
1115 init_thread_db_ops (void)
1117 thread_db_ops
.to_shortname
= "multi-thread";
1118 thread_db_ops
.to_longname
= "multi-threaded child process.";
1119 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1120 thread_db_ops
.to_attach
= thread_db_attach
;
1121 thread_db_ops
.to_detach
= thread_db_detach
;
1122 thread_db_ops
.to_resume
= thread_db_resume
;
1123 thread_db_ops
.to_wait
= thread_db_wait
;
1124 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1125 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1126 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
1127 thread_db_ops
.to_kill
= thread_db_kill
;
1128 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1129 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1130 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1131 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1132 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1133 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1134 thread_db_ops
.to_stratum
= thread_stratum
;
1135 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1136 thread_db_ops
.to_get_thread_local_address
1137 = thread_db_get_thread_local_address
;
1138 thread_db_ops
.to_magic
= OPS_MAGIC
;
1142 _initialize_thread_db (void)
1144 /* Only initialize the module if we can load libthread_db. */
1145 if (thread_db_load ())
1147 init_thread_db_ops ();
1148 add_target (&thread_db_ops
);
1150 /* Add ourselves to objfile event chain. */
1151 target_new_objfile_chain
= target_new_objfile_hook
;
1152 target_new_objfile_hook
= thread_db_new_objfile
;