1 /* libthread_db assisted debugging support, generic parts.
3 Copyright 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
5 This file is part of GDB.
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 2 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "gdb_assert.h"
26 #include "gdb_proc_service.h"
27 #include "gdb_thread_db.h"
30 #include "gdbthread.h"
36 #include "solib-svr4.h"
38 #ifndef LIBTHREAD_DB_SO
39 #define LIBTHREAD_DB_SO "libthread_db.so.1"
42 /* If we're running on GNU/Linux, we must explicitly attach to any new
45 /* FIXME: There is certainly some room for improvements:
47 - Bypass libthread_db when fetching or storing registers for
48 threads bound to a LWP. */
50 /* This module's target vector. */
51 static struct target_ops thread_db_ops
;
53 /* The target vector that we call for things this module can't handle. */
54 static struct target_ops
*target_beneath
;
56 /* Pointer to the next function on the objfile event chain. */
57 static void (*target_new_objfile_chain
) (struct objfile
* objfile
);
59 /* Non-zero if we're using this module's target vector. */
60 static int using_thread_db
;
62 /* Non-zero if we have to keep this module's target vector active
64 static int keep_thread_db
;
66 /* Non-zero if we have determined the signals used by the threads
68 static int thread_signals
;
69 static sigset_t thread_stop_set
;
70 static sigset_t thread_print_set
;
72 /* Structure that identifies the child process for the
73 <proc_service.h> interface. */
74 static struct ps_prochandle proc_handle
;
76 /* Connection to the libthread_db library. */
77 static td_thragent_t
*thread_agent
;
79 /* Pointers to the libthread_db functions. */
81 static td_err_e (*td_init_p
) (void);
83 static td_err_e (*td_ta_new_p
) (struct ps_prochandle
* ps
,
85 static td_err_e (*td_ta_map_id2thr_p
) (const td_thragent_t
*ta
, thread_t pt
,
86 td_thrhandle_t
*__th
);
87 static td_err_e (*td_ta_map_lwp2thr_p
) (const td_thragent_t
*ta
,
88 lwpid_t lwpid
, td_thrhandle_t
*th
);
89 static td_err_e (*td_ta_thr_iter_p
) (const td_thragent_t
*ta
,
90 td_thr_iter_f
*callback
, void *cbdata_p
,
91 td_thr_state_e state
, int ti_pri
,
92 sigset_t
*ti_sigmask_p
,
93 unsigned int ti_user_flags
);
94 static td_err_e (*td_ta_event_addr_p
) (const td_thragent_t
*ta
,
95 td_event_e event
, td_notify_t
*ptr
);
96 static td_err_e (*td_ta_set_event_p
) (const td_thragent_t
*ta
,
97 td_thr_events_t
*event
);
98 static td_err_e (*td_ta_event_getmsg_p
) (const td_thragent_t
*ta
,
101 static td_err_e (*td_thr_validate_p
) (const td_thrhandle_t
*th
);
102 static td_err_e (*td_thr_get_info_p
) (const td_thrhandle_t
*th
,
103 td_thrinfo_t
*infop
);
104 static td_err_e (*td_thr_getfpregs_p
) (const td_thrhandle_t
*th
,
105 gdb_prfpregset_t
*regset
);
106 static td_err_e (*td_thr_getgregs_p
) (const td_thrhandle_t
*th
,
108 static td_err_e (*td_thr_setfpregs_p
) (const td_thrhandle_t
*th
,
109 const gdb_prfpregset_t
*fpregs
);
110 static td_err_e (*td_thr_setgregs_p
) (const td_thrhandle_t
*th
,
112 static td_err_e (*td_thr_event_enable_p
) (const td_thrhandle_t
*th
,
115 static td_err_e (*td_thr_tls_get_addr_p
) (const td_thrhandle_t
*th
,
117 size_t offset
, void **address
);
119 /* Location of the thread creation event breakpoint. The code at this
120 location in the child process will be called by the pthread library
121 whenever a new thread is created. By setting a special breakpoint
122 at this location, GDB can detect when a new thread is created. We
123 obtain this location via the td_ta_event_addr call. */
124 static CORE_ADDR td_create_bp_addr
;
126 /* Location of the thread death event breakpoint. */
127 static CORE_ADDR td_death_bp_addr
;
129 /* Prototypes for local functions. */
130 static void thread_db_find_new_threads (void);
131 static void attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
132 const td_thrinfo_t
*ti_p
, int verbose
);
135 /* Building process ids. */
137 #define GET_PID(ptid) ptid_get_pid (ptid)
138 #define GET_LWP(ptid) ptid_get_lwp (ptid)
139 #define GET_THREAD(ptid) ptid_get_tid (ptid)
141 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
142 #define is_thread(ptid) (GET_THREAD (ptid) != 0)
144 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
145 #define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
148 /* Use "struct private_thread_info" to cache thread state. This is
149 a substantial optimization. */
151 struct private_thread_info
153 /* Cached thread state. */
154 unsigned int th_valid
:1;
155 unsigned int ti_valid
:1;
163 thread_db_err_str (td_err_e err
)
170 return "generic 'call succeeded'";
172 return "generic error";
174 return "no thread to satisfy query";
176 return "no sync handle to satisfy query";
178 return "no LWP to satisfy query";
180 return "invalid process handle";
182 return "invalid thread handle";
184 return "invalid synchronization handle";
186 return "invalid thread agent";
188 return "invalid key";
190 return "no event message for getmsg";
192 return "FPU register set not available";
194 return "application not linked with libthread";
196 return "requested event is not supported";
198 return "capability not available";
200 return "debugger service failed";
202 return "operation not applicable to";
204 return "no thread-specific data for this thread";
206 return "malloc failed";
208 return "only part of register set was written/read";
210 return "X register set not available for this thread";
212 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
218 thread_db_state_str (td_thr_state_e state
)
225 return "stopped by debugger";
234 case TD_THR_STOPPED_ASLEEP
:
235 return "stopped by debugger AND blocked";
237 snprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
242 /* A callback function for td_ta_thr_iter, which we use to map all
245 THP is a handle to the current thread; if INFOP is not NULL, the
246 struct thread_info associated with this thread is returned in
250 thread_get_info_callback (const td_thrhandle_t
*thp
, void *infop
)
254 struct thread_info
*thread_info
;
257 err
= td_thr_get_info_p (thp
, &ti
);
259 error ("thread_get_info_callback: cannot get thread info: %s",
260 thread_db_err_str (err
));
262 /* Fill the cache. */
263 thread_ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
264 thread_info
= find_thread_pid (thread_ptid
);
266 if (thread_info
== NULL
)
268 /* New thread. Attach to it now (why wait?). */
269 attach_thread (thread_ptid
, thp
, &ti
, 1);
270 thread_info
= find_thread_pid (thread_ptid
);
271 gdb_assert (thread_info
!= NULL
);
274 memcpy (&thread_info
->private->th
, thp
, sizeof (*thp
));
275 thread_info
->private->th_valid
= 1;
276 memcpy (&thread_info
->private->ti
, &ti
, sizeof (ti
));
277 thread_info
->private->ti_valid
= 1;
280 *(struct thread_info
**) infop
= thread_info
;
285 /* Accessor functions for the thread_db information, with caching. */
288 thread_db_map_id2thr (struct thread_info
*thread_info
, int fatal
)
292 if (thread_info
->private->th_valid
)
295 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (thread_info
->ptid
),
296 &thread_info
->private->th
);
300 error ("Cannot find thread %ld: %s",
301 (long) GET_THREAD (thread_info
->ptid
),
302 thread_db_err_str (err
));
305 thread_info
->private->th_valid
= 1;
308 static td_thrinfo_t
*
309 thread_db_get_info (struct thread_info
*thread_info
)
313 if (thread_info
->private->ti_valid
)
314 return &thread_info
->private->ti
;
316 if (!thread_info
->private->th_valid
)
317 thread_db_map_id2thr (thread_info
, 1);
320 td_thr_get_info_p (&thread_info
->private->th
, &thread_info
->private->ti
);
322 error ("thread_db_get_info: cannot get thread info: %s",
323 thread_db_err_str (err
));
325 thread_info
->private->ti_valid
= 1;
326 return &thread_info
->private->ti
;
329 /* Convert between user-level thread ids and LWP ids. */
332 thread_from_lwp (ptid_t ptid
)
336 struct thread_info
*thread_info
;
339 if (GET_LWP (ptid
) == 0)
340 ptid
= BUILD_LWP (GET_PID (ptid
), GET_PID (ptid
));
342 gdb_assert (is_lwp (ptid
));
344 err
= td_ta_map_lwp2thr_p (thread_agent
, GET_LWP (ptid
), &th
);
346 error ("Cannot find user-level thread for LWP %ld: %s",
347 GET_LWP (ptid
), thread_db_err_str (err
));
350 thread_get_info_callback (&th
, &thread_info
);
351 gdb_assert (thread_info
&& thread_info
->private->ti_valid
);
353 return BUILD_THREAD (thread_info
->private->ti
.ti_tid
, GET_PID (ptid
));
357 lwp_from_thread (ptid_t ptid
)
359 struct thread_info
*thread_info
;
362 if (!is_thread (ptid
))
365 thread_info
= find_thread_pid (ptid
);
366 thread_db_get_info (thread_info
);
368 return BUILD_LWP (thread_info
->private->ti
.ti_lid
, GET_PID (ptid
));
373 thread_db_init (struct target_ops
*target
)
375 target_beneath
= target
;
379 verbose_dlsym (void *handle
, const char *name
)
381 void *sym
= dlsym (handle
, name
);
383 warning ("Symbol \"%s\" not found in libthread_db: %s", name
, dlerror ());
388 thread_db_load (void)
393 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
396 fprintf_filtered (gdb_stderr
, "\n\ndlopen failed on '%s' - %s\n",
397 LIBTHREAD_DB_SO
, dlerror ());
398 fprintf_filtered (gdb_stderr
,
399 "GDB will not be able to debug pthreads.\n\n");
403 /* Initialize pointers to the dynamic library functions we will use.
404 Essential functions first. */
406 td_init_p
= verbose_dlsym (handle
, "td_init");
407 if (td_init_p
== NULL
)
410 td_ta_new_p
= verbose_dlsym (handle
, "td_ta_new");
411 if (td_ta_new_p
== NULL
)
414 td_ta_map_id2thr_p
= verbose_dlsym (handle
, "td_ta_map_id2thr");
415 if (td_ta_map_id2thr_p
== NULL
)
418 td_ta_map_lwp2thr_p
= verbose_dlsym (handle
, "td_ta_map_lwp2thr");
419 if (td_ta_map_lwp2thr_p
== NULL
)
422 td_ta_thr_iter_p
= verbose_dlsym (handle
, "td_ta_thr_iter");
423 if (td_ta_thr_iter_p
== NULL
)
426 td_thr_validate_p
= verbose_dlsym (handle
, "td_thr_validate");
427 if (td_thr_validate_p
== NULL
)
430 td_thr_get_info_p
= verbose_dlsym (handle
, "td_thr_get_info");
431 if (td_thr_get_info_p
== NULL
)
434 td_thr_getfpregs_p
= verbose_dlsym (handle
, "td_thr_getfpregs");
435 if (td_thr_getfpregs_p
== NULL
)
438 td_thr_getgregs_p
= verbose_dlsym (handle
, "td_thr_getgregs");
439 if (td_thr_getgregs_p
== NULL
)
442 td_thr_setfpregs_p
= verbose_dlsym (handle
, "td_thr_setfpregs");
443 if (td_thr_setfpregs_p
== NULL
)
446 td_thr_setgregs_p
= verbose_dlsym (handle
, "td_thr_setgregs");
447 if (td_thr_setgregs_p
== NULL
)
450 /* Initialize the library. */
454 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err
));
458 /* These are not essential. */
459 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
460 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
461 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
462 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
463 td_thr_tls_get_addr_p
= dlsym (handle
, "td_thr_tls_get_addr");
469 enable_thread_event_reporting (void)
471 td_thr_events_t events
;
475 /* We cannot use the thread event reporting facility if these
476 functions aren't available. */
477 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
478 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
481 /* Set the process wide mask saying which events we're interested in. */
482 td_event_emptyset (&events
);
483 td_event_addset (&events
, TD_CREATE
);
485 /* FIXME: kettenis/2000-04-23: The event reporting facility is
486 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
488 td_event_addset (&events
, TD_DEATH
);
491 err
= td_ta_set_event_p (thread_agent
, &events
);
494 warning ("Unable to set global thread event mask: %s",
495 thread_db_err_str (err
));
499 /* Delete previous thread event breakpoints, if any. */
500 remove_thread_event_breakpoints ();
502 /* Get address for thread creation breakpoint. */
503 err
= td_ta_event_addr_p (thread_agent
, TD_CREATE
, ¬ify
);
506 warning ("Unable to get location for thread creation breakpoint: %s",
507 thread_db_err_str (err
));
511 /* Set up the breakpoint. */
512 td_create_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
513 create_thread_event_breakpoint (td_create_bp_addr
);
515 /* Get address for thread death breakpoint. */
516 err
= td_ta_event_addr_p (thread_agent
, TD_DEATH
, ¬ify
);
519 warning ("Unable to get location for thread death breakpoint: %s",
520 thread_db_err_str (err
));
524 /* Set up the breakpoint. */
525 td_death_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
526 create_thread_event_breakpoint (td_death_bp_addr
);
530 disable_thread_event_reporting (void)
532 td_thr_events_t events
;
534 /* Set the process wide mask saying we aren't interested in any
536 td_event_emptyset (&events
);
537 td_ta_set_event_p (thread_agent
, &events
);
539 /* Delete thread event breakpoints, if any. */
540 remove_thread_event_breakpoints ();
541 td_create_bp_addr
= 0;
542 td_death_bp_addr
= 0;
546 check_thread_signals (void)
548 #ifdef GET_THREAD_SIGNALS
554 GET_THREAD_SIGNALS (&mask
);
555 sigemptyset (&thread_stop_set
);
556 sigemptyset (&thread_print_set
);
558 for (i
= 1; i
< NSIG
; i
++)
560 if (sigismember (&mask
, i
))
562 if (signal_stop_update (target_signal_from_host (i
), 0))
563 sigaddset (&thread_stop_set
, i
);
564 if (signal_print_update (target_signal_from_host (i
), 0))
565 sigaddset (&thread_print_set
, i
);
574 disable_thread_signals (void)
576 #ifdef GET_THREAD_SIGNALS
581 for (i
= 1; i
< NSIG
; i
++)
583 if (sigismember (&thread_stop_set
, i
))
584 signal_stop_update (target_signal_from_host (i
), 1);
585 if (sigismember (&thread_print_set
, i
))
586 signal_print_update (target_signal_from_host (i
), 1);
595 thread_db_new_objfile (struct objfile
*objfile
)
599 /* First time through, report that libthread_db was successfuly
600 loaded. Can't print this in in thread_db_load as, at that stage,
601 the interpreter and it's console haven't started. The real
602 problem here is that libthread_db is loaded too early - it should
603 only be loaded when there is a program to debug. */
609 const char *library
= NULL
;
611 if (dladdr ((*td_ta_new_p
), &info
) != 0)
612 library
= info
.dli_fname
;
615 /* Paranoid - don't let a NULL path slip through. */
616 library
= LIBTHREAD_DB_SO
;
617 printf_unfiltered ("Using host libthread_db library \"%s\".\n",
623 /* Don't attempt to use thread_db on targets which can not run
625 if (objfile
== NULL
|| !target_has_execution
)
627 /* All symbols have been discarded. If the thread_db target is
628 active, deactivate it now. */
631 gdb_assert (proc_handle
.pid
== 0);
632 unpush_target (&thread_db_ops
);
642 /* Nothing to do. The thread library was already detected and the
643 target vector was already activated. */
646 /* Initialize the structure that identifies the child process. Note
647 that at this point there is no guarantee that we actually have a
649 proc_handle
.pid
= GET_PID (inferior_ptid
);
651 /* Now attempt to open a connection to the thread library. */
652 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
656 /* No thread library was detected. */
660 printf_unfiltered ("[Thread debugging using libthread_db enabled]\n");
662 /* The thread library was detected. Activate the thread_db target. */
663 push_target (&thread_db_ops
);
666 /* If the thread library was detected in the main symbol file
667 itself, we assume that the program was statically linked
668 against the thread library and well have to keep this
669 module's target vector activated until forever... Well, at
670 least until all symbols have been discarded anyway (see
672 if (objfile
== symfile_objfile
)
674 gdb_assert (proc_handle
.pid
== 0);
678 /* We can only poke around if there actually is a child process.
679 If there is no child process alive, postpone the steps below
680 until one has been created. */
681 if (proc_handle
.pid
!= 0)
683 enable_thread_event_reporting ();
684 thread_db_find_new_threads ();
689 warning ("Cannot initialize thread debugging library: %s",
690 thread_db_err_str (err
));
695 if (target_new_objfile_chain
)
696 target_new_objfile_chain (objfile
);
700 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
701 const td_thrinfo_t
*ti_p
, int verbose
)
703 struct thread_info
*tp
;
706 check_thread_signals ();
708 /* Add the thread to GDB's thread list. */
709 tp
= add_thread (ptid
);
710 tp
->private = xmalloc (sizeof (struct private_thread_info
));
711 memset (tp
->private, 0, sizeof (struct private_thread_info
));
714 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid
));
716 if (ti_p
->ti_state
== TD_THR_UNKNOWN
|| ti_p
->ti_state
== TD_THR_ZOMBIE
)
717 return; /* A zombie thread -- do not attach. */
719 /* Under GNU/Linux, we have to attach to each and every thread. */
721 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
)), 0);
724 /* Enable thread event reporting for this thread. */
725 err
= td_thr_event_enable_p (th_p
, 1);
727 error ("Cannot enable thread event reporting for %s: %s",
728 target_pid_to_str (ptid
), thread_db_err_str (err
));
732 thread_db_attach (char *args
, int from_tty
)
734 target_beneath
->to_attach (args
, from_tty
);
736 /* Destroy thread info; it's no longer valid. */
739 /* The child process is now the actual multi-threaded
740 program. Snatch its process ID... */
741 proc_handle
.pid
= GET_PID (inferior_ptid
);
743 /* ...and perform the remaining initialization steps. */
744 enable_thread_event_reporting ();
745 thread_db_find_new_threads ();
749 detach_thread (ptid_t ptid
, int verbose
)
752 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid
));
756 thread_db_detach (char *args
, int from_tty
)
758 disable_thread_event_reporting ();
760 /* There's no need to save & restore inferior_ptid here, since the
761 inferior is supposed to be survive this function call. */
762 inferior_ptid
= lwp_from_thread (inferior_ptid
);
764 /* Forget about the child's process ID. We shouldn't need it
768 target_beneath
->to_detach (args
, from_tty
);
772 clear_lwpid_callback (struct thread_info
*thread
, void *dummy
)
774 /* If we know that our thread implementation is 1-to-1, we could save
775 a certain amount of information; it's not clear how much, so we
776 are always conservative. */
778 thread
->private->th_valid
= 0;
779 thread
->private->ti_valid
= 0;
785 thread_db_resume (ptid_t ptid
, int step
, enum target_signal signo
)
787 struct cleanup
*old_chain
= save_inferior_ptid ();
789 if (GET_PID (ptid
) == -1)
790 inferior_ptid
= lwp_from_thread (inferior_ptid
);
791 else if (is_thread (ptid
))
792 ptid
= lwp_from_thread (ptid
);
794 /* Clear cached data which may not be valid after the resume. */
795 iterate_over_threads (clear_lwpid_callback
, NULL
);
797 target_beneath
->to_resume (ptid
, step
, signo
);
799 do_cleanups (old_chain
);
802 /* Check if PID is currently stopped at the location of a thread event
803 breakpoint location. If it is, read the event message and act upon
807 check_event (ptid_t ptid
)
815 /* Bail out early if we're not at a thread event breakpoint. */
816 stop_pc
= read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
;
817 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
820 /* If we are at a create breakpoint, we do not know what new lwp
821 was created and cannot specifically locate the event message for it.
822 We have to call td_ta_event_getmsg() to get
823 the latest message. Since we have no way of correlating whether
824 the event message we get back corresponds to our breakpoint, we must
825 loop and read all event messages, processing them appropriately.
826 This guarantees we will process the correct message before continuing
829 Currently, death events are not enabled. If they are enabled,
830 the death event can use the td_thr_event_getmsg() interface to
831 get the message specifically for that lwp and avoid looping
838 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
844 error ("Cannot get thread event message: %s",
845 thread_db_err_str (err
));
848 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
850 error ("Cannot get thread info: %s", thread_db_err_str (err
));
852 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
858 /* We may already know about this thread, for instance when the
859 user has issued the `info threads' command before the SIGTRAP
860 for hitting the thread creation breakpoint was reported. */
861 if (!in_thread_list (ptid
))
862 attach_thread (ptid
, msg
.th_p
, &ti
, 1);
868 if (!in_thread_list (ptid
))
869 error ("Spurious thread death event.");
871 detach_thread (ptid
, 1);
876 error ("Spurious thread event.");
883 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
885 extern ptid_t trap_ptid
;
887 if (GET_PID (ptid
) != -1 && is_thread (ptid
))
888 ptid
= lwp_from_thread (ptid
);
890 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
892 if (proc_handle
.pid
== 0)
893 /* The current child process isn't the actual multi-threaded
894 program yet, so don't try to do any special thread-specific
895 post-processing and bail out early. */
898 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
899 return pid_to_ptid (-1);
901 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
902 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
903 /* Check for a thread event. */
906 if (!ptid_equal (trap_ptid
, null_ptid
))
907 trap_ptid
= thread_from_lwp (trap_ptid
);
909 return thread_from_lwp (ptid
);
913 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
914 struct mem_attrib
*attrib
, struct target_ops
*target
)
916 struct cleanup
*old_chain
= save_inferior_ptid ();
919 if (is_thread (inferior_ptid
))
921 /* FIXME: This seems to be necessary to make sure breakpoints
923 if (!target_thread_alive (inferior_ptid
))
924 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
926 inferior_ptid
= lwp_from_thread (inferior_ptid
);
930 target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
,
933 do_cleanups (old_chain
);
938 thread_db_fetch_registers (int regno
)
940 struct thread_info
*thread_info
;
942 gdb_prfpregset_t fpregset
;
945 if (!is_thread (inferior_ptid
))
947 /* Pass the request to the target beneath us. */
948 target_beneath
->to_fetch_registers (regno
);
952 thread_info
= find_thread_pid (inferior_ptid
);
953 thread_db_map_id2thr (thread_info
, 1);
955 err
= td_thr_getgregs_p (&thread_info
->private->th
, gregset
);
957 error ("Cannot fetch general-purpose registers for thread %ld: %s",
958 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
960 err
= td_thr_getfpregs_p (&thread_info
->private->th
, &fpregset
);
962 error ("Cannot get floating-point registers for thread %ld: %s",
963 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
965 /* Note that we must call supply_gregset after calling the thread_db
966 routines because the thread_db routines call ps_lgetgregs and
967 friends which clobber GDB's register cache. */
968 supply_gregset ((gdb_gregset_t
*) gregset
);
969 supply_fpregset (&fpregset
);
973 thread_db_store_registers (int regno
)
976 gdb_prfpregset_t fpregset
;
978 struct thread_info
*thread_info
;
980 if (!is_thread (inferior_ptid
))
982 /* Pass the request to the target beneath us. */
983 target_beneath
->to_store_registers (regno
);
987 thread_info
= find_thread_pid (inferior_ptid
);
988 thread_db_map_id2thr (thread_info
, 1);
992 char raw
[MAX_REGISTER_SIZE
];
994 deprecated_read_register_gen (regno
, raw
);
995 thread_db_fetch_registers (-1);
996 supply_register (regno
, raw
);
999 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
1000 fill_fpregset (&fpregset
, -1);
1002 err
= td_thr_setgregs_p (&thread_info
->private->th
, gregset
);
1004 error ("Cannot store general-purpose registers for thread %ld: %s",
1005 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1006 err
= td_thr_setfpregs_p (&thread_info
->private->th
, &fpregset
);
1008 error ("Cannot store floating-point registers for thread %ld: %s",
1009 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1013 thread_db_kill (void)
1015 /* There's no need to save & restore inferior_ptid here, since the
1016 inferior isn't supposed to survive this function call. */
1017 inferior_ptid
= lwp_from_thread (inferior_ptid
);
1018 target_beneath
->to_kill ();
1022 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
)
1024 if (!keep_thread_db
)
1026 unpush_target (&thread_db_ops
);
1027 using_thread_db
= 0;
1030 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
1034 thread_db_post_startup_inferior (ptid_t ptid
)
1036 if (proc_handle
.pid
== 0)
1038 /* The child process is now the actual multi-threaded
1039 program. Snatch its process ID... */
1040 proc_handle
.pid
= GET_PID (ptid
);
1042 /* ...and perform the remaining initialization steps. */
1043 enable_thread_event_reporting ();
1044 thread_db_find_new_threads ();
1049 thread_db_mourn_inferior (void)
1051 remove_thread_event_breakpoints ();
1053 /* Forget about the child's process ID. We shouldn't need it
1055 proc_handle
.pid
= 0;
1057 target_beneath
->to_mourn_inferior ();
1059 /* Detach thread_db target ops if not dealing with a statically
1060 linked threaded program. This allows a corefile to be debugged
1061 after finishing debugging of a threaded program. At present,
1062 debugging a statically-linked threaded program is broken, but
1063 the check is added below in the event that it is fixed in the
1065 if (!keep_thread_db
)
1067 unpush_target (&thread_db_ops
);
1068 using_thread_db
= 0;
1073 thread_db_thread_alive (ptid_t ptid
)
1078 if (is_thread (ptid
))
1080 struct thread_info
*thread_info
;
1081 thread_info
= find_thread_pid (ptid
);
1083 thread_db_map_id2thr (thread_info
, 0);
1084 if (!thread_info
->private->th_valid
)
1087 err
= td_thr_validate_p (&thread_info
->private->th
);
1091 if (!thread_info
->private->ti_valid
)
1094 td_thr_get_info_p (&thread_info
->private->th
,
1095 &thread_info
->private->ti
);
1098 thread_info
->private->ti_valid
= 1;
1101 if (thread_info
->private->ti
.ti_state
== TD_THR_UNKNOWN
1102 || thread_info
->private->ti
.ti_state
== TD_THR_ZOMBIE
)
1103 return 0; /* A zombie thread. */
1108 if (target_beneath
->to_thread_alive
)
1109 return target_beneath
->to_thread_alive (ptid
);
1115 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
1121 err
= td_thr_get_info_p (th_p
, &ti
);
1123 error ("find_new_threads_callback: cannot get thread info: %s",
1124 thread_db_err_str (err
));
1126 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
1127 return 0; /* A zombie -- ignore. */
1129 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
1131 if (!in_thread_list (ptid
))
1132 attach_thread (ptid
, th_p
, &ti
, 1);
1138 thread_db_find_new_threads (void)
1142 /* Iterate over all user-space threads to discover new threads. */
1143 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
1144 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1145 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1147 error ("Cannot find new threads: %s", thread_db_err_str (err
));
1151 thread_db_pid_to_str (ptid_t ptid
)
1153 if (is_thread (ptid
))
1155 static char buf
[64];
1158 struct thread_info
*thread_info
;
1160 thread_info
= find_thread_pid (ptid
);
1161 thread_db_map_id2thr (thread_info
, 0);
1162 if (!thread_info
->private->th_valid
)
1164 snprintf (buf
, sizeof (buf
), "Thread %ld (Missing)",
1169 ti_p
= thread_db_get_info (thread_info
);
1171 if (ti_p
->ti_state
== TD_THR_ACTIVE
&& ti_p
->ti_lid
!= 0)
1173 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
1174 (long) ti_p
->ti_tid
, ti_p
->ti_lid
);
1178 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
1179 (long) ti_p
->ti_tid
,
1180 thread_db_state_str (ti_p
->ti_state
));
1186 if (target_beneath
->to_pid_to_str (ptid
))
1187 return target_beneath
->to_pid_to_str (ptid
);
1189 return normal_pid_to_str (ptid
);
1192 /* Get the address of the thread local variable in OBJFILE which is
1193 stored at OFFSET within the thread local storage for thread PTID. */
1196 thread_db_get_thread_local_address (ptid_t ptid
, struct objfile
*objfile
,
1199 if (is_thread (ptid
))
1201 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1205 struct thread_info
*thread_info
;
1207 /* glibc doesn't provide the needed interface. */
1208 if (!td_thr_tls_get_addr_p
)
1209 error ("Cannot find thread-local variables in this thread library.");
1211 /* Get the address of the link map for this objfile. */
1212 lm
= svr4_fetch_objfile_link_map (objfile
);
1214 /* Whoops, we couldn't find one. Bail out. */
1217 if (objfile_is_library
)
1218 error ("Cannot find shared library `%s' link_map in dynamic"
1219 " linker's module list", objfile
->name
);
1221 error ("Cannot find executable file `%s' link_map in dynamic"
1222 " linker's module list", objfile
->name
);
1225 /* Get info about the thread. */
1226 thread_info
= find_thread_pid (ptid
);
1227 thread_db_map_id2thr (thread_info
, 1);
1229 /* Finally, get the address of the variable. */
1230 err
= td_thr_tls_get_addr_p (&thread_info
->private->th
, (void *) lm
,
1233 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1234 /* The memory hasn't been allocated, yet. */
1235 if (err
== TD_NOTALLOC
)
1237 /* Now, if libthread_db provided the initialization image's
1238 address, we *could* try to build a non-lvalue value from
1239 the initialization image. */
1240 if (objfile_is_library
)
1241 error ("The inferior has not yet allocated storage for"
1242 " thread-local variables in\n"
1243 "the shared library `%s'\n"
1244 "for the thread %ld",
1245 objfile
->name
, (long) GET_THREAD (ptid
));
1247 error ("The inferior has not yet allocated storage for"
1248 " thread-local variables in\n"
1249 "the executable `%s'\n"
1250 "for the thread %ld",
1251 objfile
->name
, (long) GET_THREAD (ptid
));
1255 /* Something else went wrong. */
1258 if (objfile_is_library
)
1259 error ("Cannot find thread-local storage for thread %ld, "
1260 "shared library %s:\n%s",
1261 (long) GET_THREAD (ptid
),
1262 objfile
->name
, thread_db_err_str (err
));
1264 error ("Cannot find thread-local storage for thread %ld, "
1265 "executable file %s:\n%s",
1266 (long) GET_THREAD (ptid
),
1267 objfile
->name
, thread_db_err_str (err
));
1270 /* Cast assuming host == target. Joy. */
1271 return (CORE_ADDR
) address
;
1274 if (target_beneath
->to_get_thread_local_address
)
1275 return target_beneath
->to_get_thread_local_address (ptid
, objfile
,
1278 error ("Cannot find thread-local values on this target.");
1282 init_thread_db_ops (void)
1284 thread_db_ops
.to_shortname
= "multi-thread";
1285 thread_db_ops
.to_longname
= "multi-threaded child process.";
1286 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1287 thread_db_ops
.to_attach
= thread_db_attach
;
1288 thread_db_ops
.to_detach
= thread_db_detach
;
1289 thread_db_ops
.to_resume
= thread_db_resume
;
1290 thread_db_ops
.to_wait
= thread_db_wait
;
1291 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1292 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1293 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
1294 thread_db_ops
.to_kill
= thread_db_kill
;
1295 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1296 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1297 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1298 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1299 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1300 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1301 thread_db_ops
.to_stratum
= thread_stratum
;
1302 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1303 thread_db_ops
.to_get_thread_local_address
1304 = thread_db_get_thread_local_address
;
1305 thread_db_ops
.to_magic
= OPS_MAGIC
;
1309 _initialize_thread_db (void)
1311 /* Only initialize the module if we can load libthread_db. */
1312 if (thread_db_load ())
1314 init_thread_db_ops ();
1315 add_target (&thread_db_ops
);
1317 /* Add ourselves to objfile event chain. */
1318 target_new_objfile_chain
= target_new_objfile_hook
;
1319 target_new_objfile_hook
= thread_db_new_objfile
;