projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
2001-12-21 Michael Snyder <msnyder@redhat.com>
[deliverable/binutils-gdb.git] / gdb / thread-db.c
... / ...
CommitLineData
1/* libthread_db assisted debugging support, generic parts.
2 Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
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.
10
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.
15
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. */
20
21#include "defs.h"
22
23#include "gdb_assert.h"
24#include <dlfcn.h>
25#include "gdb_proc_service.h"
26#include "gdb_thread_db.h"
27
28#include "bfd.h"
29#include "gdbthread.h"
30#include "inferior.h"
31#include "symfile.h"
32#include "objfiles.h"
33#include "target.h"
34#include "regcache.h"
35
36#ifndef LIBTHREAD_DB_SO
37#define LIBTHREAD_DB_SO "libthread_db.so.1"
38#endif
39
40/* If we're running on Linux, we must explicitly attach to any new threads. */
41
42/* FIXME: There is certainly some room for improvements:
43 - Cache LWP ids.
44 - Bypass libthread_db when fetching or storing registers for
45 threads bound to a LWP. */
46
47/* This module's target vector. */
48static struct target_ops thread_db_ops;
49
50/* The target vector that we call for things this module can't handle. */
51static struct target_ops *target_beneath;
52
53/* Pointer to the next function on the objfile event chain. */
54static void (*target_new_objfile_chain) (struct objfile *objfile);
55
56/* Non-zero if we're using this module's target vector. */
57static int using_thread_db;
58
59/* Non-zero if we have to keep this module's target vector active
60 across re-runs. */
61static int keep_thread_db;
62
63/* Non-zero if we have determined the signals used by the threads
64 library. */
65static int thread_signals;
66static sigset_t thread_stop_set;
67static sigset_t thread_print_set;
68
69/* Structure that identifies the child process for the
70 <proc_service.h> interface. */
71static struct ps_prochandle proc_handle;
72
73/* Connection to the libthread_db library. */
74static td_thragent_t *thread_agent;
75
76/* Pointers to the libthread_db functions. */
77
78static td_err_e (*td_init_p) (void);
79
80static td_err_e (*td_ta_new_p) (struct ps_prochandle *ps, td_thragent_t **ta);
81static td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt,
82 td_thrhandle_t *__th);
83static td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta, lwpid_t lwpid,
84 td_thrhandle_t *th);
85static td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
86 td_thr_iter_f *callback,
87 void *cbdata_p, td_thr_state_e state,
88 int ti_pri, sigset_t *ti_sigmask_p,
89 unsigned int ti_user_flags);
90static td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
91 td_event_e event, td_notify_t *ptr);
92static td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
93 td_thr_events_t *event);
94static td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
95 td_event_msg_t *msg);
96
97static td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
98static td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
99 td_thrinfo_t *infop);
100static td_err_e (*td_thr_getfpregs_p) (const td_thrhandle_t *th,
101 gdb_prfpregset_t *regset);
102static td_err_e (*td_thr_getgregs_p) (const td_thrhandle_t *th,
103 prgregset_t gregs);
104static td_err_e (*td_thr_setfpregs_p) (const td_thrhandle_t *th,
105 const gdb_prfpregset_t *fpregs);
106static td_err_e (*td_thr_setgregs_p) (const td_thrhandle_t *th,
107 prgregset_t gregs);
108static td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th, int event);
109
110/* Location of the thread creation event breakpoint. The code at this
111 location in the child process will be called by the pthread library
112 whenever a new thread is created. By setting a special breakpoint
113 at this location, GDB can detect when a new thread is created. We
114 obtain this location via the td_ta_event_addr call. */
115static CORE_ADDR td_create_bp_addr;
116
117/* Location of the thread death event breakpoint. */
118static CORE_ADDR td_death_bp_addr;
119
120/* Prototypes for local functions. */
121static void thread_db_find_new_threads (void);
122\f
123
124/* Building process ids. */
125
126#define GET_PID(ptid) ptid_get_pid (ptid)
127#define GET_LWP(ptid) ptid_get_lwp (ptid)
128#define GET_THREAD(ptid) ptid_get_tid (ptid)
129
130#define is_lwp(ptid) (GET_LWP (ptid) != 0)
131#define is_thread(ptid) (GET_THREAD (ptid) != 0)
132
133#define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
134#define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
135\f
136
137struct private_thread_info
138{
139 /* Cached LWP id. Must come first, see lin-lwp.c. */
140 lwpid_t lwpid;
141};
142\f
143
144static char *
145thread_db_err_str (td_err_e err)
146{
147 static char buf[64];
148
149 switch (err)
150 {
151 case TD_OK:
152 return "generic 'call succeeded'";
153 case TD_ERR:
154 return "generic error";
155 case TD_NOTHR:
156 return "no thread to satisfy query";
157 case TD_NOSV:
158 return "no sync handle to satisfy query";
159 case TD_NOLWP:
160 return "no LWP to satisfy query";
161 case TD_BADPH:
162 return "invalid process handle";
163 case TD_BADTH:
164 return "invalid thread handle";
165 case TD_BADSH:
166 return "invalid synchronization handle";
167 case TD_BADTA:
168 return "invalid thread agent";
169 case TD_BADKEY:
170 return "invalid key";
171 case TD_NOMSG:
172 return "no event message for getmsg";
173 case TD_NOFPREGS:
174 return "FPU register set not available";
175 case TD_NOLIBTHREAD:
176 return "application not linked with libthread";
177 case TD_NOEVENT:
178 return "requested event is not supported";
179 case TD_NOCAPAB:
180 return "capability not available";
181 case TD_DBERR:
182 return "debugger service failed";
183 case TD_NOAPLIC:
184 return "operation not applicable to";
185 case TD_NOTSD:
186 return "no thread-specific data for this thread";
187 case TD_MALLOC:
188 return "malloc failed";
189 case TD_PARTIALREG:
190 return "only part of register set was written/read";
191 case TD_NOXREGS:
192 return "X register set not available for this thread";
193 default:
194 snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
195 return buf;
196 }
197}
198
199static char *
200thread_db_state_str (td_thr_state_e state)
201{
202 static char buf[64];
203
204 switch (state)
205 {
206 case TD_THR_STOPPED:
207 return "stopped by debugger";
208 case TD_THR_RUN:
209 return "runnable";
210 case TD_THR_ACTIVE:
211 return "active";
212 case TD_THR_ZOMBIE:
213 return "zombie";
214 case TD_THR_SLEEP:
215 return "sleeping";
216 case TD_THR_STOPPED_ASLEEP:
217 return "stopped by debugger AND blocked";
218 default:
219 snprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
220 return buf;
221 }
222}
223\f
224
225/* Convert between user-level thread ids and LWP ids. */
226
227static ptid_t
228thread_from_lwp (ptid_t ptid)
229{
230 td_thrinfo_t ti;
231 td_thrhandle_t th;
232 td_err_e err;
233
234 if (GET_LWP (ptid) == 0)
235 ptid = BUILD_LWP (GET_PID (ptid), GET_PID (ptid));
236
237 gdb_assert (is_lwp (ptid));
238
239 err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
240 if (err != TD_OK)
241 error ("Cannot find user-level thread for LWP %d: %s",
242 GET_LWP (ptid), thread_db_err_str (err));
243
244 err = td_thr_get_info_p (&th, &ti);
245 if (err != TD_OK)
246 error ("Cannot get thread info: %s", thread_db_err_str (err));
247
248 return BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
249}
250
251static ptid_t
252lwp_from_thread (ptid_t ptid)
253{
254 td_thrinfo_t ti;
255 td_thrhandle_t th;
256 td_err_e err;
257
258 if (!is_thread (ptid))
259 return ptid;
260
261 err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
262 if (err != TD_OK)
263 error ("Cannot find thread %ld: %s",
264 (long) GET_THREAD (ptid), thread_db_err_str (err));
265
266 err = td_thr_get_info_p (&th, &ti);
267 if (err != TD_OK)
268 error ("Cannot get thread info: %s", thread_db_err_str (err));
269
270 return BUILD_LWP (ti.ti_lid, GET_PID (ptid));
271}
272\f
273
274void
275thread_db_init (struct target_ops *target)
276{
277 target_beneath = target;
278}
279
280static int
281thread_db_load (void)
282{
283 void *handle;
284 td_err_e err;
285
286 handle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW);
287 if (handle == NULL)
288 return 0;
289
290 /* Initialize pointers to the dynamic library functions we will use.
291 Essential functions first. */
292
293 td_init_p = dlsym (handle, "td_init");
294 if (td_init_p == NULL)
295 return 0;
296
297 td_ta_new_p = dlsym (handle, "td_ta_new");
298 if (td_ta_new_p == NULL)
299 return 0;
300
301 td_ta_map_id2thr_p = dlsym (handle, "td_ta_map_id2thr");
302 if (td_ta_map_id2thr_p == NULL)
303 return 0;
304
305 td_ta_map_lwp2thr_p = dlsym (handle, "td_ta_map_lwp2thr");
306 if (td_ta_map_lwp2thr_p == NULL)
307 return 0;
308
309 td_ta_thr_iter_p = dlsym (handle, "td_ta_thr_iter");
310 if (td_ta_thr_iter_p == NULL)
311 return 0;
312
313 td_thr_validate_p = dlsym (handle, "td_thr_validate");
314 if (td_thr_validate_p == NULL)
315 return 0;
316
317 td_thr_get_info_p = dlsym (handle, "td_thr_get_info");
318 if (td_thr_get_info_p == NULL)
319 return 0;
320
321 td_thr_getfpregs_p = dlsym (handle, "td_thr_getfpregs");
322 if (td_thr_getfpregs_p == NULL)
323 return 0;
324
325 td_thr_getgregs_p = dlsym (handle, "td_thr_getgregs");
326 if (td_thr_getgregs_p == NULL)
327 return 0;
328
329 td_thr_setfpregs_p = dlsym (handle, "td_thr_setfpregs");
330 if (td_thr_setfpregs_p == NULL)
331 return 0;
332
333 td_thr_setgregs_p = dlsym (handle, "td_thr_setgregs");
334 if (td_thr_setgregs_p == NULL)
335 return 0;
336
337 /* Initialize the library. */
338 err = td_init_p ();
339 if (err != TD_OK)
340 {
341 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err));
342 return 0;
343 }
344
345 /* These are not essential. */
346 td_ta_event_addr_p = dlsym (handle, "td_ta_event_addr");
347 td_ta_set_event_p = dlsym (handle, "td_ta_set_event");
348 td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg");
349 td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable");
350
351 return 1;
352}
353
354static void
355enable_thread_event_reporting (void)
356{
357 td_thr_events_t events;
358 td_notify_t notify;
359 td_err_e err;
360
361 /* We cannot use the thread event reporting facility if these
362 functions aren't available. */
363 if (td_ta_event_addr_p == NULL || td_ta_set_event_p == NULL
364 || td_ta_event_getmsg_p == NULL || td_thr_event_enable_p == NULL)
365 return;
366
367 /* Set the process wide mask saying which events we're interested in. */
368 td_event_emptyset (&events);
369 td_event_addset (&events, TD_CREATE);
370#if 0
371 /* FIXME: kettenis/2000-04-23: The event reporting facility is
372 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
373 now. */
374 td_event_addset (&events, TD_DEATH);
375#endif
376
377 err = td_ta_set_event_p (thread_agent, &events);
378 if (err != TD_OK)
379 {
380 warning ("Unable to set global thread event mask: %s",
381 thread_db_err_str (err));
382 return;
383 }
384
385 /* Delete previous thread event breakpoints, if any. */
386 remove_thread_event_breakpoints ();
387
388 /* Get address for thread creation breakpoint. */
389 err = td_ta_event_addr_p (thread_agent, TD_CREATE, &notify);
390 if (err != TD_OK)
391 {
392 warning ("Unable to get location for thread creation breakpoint: %s",
393 thread_db_err_str (err));
394 return;
395 }
396
397 /* Set up the breakpoint. */
398 td_create_bp_addr = (CORE_ADDR) notify.u.bptaddr;
399 create_thread_event_breakpoint (td_create_bp_addr);
400
401 /* Get address for thread death breakpoint. */
402 err = td_ta_event_addr_p (thread_agent, TD_DEATH, &notify);
403 if (err != TD_OK)
404 {
405 warning ("Unable to get location for thread death breakpoint: %s",
406 thread_db_err_str (err));
407 return;
408 }
409
410 /* Set up the breakpoint. */
411 td_death_bp_addr = (CORE_ADDR) notify.u.bptaddr;
412 create_thread_event_breakpoint (td_death_bp_addr);
413}
414
415static void
416disable_thread_event_reporting (void)
417{
418 td_thr_events_t events;
419
420 /* Set the process wide mask saying we aren't interested in any
421 events anymore. */
422 td_event_emptyset (&events);
423 td_ta_set_event_p (thread_agent, &events);
424
425 /* Delete thread event breakpoints, if any. */
426 remove_thread_event_breakpoints ();
427 td_create_bp_addr = 0;
428 td_death_bp_addr = 0;
429}
430
431static void
432check_thread_signals (void)
433{
434#ifdef GET_THREAD_SIGNALS
435 if (!thread_signals)
436 {
437 sigset_t mask;
438 int i;
439
440 GET_THREAD_SIGNALS (&mask);
441 sigemptyset (&thread_stop_set);
442 sigemptyset (&thread_print_set);
443
444 for (i = 1; i < NSIG; i++)
445 {
446 if (sigismember (&mask, i))
447 {
448 if (signal_stop_update (target_signal_from_host (i), 0))
449 sigaddset (&thread_stop_set, i);
450 if (signal_print_update (target_signal_from_host (i), 0))
451 sigaddset (&thread_print_set, i);
452 thread_signals = 1;
453 }
454 }
455 }
456#endif
457}
458
459static void
460disable_thread_signals (void)
461{
462#ifdef GET_THREAD_SIGNALS
463 if (thread_signals)
464 {
465 int i;
466
467 for (i = 1; i < NSIG; i++)
468 {
469 if (sigismember (&thread_stop_set, i))
470 signal_stop_update (target_signal_from_host (i), 1);
471 if (sigismember (&thread_print_set, i))
472 signal_print_update (target_signal_from_host (i), 1);
473 }
474
475 thread_signals = 0;
476 }
477#endif
478}
479
480static void
481thread_db_new_objfile (struct objfile *objfile)
482{
483 td_err_e err;
484
485 if (objfile == NULL)
486 {
487 /* All symbols have been discarded. If the thread_db target is
488 active, deactivate it now. */
489 if (using_thread_db)
490 {
491 gdb_assert (proc_handle.pid == 0);
492 unpush_target (&thread_db_ops);
493 using_thread_db = 0;
494 }
495
496 keep_thread_db = 0;
497
498 goto quit;
499 }
500
501 if (using_thread_db)
502 /* Nothing to do. The thread library was already detected and the
503 target vector was already activated. */
504 goto quit;
505
506 /* Initialize the structure that identifies the child process. Note
507 that at this point there is no guarantee that we actually have a
508 child process. */
509 proc_handle.pid = GET_PID (inferior_ptid);
510
511 /* Now attempt to open a connection to the thread library. */
512 err = td_ta_new_p (&proc_handle, &thread_agent);
513 switch (err)
514 {
515 case TD_NOLIBTHREAD:
516 /* No thread library was detected. */
517 break;
518
519 case TD_OK:
520 /* The thread library was detected. Activate the thread_db target. */
521 push_target (&thread_db_ops);
522 using_thread_db = 1;
523
524 /* If the thread library was detected in the main symbol file
525 itself, we assume that the program was statically linked
526 against the thread library and well have to keep this
527 module's target vector activated until forever... Well, at
528 least until all symbols have been discarded anyway (see
529 above). */
530 if (objfile == symfile_objfile)
531 {
532 gdb_assert (proc_handle.pid == 0);
533 keep_thread_db = 1;
534 }
535
536 /* We can only poke around if there actually is a child process.
537 If there is no child process alive, postpone the steps below
538 until one has been created. */
539 if (proc_handle.pid != 0)
540 {
541 enable_thread_event_reporting ();
542 thread_db_find_new_threads ();
543 }
544 break;
545
546 default:
547 warning ("Cannot initialize thread debugging library: %s",
548 thread_db_err_str (err));
549 break;
550 }
551
552 quit:
553 if (target_new_objfile_chain)
554 target_new_objfile_chain (objfile);
555}
556
557static void
558attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
559 const td_thrinfo_t *ti_p, int verbose)
560{
561 struct thread_info *tp;
562 td_err_e err;
563
564 check_thread_signals ();
565
566 if (verbose)
567 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid));
568
569 /* Add the thread to GDB's thread list. */
570 tp = add_thread (ptid);
571 tp->private = xmalloc (sizeof (struct private_thread_info));
572 tp->private->lwpid = ti_p->ti_lid;
573
574 if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
575 return; /* A zombie thread -- do not attach. */
576
577 /* Under Linux, we have to attach to each and every thread. */
578#ifdef ATTACH_LWP
579 ATTACH_LWP (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)), 0);
580#endif
581
582 /* Enable thread event reporting for this thread. */
583 err = td_thr_event_enable_p (th_p, 1);
584 if (err != TD_OK)
585 error ("Cannot enable thread event reporting for %s: %s",
586 target_pid_to_str (ptid), thread_db_err_str (err));
587}
588
589static void
590thread_db_attach (char *args, int from_tty)
591{
592 target_beneath->to_attach (args, from_tty);
593
594 /* Destroy thread info; it's no longer valid. */
595 init_thread_list ();
596
597 /* The child process is now the actual multi-threaded
598 program. Snatch its process ID... */
599 proc_handle.pid = GET_PID (inferior_ptid);
600
601 /* ...and perform the remaining initialization steps. */
602 enable_thread_event_reporting ();
603 thread_db_find_new_threads();
604}
605
606static void
607detach_thread (ptid_t ptid, int verbose)
608{
609 if (verbose)
610 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid));
611}
612
613static void
614thread_db_detach (char *args, int from_tty)
615{
616 disable_thread_event_reporting ();
617
618 /* There's no need to save & restore inferior_ptid here, since the
619 inferior is supposed to be survive this function call. */
620 inferior_ptid = lwp_from_thread (inferior_ptid);
621
622 /* Forget about the child's process ID. We shouldn't need it
623 anymore. */
624 proc_handle.pid = 0;
625
626 target_beneath->to_detach (args, from_tty);
627}
628
629static void
630thread_db_resume (ptid_t ptid, int step, enum target_signal signo)
631{
632 struct cleanup *old_chain = save_inferior_ptid ();
633
634 if (GET_PID (ptid) == -1)
635 inferior_ptid = lwp_from_thread (inferior_ptid);
636 else if (is_thread (ptid))
637 ptid = lwp_from_thread (ptid);
638
639 target_beneath->to_resume (ptid, step, signo);
640
641 do_cleanups (old_chain);
642}
643
644/* Check if PID is currently stopped at the location of a thread event
645 breakpoint location. If it is, read the event message and act upon
646 the event. */
647
648static void
649check_event (ptid_t ptid)
650{
651 td_event_msg_t msg;
652 td_thrinfo_t ti;
653 td_err_e err;
654 CORE_ADDR stop_pc;
655
656 /* Bail out early if we're not at a thread event breakpoint. */
657 stop_pc = read_pc_pid (ptid) - DECR_PC_AFTER_BREAK;
658 if (stop_pc != td_create_bp_addr && stop_pc != td_death_bp_addr)
659 return;
660
661 err = td_ta_event_getmsg_p (thread_agent, &msg);
662 if (err != TD_OK)
663 {
664 if (err == TD_NOMSG)
665 return;
666
667 error ("Cannot get thread event message: %s", thread_db_err_str (err));
668 }
669
670 err = td_thr_get_info_p (msg.th_p, &ti);
671 if (err != TD_OK)
672 error ("Cannot get thread info: %s", thread_db_err_str (err));
673
674 ptid = BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
675
676 switch (msg.event)
677 {
678 case TD_CREATE:
679#if 0
680 /* FIXME: kettenis/2000-08-26: Since we use td_ta_event_getmsg,
681 there is no guarantee that the breakpoint will match the
682 event. Should we use td_thr_event_getmsg instead? */
683
684 if (stop_pc != td_create_bp_addr)
685 error ("Thread creation event doesn't match breakpoint.");
686#endif
687
688 /* We may already know about this thread, for instance when the
689 user has issued the `info threads' command before the SIGTRAP
690 for hitting the thread creation breakpoint was reported. */
691 if (!in_thread_list (ptid))
692 attach_thread (ptid, msg.th_p, &ti, 1);
693 return;
694
695 case TD_DEATH:
696#if 0
697 /* FIXME: See TD_CREATE. */
698
699 if (stop_pc != td_death_bp_addr)
700 error ("Thread death event doesn't match breakpoint.");
701#endif
702
703 if (!in_thread_list (ptid))
704 error ("Spurious thread death event.");
705
706 detach_thread (ptid, 1);
707 return;
708
709 default:
710 error ("Spurious thread event.");
711 }
712}
713
714static ptid_t
715thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
716{
717 extern ptid_t trap_ptid;
718
719 if (GET_PID (ptid) != -1 && is_thread (ptid))
720 ptid = lwp_from_thread (ptid);
721
722 ptid = target_beneath->to_wait (ptid, ourstatus);
723
724 if (proc_handle.pid == 0)
725 /* The current child process isn't the actual multi-threaded
726 program yet, so don't try to do any special thread-specific
727 post-processing and bail out early. */
728 return ptid;
729
730 if (ourstatus->kind == TARGET_WAITKIND_EXITED)
731 return pid_to_ptid (-1);
732
733 if (ourstatus->kind == TARGET_WAITKIND_STOPPED
734 && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
735 /* Check for a thread event. */
736 check_event (ptid);
737
738 if (!ptid_equal (trap_ptid, null_ptid))
739 trap_ptid = thread_from_lwp (trap_ptid);
740
741 return thread_from_lwp (ptid);
742}
743
744static int
745thread_db_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
746 struct mem_attrib *attrib,
747 struct target_ops *target)
748{
749 struct cleanup *old_chain = save_inferior_ptid ();
750 int xfer;
751
752 if (is_thread (inferior_ptid))
753 {
754 /* FIXME: This seems to be necessary to make sure breakpoints
755 are removed. */
756 if (!target_thread_alive (inferior_ptid))
757 inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
758 else
759 inferior_ptid = lwp_from_thread (inferior_ptid);
760 }
761
762 xfer = target_beneath->to_xfer_memory (memaddr, myaddr, len, write, attrib, target);
763
764 do_cleanups (old_chain);
765 return xfer;
766}
767
768static void
769thread_db_fetch_registers (int regno)
770{
771 td_thrhandle_t th;
772 prgregset_t gregset;
773 gdb_prfpregset_t fpregset;
774 td_err_e err;
775
776 if (!is_thread (inferior_ptid))
777 {
778 /* Pass the request to the target beneath us. */
779 target_beneath->to_fetch_registers (regno);
780 return;
781 }
782
783 err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
784 if (err != TD_OK)
785 error ("Cannot find thread %ld: %s",
786 (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
787
788 err = td_thr_getgregs_p (&th, gregset);
789 if (err != TD_OK)
790 error ("Cannot fetch general-purpose registers for thread %ld: %s",
791 (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
792
793 err = td_thr_getfpregs_p (&th, &fpregset);
794 if (err != TD_OK)
795 error ("Cannot get floating-point registers for thread %ld: %s",
796 (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
797
798 /* Note that we must call supply_gregset after calling the thread_db
799 routines because the thread_db routines call ps_lgetgregs and
800 friends which clobber GDB's register cache. */
801 supply_gregset ((gdb_gregset_t *) gregset);
802 supply_fpregset (&fpregset);
803}
804
805static void
806thread_db_store_registers (int regno)
807{
808 td_thrhandle_t th;
809 prgregset_t gregset;
810 gdb_prfpregset_t fpregset;
811 td_err_e err;
812
813 if (!is_thread (inferior_ptid))
814 {
815 /* Pass the request to the target beneath us. */
816 target_beneath->to_store_registers (regno);
817 return;
818 }
819
820 err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
821 if (err != TD_OK)
822 error ("Cannot find thread %ld: %s",
823 (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
824
825 if (regno != -1)
826 {
827 char raw[MAX_REGISTER_RAW_SIZE];
828
829 read_register_gen (regno, raw);
830 thread_db_fetch_registers (-1);
831 supply_register (regno, raw);
832 }
833
834 fill_gregset ((gdb_gregset_t *) gregset, -1);
835 fill_fpregset (&fpregset, -1);
836
837 err = td_thr_setgregs_p (&th, gregset);
838 if (err != TD_OK)
839 error ("Cannot store general-purpose registers for thread %ld: %s",
840 (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
841 err = td_thr_setfpregs_p (&th, &fpregset);
842 if (err != TD_OK)
843 error ("Cannot store floating-point registers for thread %ld: %s",
844 (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
845}
846
847static void
848thread_db_kill (void)
849{
850 /* There's no need to save & restore inferior_ptid here, since the
851 inferior isn't supposed to survive this function call. */
852 inferior_ptid = lwp_from_thread (inferior_ptid);
853 target_beneath->to_kill ();
854}
855
856static void
857thread_db_create_inferior (char *exec_file, char *allargs, char **env)
858{
859 if (!keep_thread_db)
860 {
861 unpush_target (&thread_db_ops);
862 using_thread_db = 0;
863 }
864
865 target_beneath->to_create_inferior (exec_file, allargs, env);
866}
867
868static void
869thread_db_post_startup_inferior (ptid_t ptid)
870{
871 if (proc_handle.pid == 0)
872 {
873 /* The child process is now the actual multi-threaded
874 program. Snatch its process ID... */
875 proc_handle.pid = GET_PID (ptid);
876
877 /* ...and perform the remaining initialization steps. */
878 enable_thread_event_reporting ();
879 thread_db_find_new_threads ();
880 }
881}
882
883static void
884thread_db_mourn_inferior (void)
885{
886 remove_thread_event_breakpoints ();
887
888 /* Forget about the child's process ID. We shouldn't need it
889 anymore. */
890 proc_handle.pid = 0;
891
892 target_beneath->to_mourn_inferior ();
893}
894
895static int
896thread_db_thread_alive (ptid_t ptid)
897{
898 td_thrhandle_t th;
899 td_thrinfo_t ti;
900 td_err_e err;
901
902 if (is_thread (ptid))
903 {
904 err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
905 if (err != TD_OK)
906 return 0;
907
908 err = td_thr_validate_p (&th);
909 if (err != TD_OK)
910 return 0;
911
912 err = td_thr_get_info_p (&th, &ti);
913 if (err != TD_OK)
914 return 0;
915
916 if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
917 return 0; /* A zombie thread. */
918
919 return 1;
920 }
921
922 if (target_beneath->to_thread_alive)
923 return target_beneath->to_thread_alive (ptid);
924
925 return 0;
926}
927
928static int
929find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
930{
931 td_thrinfo_t ti;
932 td_err_e err;
933 ptid_t ptid;
934
935 err = td_thr_get_info_p (th_p, &ti);
936 if (err != TD_OK)
937 error ("Cannot get thread info: %s", thread_db_err_str (err));
938
939 if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
940 return 0; /* A zombie -- ignore. */
941
942 ptid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_ptid));
943
944 if (!in_thread_list (ptid))
945 attach_thread (ptid, th_p, &ti, 1);
946
947 return 0;
948}
949
950static void
951thread_db_find_new_threads (void)
952{
953 td_err_e err;
954
955 /* Iterate over all user-space threads to discover new threads. */
956 err = td_ta_thr_iter_p (thread_agent, find_new_threads_callback, NULL,
957 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
958 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
959 if (err != TD_OK)
960 error ("Cannot find new threads: %s", thread_db_err_str (err));
961}
962
963static char *
964thread_db_pid_to_str (ptid_t ptid)
965{
966 if (is_thread (ptid))
967 {
968 static char buf[64];
969 td_thrhandle_t th;
970 td_thrinfo_t ti;
971 td_err_e err;
972
973 err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
974 if (err != TD_OK)
975 error ("Cannot find thread %ld: %s",
976 (long) GET_THREAD (ptid), thread_db_err_str (err));
977
978 err = td_thr_get_info_p (&th, &ti);
979 if (err != TD_OK)
980 error ("Cannot get thread info for thread %ld: %s",
981 (long) GET_THREAD (ptid), thread_db_err_str (err));
982
983 if (ti.ti_state == TD_THR_ACTIVE && ti.ti_lid != 0)
984 {
985 snprintf (buf, sizeof (buf), "Thread %ld (LWP %d)",
986 (long) ti.ti_tid, ti.ti_lid);
987 }
988 else
989 {
990 snprintf (buf, sizeof (buf), "Thread %ld (%s)",
991 (long) ti.ti_tid, thread_db_state_str (ti.ti_state));
992 }
993
994 return buf;
995 }
996
997 if (target_beneath->to_pid_to_str (ptid))
998 return target_beneath->to_pid_to_str (ptid);
999
1000 return normal_pid_to_str (ptid);
1001}
1002
1003static void
1004init_thread_db_ops (void)
1005{
1006 thread_db_ops.to_shortname = "multi-thread";
1007 thread_db_ops.to_longname = "multi-threaded child process.";
1008 thread_db_ops.to_doc = "Threads and pthreads support.";
1009 thread_db_ops.to_attach = thread_db_attach;
1010 thread_db_ops.to_detach = thread_db_detach;
1011 thread_db_ops.to_resume = thread_db_resume;
1012 thread_db_ops.to_wait = thread_db_wait;
1013 thread_db_ops.to_fetch_registers = thread_db_fetch_registers;
1014 thread_db_ops.to_store_registers = thread_db_store_registers;
1015 thread_db_ops.to_xfer_memory = thread_db_xfer_memory;
1016 thread_db_ops.to_kill = thread_db_kill;
1017 thread_db_ops.to_create_inferior = thread_db_create_inferior;
1018 thread_db_ops.to_post_startup_inferior = thread_db_post_startup_inferior;
1019 thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
1020 thread_db_ops.to_thread_alive = thread_db_thread_alive;
1021 thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
1022 thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
1023 thread_db_ops.to_stratum = thread_stratum;
1024 thread_db_ops.to_has_thread_control = tc_schedlock;
1025 thread_db_ops.to_magic = OPS_MAGIC;
1026}
1027
1028void
1029_initialize_thread_db (void)
1030{
1031 /* Only initialize the module if we can load libthread_db. */
1032 if (thread_db_load ())
1033 {
1034 init_thread_db_ops ();
1035 add_target (&thread_db_ops);
1036
1037 /* Add ourselves to objfile event chain. */
1038 target_new_objfile_chain = target_new_objfile_hook;
1039 target_new_objfile_hook = thread_db_new_objfile;
1040 }
1041}
GDB Binutils - Deliverables
This page took 0.026565 seconds and 4 git commands to generate.