1 /* Multi-threaded debugging support for the thread_db interface,
2 used on operating systems such as Solaris and Linux.
3 Copyright 1999, 2001 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. */
22 /* This module implements a thread_stratum target that sits on top of
23 a normal process_stratum target (such as procfs or ptrace). The
24 process_stratum target must install this thread_stratum target when
25 it detects the presence of the thread_db shared library.
27 This module will then use the thread_db API to add thread-awareness
28 to the functionality provided by the process_stratum target (or in
29 some cases, to add user-level thread awareness on top of the
30 kernel-level thread awareness that is already provided by the
31 process_stratum target).
33 Solaris threads (for instance) are a multi-level thread implementation;
34 the kernel provides a Light Weight Process (LWP) which the procfs
35 process_stratum module is aware of. This module must then mediate
36 the relationship between kernel LWP threads and user (eg. posix)
39 Linux threads are likely to be different -- but the thread_db
40 library API should make the difference largely transparent to GDB.
44 /* The thread_db API provides a number of functions that give the caller
45 access to the inner workings of the child process's thread library.
46 We will be using the following (others may be added):
48 td_thr_validate Confirm valid "live" thread
49 td_thr_get_info Get info about a thread
50 td_thr_getgregs Get thread's general registers
51 td_thr_getfpregs Get thread's floating point registers
52 td_thr_setgregs Set thread's general registers
53 td_thr_setfpregs Set thread's floating point registers
54 td_ta_map_id2thr Get thread handle from thread id
55 td_ta_map_lwp2thr Get thread handle from LWP id
56 td_ta_thr_iter Iterate over all threads (with callback)
58 In return, the debugger has to provide certain services to the
59 thread_db library. Some of these aren't actually required to do
60 anything in practice. For instance, the thread_db expects to be
61 able to stop the child process and start it again: but in our
62 context, the child process will always be stopped already when we
63 invoke the thread_db library, so the functions that we provide for
64 the library to stop and start the child process are no-ops.
66 Here is the list of functions which we export to the thread_db
67 library, divided into no-op functions vs. functions that actually
72 ps_pstop Stop the child process
73 ps_pcontinue Continue the child process
74 ps_lstop Stop a specific LWP (kernel thread)
75 ps_lcontinue Continue an LWP
76 ps_lgetxregsize Get size of LWP's xregs (sparc)
77 ps_lgetxregs Get LWP's xregs (sparc)
78 ps_lsetxregs Set LWP's xregs (sparc)
80 Functions that have to do useful work:
82 ps_pglobal_lookup Get the address of a global symbol
83 ps_pdread Read memory, data segment
84 ps_ptread Read memory, text segment
85 ps_pdwrite Write memory, data segment
86 ps_ptwrite Write memory, text segment
87 ps_lgetregs Get LWP's general registers
88 ps_lgetfpregs Get LWP's floating point registers
89 ps_lsetregs Set LWP's general registers
90 ps_lsetfpregs Set LWP's floating point registers
91 ps_lgetLDT Get LWP's Local Descriptor Table (x86)
93 Thus, if we ask the thread_db library to give us the general registers
94 for user thread X, thread_db may figure out that user thread X is
95 actually mapped onto kernel thread Y. Thread_db does not know how
96 to obtain the registers for kernel thread Y, but GDB does, so thread_db
97 turns the request right back to us via the ps_lgetregs callback. */
100 #include "gdbthread.h"
102 #include "inferior.h"
104 #include "regcache.h"
106 #include "gdb_wait.h"
110 #if defined(USE_PROC_FS) || defined(HAVE_GREGSET_T)
111 #include <sys/procfs.h>
114 #include "gdb_proc_service.h"
116 #if defined HAVE_STDINT_H /* Pre-5.2 systems don't have this header */
117 #if defined (HAVE_THREAD_DB_H)
118 #include <thread_db.h> /* defines outgoing API (td_thr_* calls) */
120 #include "gdb_thread_db.h"
123 #include <dlfcn.h> /* dynamic library interface */
125 /* Prototypes for supply_gregset etc. */
129 #define TIDGET(PID) (((PID) & 0x7fffffff) >> 16)
130 #define PIDGET(PID) (((PID) & 0xffff))
131 #define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
134 /* Macros for superimposing PID and TID into inferior_pid. */
135 #define THREAD_FLAG 0x80000000
136 #define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
137 #define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
138 #define GET_LWP(PID) TIDGET (PID)
139 #define GET_THREAD(PID) TIDGET (PID)
140 #define BUILD_LWP(TID, PID) MERGEPID (PID, TID)
141 #define BUILD_THREAD(TID, PID) (MERGEPID (PID, TID) | THREAD_FLAG)
144 * target_beneath is a pointer to the target_ops underlying this one.
147 static struct target_ops
*target_beneath
;
151 * target vector defined in this module:
154 static struct target_ops thread_db_ops
;
157 * Typedefs required to resolve differences between the thread_db
158 * and proc_service API defined on different versions of Solaris:
161 #if defined(PROC_SERVICE_IS_OLD)
162 typedef const struct ps_prochandle
*gdb_ps_prochandle_t
;
163 typedef char *gdb_ps_read_buf_t
;
164 typedef char *gdb_ps_write_buf_t
;
165 typedef int gdb_ps_size_t
;
167 typedef struct ps_prochandle
*gdb_ps_prochandle_t
;
168 typedef void *gdb_ps_read_buf_t
;
169 typedef const void *gdb_ps_write_buf_t
;
170 typedef size_t gdb_ps_size_t
;
174 * proc_service callback functions, called by thread_db.
178 ps_pstop (gdb_ps_prochandle_t ph
) /* Process stop */
184 ps_pcontinue (gdb_ps_prochandle_t ph
) /* Process continue */
190 ps_lstop (gdb_ps_prochandle_t ph
, /* LWP stop */
197 ps_lcontinue (gdb_ps_prochandle_t ph
, /* LWP continue */
204 ps_lgetxregsize (gdb_ps_prochandle_t ph
, /* Get XREG size */
212 ps_lgetxregs (gdb_ps_prochandle_t ph
, /* Get XREGS */
220 ps_lsetxregs (gdb_ps_prochandle_t ph
, /* Set XREGS */
228 ps_plog (const char *fmt
, ...)
232 va_start (args
, fmt
);
233 vfprintf_filtered (gdb_stderr
, fmt
, args
);
236 /* Look up a symbol in GDB's global symbol table.
237 Return the symbol's address.
238 FIXME: it would be more correct to look up the symbol in the context
239 of the LD_OBJECT_NAME provided. However we're probably fairly safe
240 as long as there aren't name conflicts with other libraries. */
243 ps_pglobal_lookup (gdb_ps_prochandle_t ph
,
244 const char *ld_object_name
, /* the library name */
245 const char *ld_symbol_name
, /* the symbol name */
246 paddr_t
*ld_symbol_addr
) /* return the symbol addr */
248 struct minimal_symbol
*ms
;
250 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
255 *ld_symbol_addr
= SYMBOL_VALUE_ADDRESS (ms
);
260 /* Worker function for all memory reads and writes: */
261 static ps_err_e
rw_common (const struct ps_prochandle
*ph
,
267 /* target_xfer_memory direction consts */
268 enum {PS_READ
= 0, PS_WRITE
= 1};
271 ps_pdread (gdb_ps_prochandle_t ph
, /* read from data segment */
273 gdb_ps_read_buf_t buf
,
276 return rw_common (ph
, addr
, buf
, size
, PS_READ
);
280 ps_pdwrite (gdb_ps_prochandle_t ph
, /* write to data segment */
282 gdb_ps_write_buf_t buf
,
285 return rw_common (ph
, addr
, (char *) buf
, size
, PS_WRITE
);
289 ps_ptread (gdb_ps_prochandle_t ph
, /* read from text segment */
291 gdb_ps_read_buf_t buf
,
294 return rw_common (ph
, addr
, buf
, size
, PS_READ
);
298 ps_ptwrite (gdb_ps_prochandle_t ph
, /* write to text segment */
300 gdb_ps_write_buf_t buf
,
303 return rw_common (ph
, addr
, (char *) buf
, size
, PS_WRITE
);
306 static struct cleanup
*save_inferior_pid (void);
307 static void restore_inferior_pid (void *saved_pid
);
308 static char *thr_err_string (td_err_e
);
309 static char *thr_state_string (td_thr_state_e
);
311 struct ps_prochandle main_prochandle
;
312 td_thragent_t
* main_threadagent
;
315 * Common proc_service routine for reading and writing memory.
318 /* FIXME: once we've munged the inferior_pid, why can't we
319 simply call target_read/write_memory and return? */
323 rw_common (const struct ps_prochandle
*ph
,
329 struct cleanup
*old_chain
= save_inferior_pid ();
333 inferior_pid
= main_prochandle
.pid
;
337 done
= current_target
.to_xfer_memory (addr
, buf
, size
, write_p
,
341 if (write_p
== PS_READ
)
342 print_sys_errmsg ("rw_common (): read", errno
);
344 print_sys_errmsg ("rw_common (): write", errno
);
351 do_cleanups (old_chain
);
355 /* Cleanup functions used by the register callbacks
356 (which have to manipulate the global inferior_pid). */
359 ps_lgetregs (gdb_ps_prochandle_t ph
, /* Get LWP general regs */
363 struct cleanup
*old_chain
= save_inferior_pid ();
365 inferior_pid
= BUILD_LWP (lwpid
, main_prochandle
.pid
);
366 current_target
.to_fetch_registers (-1);
368 fill_gregset (gregset
, -1);
369 do_cleanups (old_chain
);
375 ps_lsetregs (gdb_ps_prochandle_t ph
, /* Set LWP general regs */
377 const prgregset_t gregset
)
379 struct cleanup
*old_chain
= save_inferior_pid ();
381 inferior_pid
= BUILD_LWP (lwpid
, main_prochandle
.pid
);
382 supply_gregset (gregset
);
383 current_target
.to_store_registers (-1);
384 do_cleanups (old_chain
);
389 ps_lgetfpregs (gdb_ps_prochandle_t ph
, /* Get LWP float regs */
391 gdb_prfpregset_t
*fpregset
)
393 struct cleanup
*old_chain
= save_inferior_pid ();
395 inferior_pid
= BUILD_LWP (lwpid
, main_prochandle
.pid
);
396 current_target
.to_fetch_registers (-1);
397 fill_fpregset (fpregset
, -1);
398 do_cleanups (old_chain
);
403 ps_lsetfpregs (gdb_ps_prochandle_t ph
, /* Set LWP float regs */
405 const gdb_prfpregset_t
*fpregset
)
407 struct cleanup
*old_chain
= save_inferior_pid ();
409 inferior_pid
= BUILD_LWP (lwpid
, main_prochandle
.pid
);
410 supply_fpregset (fpregset
);
411 current_target
.to_store_registers (-1);
412 do_cleanups (old_chain
);
419 * return the main pid for the child process
420 * (special for Linux -- not used on Solaris)
424 ps_getpid (gdb_ps_prochandle_t ph
)
431 /* Reads the local descriptor table of a LWP. */
434 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
437 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c */
438 extern struct ssd
*procfs_find_LDT_entry (int);
441 ret
= procfs_find_LDT_entry (BUILD_LWP (lwpid
,
442 PIDGET (main_prochandle
.pid
)));
445 memcpy (pldt
, ret
, sizeof (struct ssd
));
448 else /* LDT not found. */
451 #endif /* TM_I386SOL2_H */
454 * Pointers to thread_db functions:
456 * These are a dynamic library mechanism.
457 * The dlfcn.h interface will be used to initialize these
458 * so that they point to the appropriate functions in the
459 * thread_db dynamic library. This is done dynamically
460 * so that GDB can still run on systems that lack thread_db.
463 static td_err_e (*p_td_init
) (void);
465 static td_err_e (*p_td_ta_new
) (const struct ps_prochandle
*ph_p
,
466 td_thragent_t
**ta_pp
);
468 static td_err_e (*p_td_ta_delete
) (td_thragent_t
*ta_p
);
470 static td_err_e (*p_td_ta_get_nthreads
) (const td_thragent_t
*ta_p
,
474 static td_err_e (*p_td_ta_thr_iter
) (const td_thragent_t
*ta_p
,
477 td_thr_state_e state
,
479 sigset_t
*ti_sigmask_p
,
480 unsigned ti_user_flags
);
482 static td_err_e (*p_td_ta_event_addr
) (const td_thragent_t
*ta_p
,
484 td_notify_t
*notify_p
);
486 static td_err_e (*p_td_ta_event_getmsg
) (const td_thragent_t
*ta_p
,
487 td_event_msg_t
*msg
);
489 static td_err_e (*p_td_ta_set_event
) (const td_thragent_t
*ta_p
,
490 td_thr_events_t
*events
);
492 static td_err_e (*p_td_thr_validate
) (const td_thrhandle_t
*th_p
);
494 static td_err_e (*p_td_thr_event_enable
) (const td_thrhandle_t
*th_p
,
497 static td_err_e (*p_td_thr_get_info
) (const td_thrhandle_t
*th_p
,
500 static td_err_e (*p_td_thr_getgregs
) (const td_thrhandle_t
*th_p
,
503 static td_err_e (*p_td_thr_setgregs
) (const td_thrhandle_t
*th_p
,
504 const prgregset_t regset
);
506 static td_err_e (*p_td_thr_getfpregs
) (const td_thrhandle_t
*th_p
,
507 gdb_prfpregset_t
*fpregset
);
509 static td_err_e (*p_td_thr_setfpregs
) (const td_thrhandle_t
*th_p
,
510 const gdb_prfpregset_t
*fpregset
);
512 static td_err_e (*p_td_ta_map_id2thr
) (const td_thragent_t
*ta_p
,
514 td_thrhandle_t
*th_p
);
516 static td_err_e (*p_td_ta_map_lwp2thr
) (const td_thragent_t
*ta_p
,
518 td_thrhandle_t
*th_p
);
521 * API and target vector initialization function: thread_db_initialize.
523 * NOTE: this function is deliberately NOT named with the GDB convention
524 * of module initializer function names that begin with "_initialize".
525 * This module is NOT intended to be auto-initialized at GDB startup.
526 * Rather, it will only be initialized when a multi-threaded child
527 * process is detected.
532 * Initializer for thread_db library interface.
533 * This function does the dynamic library stuff (dlopen, dlsym),
534 * and then calls the thread_db library's one-time initializer
535 * function (td_init). If everything succeeds, this function
536 * returns true; otherwise it returns false, and this module
541 init_thread_db_library (void)
546 /* Open a handle to the "thread_db" dynamic library. */
547 if ((dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
)) == NULL
)
550 /* Initialize pointers to the dynamic library functions we will use.
551 * Note that we are not calling the functions here -- we are only
552 * establishing pointers to them.
555 /* td_init: initialize thread_db library. */
556 if ((p_td_init
= dlsym (dlhandle
, "td_init")) == NULL
)
558 /* td_ta_new: register a target process with thread_db. */
559 if ((p_td_ta_new
= dlsym (dlhandle
, "td_ta_new")) == NULL
)
561 /* td_ta_delete: un-register a target process with thread_db. */
562 if ((p_td_ta_delete
= dlsym (dlhandle
, "td_ta_delete")) == NULL
)
565 /* td_ta_map_id2thr: get thread handle from thread id. */
566 if ((p_td_ta_map_id2thr
= dlsym (dlhandle
, "td_ta_map_id2thr")) == NULL
)
568 /* td_ta_map_lwp2thr: get thread handle from lwp id. */
569 if ((p_td_ta_map_lwp2thr
= dlsym (dlhandle
, "td_ta_map_lwp2thr")) == NULL
)
571 /* td_ta_get_nthreads: get number of threads in target process. */
572 if ((p_td_ta_get_nthreads
= dlsym (dlhandle
, "td_ta_get_nthreads")) == NULL
)
574 /* td_ta_thr_iter: iterate over all thread handles. */
575 if ((p_td_ta_thr_iter
= dlsym (dlhandle
, "td_ta_thr_iter")) == NULL
)
578 /* td_thr_validate: make sure a thread handle is real and alive. */
579 if ((p_td_thr_validate
= dlsym (dlhandle
, "td_thr_validate")) == NULL
)
581 /* td_thr_get_info: get a bunch of info about a thread. */
582 if ((p_td_thr_get_info
= dlsym (dlhandle
, "td_thr_get_info")) == NULL
)
584 /* td_thr_getgregs: get general registers for thread. */
585 if ((p_td_thr_getgregs
= dlsym (dlhandle
, "td_thr_getgregs")) == NULL
)
587 /* td_thr_setgregs: set general registers for thread. */
588 if ((p_td_thr_setgregs
= dlsym (dlhandle
, "td_thr_setgregs")) == NULL
)
590 /* td_thr_getfpregs: get floating point registers for thread. */
591 if ((p_td_thr_getfpregs
= dlsym (dlhandle
, "td_thr_getfpregs")) == NULL
)
593 /* td_thr_setfpregs: set floating point registers for thread. */
594 if ((p_td_thr_setfpregs
= dlsym (dlhandle
, "td_thr_setfpregs")) == NULL
)
600 warning ("init_thread_db: td_init: %s", thr_err_string (ret
));
604 /* Optional functions:
605 We can still debug even if the following functions are not found. */
607 /* td_ta_event_addr: get the breakpoint address for specified event. */
608 p_td_ta_event_addr
= dlsym (dlhandle
, "td_ta_event_addr");
610 /* td_ta_event_getmsg: get the next event message for the process. */
611 p_td_ta_event_getmsg
= dlsym (dlhandle
, "td_ta_event_getmsg");
613 /* td_ta_set_event: request notification of an event. */
614 p_td_ta_set_event
= dlsym (dlhandle
, "td_ta_set_event");
616 /* td_thr_event_enable: enable event reporting in a thread. */
617 p_td_thr_event_enable
= dlsym (dlhandle
, "td_thr_event_enable");
619 return 1; /* success */
623 * Local utility functions:
631 save_inferior_pid - Save inferior_pid on the cleanup list
632 restore_inferior_pid - Restore inferior_pid from the cleanup list
636 struct cleanup *save_inferior_pid (void);
637 void restore_inferior_pid (void *saved_pid);
641 These two functions act in unison to restore inferior_pid in
646 inferior_pid is a global variable that needs to be changed by many
647 of these routines before calling functions in procfs.c. In order
648 to guarantee that inferior_pid gets restored (in case of errors),
649 you need to call save_inferior_pid before changing it. At the end
650 of the function, you should invoke do_cleanups to restore it.
654 static struct cleanup
*
655 save_inferior_pid (void)
659 saved_pid_ptr
= xmalloc (sizeof (int));
660 *saved_pid_ptr
= inferior_pid
;
661 return make_cleanup (restore_inferior_pid
, saved_pid_ptr
);
665 restore_inferior_pid (void *arg
)
667 int *saved_pid_ptr
= arg
;
668 inferior_pid
= *saved_pid_ptr
;
676 thr_err_string - Convert a thread_db error code to a string
680 char * thr_err_string (errcode)
684 Return a string description of the thread_db errcode. If errcode
685 is unknown, then return an <unknown> message.
690 thr_err_string (td_err_e errcode
)
695 case TD_OK
: return "generic 'call succeeded'";
696 case TD_ERR
: return "generic error";
697 case TD_NOTHR
: return "no thread to satisfy query";
698 case TD_NOSV
: return "no sync handle to satisfy query";
699 case TD_NOLWP
: return "no lwp to satisfy query";
700 case TD_BADPH
: return "invalid process handle";
701 case TD_BADTH
: return "invalid thread handle";
702 case TD_BADSH
: return "invalid synchronization handle";
703 case TD_BADTA
: return "invalid thread agent";
704 case TD_BADKEY
: return "invalid key";
705 case TD_NOMSG
: return "no event message for getmsg";
706 case TD_NOFPREGS
: return "FPU register set not available";
707 case TD_NOLIBTHREAD
: return "application not linked with libthread";
708 case TD_NOEVENT
: return "requested event is not supported";
709 case TD_NOCAPAB
: return "capability not available";
710 case TD_DBERR
: return "debugger service failed";
711 case TD_NOAPLIC
: return "operation not applicable to";
712 case TD_NOTSD
: return "no thread-specific data for this thread";
713 case TD_MALLOC
: return "malloc failed";
714 case TD_PARTIALREG
: return "only part of register set was written/read";
715 case TD_NOXREGS
: return "X register set not available for this thread";
717 sprintf (buf
, "unknown thread_db error '%d'", errcode
);
726 thr_state_string - Convert a thread_db state code to a string
730 char *thr_state_string (statecode)
734 Return the thread_db state string associated with statecode.
735 If statecode is unknown, then return an <unknown> message.
740 thr_state_string (td_thr_state_e statecode
)
745 case TD_THR_STOPPED
: return "stopped by debugger";
746 case TD_THR_RUN
: return "runnable";
747 case TD_THR_ACTIVE
: return "active";
748 case TD_THR_ZOMBIE
: return "zombie";
749 case TD_THR_SLEEP
: return "sleeping";
750 case TD_THR_STOPPED_ASLEEP
: return "stopped by debugger AND blocked";
752 sprintf (buf
, "unknown thread_db state %d", statecode
);
758 * Local thread/event list.
759 * This data structure will be used to hold a list of threads and
760 * pending/deliverable events.
763 typedef struct THREADINFO
{
764 thread_t tid
; /* thread ID */
765 pid_t lid
; /* process/lwp ID */
766 td_thr_state_e state
; /* thread state (a la thread_db) */
767 td_thr_type_e type
; /* thread type (a la thread_db) */
768 int pending
; /* true if holding a pending event */
769 int status
; /* wait status of any interesting event */
772 threadinfo
* threadlist
;
773 int threadlist_max
= 0; /* current size of table */
774 int threadlist_top
= 0; /* number of threads now in table */
775 #define THREADLIST_ALLOC 100 /* chunk size by which to expand table */
778 insert_thread (int tid
, int lid
, td_thr_state_e state
, td_thr_type_e type
)
780 if (threadlist_top
>= threadlist_max
)
782 threadlist_max
+= THREADLIST_ALLOC
;
783 threadlist
= realloc (threadlist
,
784 threadlist_max
* sizeof (threadinfo
));
785 if (threadlist
== NULL
)
788 threadlist
[threadlist_top
].tid
= tid
;
789 threadlist
[threadlist_top
].lid
= lid
;
790 threadlist
[threadlist_top
].state
= state
;
791 threadlist
[threadlist_top
].type
= type
;
792 threadlist
[threadlist_top
].pending
= 0;
793 threadlist
[threadlist_top
].status
= 0;
795 return &threadlist
[threadlist_top
++];
799 empty_threadlist (void)
805 next_pending_event (void)
809 for (i
= 0; i
< threadlist_top
; i
++)
810 if (threadlist
[i
].pending
)
811 return &threadlist
[i
];
817 threadlist_iter (int (*func
) (), void *data
, td_thr_state_e state
,
822 for (i
= 0; i
< threadlist_top
; i
++)
823 if ((state
== TD_THR_ANY_STATE
|| state
== threadlist
[i
].state
) &&
824 (type
== TD_THR_ANY_TYPE
|| type
== threadlist
[i
].type
))
825 if ((*func
) (&threadlist
[i
], data
) != 0)
834 * Here we keep state information all collected in one place.
837 /* This flag is set when we activate, so that we don't do it twice.
838 Defined in linux-thread.c and used for inter-target syncronization. */
839 extern int using_thread_db
;
841 /* The process id for which we've stopped.
842 * This is only set when we actually stop all threads.
843 * Otherwise it's zero.
845 static int event_pid
;
848 * The process id for a new thread to which we've just attached.
849 * This process needs special handling at resume time.
851 static int attach_pid
;
855 * thread_db event handling:
857 * The mechanism for event notification via the thread_db API.
858 * These events are implemented as breakpoints. The thread_db
859 * library gives us an address where we can set a breakpoint.
860 * When the breakpoint is hit, it represents an event of interest
867 /* Location of the thread creation event breakpoint. The code at this
868 location in the child process will be called by the pthread library
869 whenever a new thread is created. By setting a special breakpoint
870 at this location, GDB can detect when a new thread is created. We
871 obtain this location via the td_ta_event_addr call. */
873 static CORE_ADDR thread_creation_bkpt_address
;
875 /* Location of the thread death event breakpoint. The code at this
876 location in the child process will be called by the pthread library
877 whenever a thread is destroyed. By setting a special breakpoint at
878 this location, GDB can detect when a new thread is created. We
879 obtain this location via the td_ta_event_addr call. */
881 static CORE_ADDR thread_death_bkpt_address
;
883 /* This function handles the global parts of enabling thread events.
884 The thread-specific enabling is handled per-thread elsewhere. */
887 enable_thread_event_reporting (td_thragent_t
*ta
)
889 td_thr_events_t events
;
893 if (p_td_ta_set_event
== NULL
||
894 p_td_ta_event_addr
== NULL
||
895 p_td_ta_event_getmsg
== NULL
||
896 p_td_thr_event_enable
== NULL
)
897 return; /* can't do thread event reporting without these funcs */
899 /* set process wide mask saying which events we are interested in */
900 td_event_emptyset (&events
);
901 td_event_addset (&events
, TD_CREATE
);
902 td_event_addset (&events
, TD_DEATH
);
904 if (p_td_ta_set_event (ta
, &events
) != TD_OK
)
906 warning ("unable to set global thread event mask");
910 /* Delete previous thread event breakpoints, if any. */
911 remove_thread_event_breakpoints ();
913 /* create breakpoints -- thread creation and death */
914 /* thread creation */
915 /* get breakpoint location */
916 if (p_td_ta_event_addr (ta
, TD_CREATE
, ¬ify
) != TD_OK
)
918 warning ("unable to get location for thread creation breakpoint");
922 /* Set up the breakpoint. */
923 create_thread_event_breakpoint (notify
.u
.bptaddr
);
925 /* Save it's location. */
926 thread_creation_bkpt_address
= notify
.u
.bptaddr
;
929 /* get breakpoint location */
930 if (p_td_ta_event_addr (ta
, TD_DEATH
, ¬ify
) != TD_OK
)
932 warning ("unable to get location for thread death breakpoint");
935 /* Set up the breakpoint. */
936 create_thread_event_breakpoint (notify
.u
.bptaddr
);
938 /* Save it's location. */
939 thread_death_bkpt_address
= notify
.u
.bptaddr
;
942 /* This function handles the global parts of disabling thread events.
943 The thread-specific enabling is handled per-thread elsewhere. */
946 disable_thread_event_reporting (td_thragent_t
*ta
)
948 td_thr_events_t events
;
950 /* set process wide mask saying we aren't interested in any events */
951 td_event_emptyset (&events
);
952 p_td_ta_set_event (main_threadagent
, &events
);
954 /* Delete thread event breakpoints, if any. */
955 remove_thread_event_breakpoints ();
956 thread_creation_bkpt_address
= 0;
957 thread_death_bkpt_address
= 0;
960 /* check_for_thread_event
962 if it's a thread event we recognize (currently
963 we only recognize creation and destruction
964 events), return 1; else return 0. */
968 check_for_thread_event (struct target_waitstatus
*tws
, int event_pid
)
970 /* FIXME: to be more efficient, we should keep a static
971 list of threads, and update it only here (with td_ta_thr_iter). */
975 thread_db_push_target (void)
977 /* Called ONLY from thread_db_new_objfile after td_ta_new call succeeds. */
979 /* Push this target vector */
980 push_target (&thread_db_ops
);
981 /* Find the underlying process-layer target for calling later. */
982 target_beneath
= find_target_beneath (&thread_db_ops
);
984 /* Turn on thread_db event-reporting API. */
985 enable_thread_event_reporting (main_threadagent
);
989 thread_db_unpush_target (void)
991 /* Must be called whenever we remove ourself from the target stack! */
994 target_beneath
= NULL
;
996 /* delete local list of threads */
998 /* Turn off the thread_db API. */
999 p_td_ta_delete (main_threadagent
);
1000 /* Unpush this target vector */
1001 unpush_target (&thread_db_ops
);
1002 /* Reset linuxthreads module. */
1003 linuxthreads_discard_global_state ();
1007 * New objfile hook function:
1008 * Called for each new objfile (image, shared lib) in the target process.
1010 * The purpose of this function is to detect that the target process
1011 * is linked with the (appropriate) thread library. So every time a
1012 * new target shared library is detected, we will call td_ta_new.
1013 * If it succeeds, we know we have a multi-threaded target process
1014 * that we can debug using the thread_db API.
1018 * new_objfile function:
1020 * connected to target_new_objfile_hook, this function gets called
1021 * every time a new binary image is loaded.
1023 * At each call, we attempt to open the thread_db connection to the
1024 * child process. If it succeeds, we know we have a libthread process
1025 * and we can debug it with this target vector. Therefore we push
1026 * ourself onto the target stack.
1029 static void (*target_new_objfile_chain
) (struct objfile
*objfile
);
1030 static int stop_or_attach_thread_callback (const td_thrhandle_t
*th
,
1032 static int wait_thread_callback (const td_thrhandle_t
*th
,
1036 thread_db_new_objfile (struct objfile
*objfile
)
1040 if (using_thread_db
) /* libthread already detected, and */
1041 goto quit
; /* thread target vector activated. */
1043 if (objfile
== NULL
)
1044 goto quit
; /* un-interesting object file */
1046 /* Initialize our "main prochandle" with the main inferior pid. */
1047 main_prochandle
.pid
= PIDGET (inferior_pid
);
1049 /* Now attempt to open a thread_db connection to the
1050 thread library running in the child process. */
1051 ret
= p_td_ta_new (&main_prochandle
, &main_threadagent
);
1054 warning ("Unexpected error initializing thread_db: %s",
1055 thr_err_string (ret
));
1057 case TD_NOLIBTHREAD
: /* expected: no libthread in child process (yet) */
1059 case TD_OK
: /* libthread detected in child: we go live now! */
1060 thread_db_push_target ();
1061 event_pid
= inferior_pid
; /* for resume */
1063 /* Now stop everyone else, and attach any new threads you find. */
1064 p_td_ta_thr_iter (main_threadagent
,
1065 stop_or_attach_thread_callback
,
1068 TD_THR_LOWEST_PRIORITY
,
1070 TD_THR_ANY_USER_FLAGS
);
1072 /* Now go call wait on all the threads you've stopped:
1073 This allows us to absorb the SIGKILL event, and to make sure
1074 that the thread knows that it is stopped (Linux peculiarity). */
1075 p_td_ta_thr_iter (main_threadagent
,
1076 wait_thread_callback
,
1079 TD_THR_LOWEST_PRIORITY
,
1081 TD_THR_ANY_USER_FLAGS
);
1086 if (target_new_objfile_chain
)
1087 target_new_objfile_chain (objfile
);
1095 thread_db_alive - test thread for "aliveness"
1099 static bool thread_db_alive (int pid);
1103 returns true if thread still active in inferior.
1108 thread_db_alive (int pid
)
1110 if (is_thread (pid
)) /* user-space (non-kernel) thread */
1115 pid
= GET_THREAD (pid
);
1116 if ((ret
= p_td_ta_map_id2thr (main_threadagent
, pid
, &th
)) != TD_OK
)
1117 return 0; /* thread not found */
1118 if ((ret
= p_td_thr_validate (&th
)) != TD_OK
)
1119 return 0; /* thread not valid */
1120 return 1; /* known thread: return true */
1122 else if (target_beneath
->to_thread_alive
)
1123 return target_beneath
->to_thread_alive (pid
);
1125 return 0; /* default to "not alive" (shouldn't happen anyway) */
1129 * get_lwp_from_thread_handle
1132 static int /* lwpid_t or pid_t */
1133 get_lwp_from_thread_handle (td_thrhandle_t
*th
)
1138 if ((ret
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1139 error ("get_lwp_from_thread_handle: thr_get_info failed: %s",
1140 thr_err_string (ret
));
1146 * get_lwp_from_thread_id
1149 static int /* lwpid_t or pid_t */
1150 get_lwp_from_thread_id (int tid
/* thread_t? */)
1155 if ((ret
= p_td_ta_map_id2thr (main_threadagent
, tid
, &th
)) != TD_OK
)
1156 error ("get_lwp_from_thread_id: map_id2thr failed: %s",
1157 thr_err_string (ret
));
1159 return get_lwp_from_thread_handle (&th
);
1163 * pid_to_str has to handle user-space threads.
1164 * If not a user-space thread, then pass the request on to the
1165 * underlying stratum if it can handle it: else call normal_pid_to_str.
1169 thread_db_pid_to_str (int pid
)
1171 static char buf
[100];
1176 if (is_thread (pid
))
1178 if ((ret
= p_td_ta_map_id2thr (main_threadagent
,
1181 error ("thread_db: map_id2thr failed: %s", thr_err_string (ret
));
1183 if ((ret
= p_td_thr_get_info (&th
, &ti
)) != TD_OK
)
1184 error ("thread_db: thr_get_info failed: %s", thr_err_string (ret
));
1186 if (ti
.ti_state
== TD_THR_ACTIVE
&&
1188 sprintf (buf
, "Thread %d (LWP %d)", ti
.ti_tid
, ti
.ti_lid
);
1190 sprintf (buf
, "Thread %d (%s)", ti
.ti_tid
,
1191 thr_state_string (ti
.ti_state
));
1193 else if (GET_LWP (pid
))
1194 sprintf (buf
, "LWP %d", GET_LWP (pid
));
1195 else return normal_pid_to_str (pid
);
1201 * thread_db target vector functions:
1205 thread_db_files_info (struct target_ops
*tgt_vector
)
1207 /* This function will be unnecessary in real life. */
1208 printf_filtered ("thread_db stratum:\n");
1209 target_beneath
->to_files_info (tgt_vector
);
1213 * xfer_memory has to munge the inferior_pid before passing the call
1214 * down to the target layer.
1218 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int dowrite
,
1219 struct target_ops
*target
)
1221 struct cleanup
*old_chain
;
1224 old_chain
= save_inferior_pid ();
1226 if (is_thread (inferior_pid
) ||
1227 !target_thread_alive (inferior_pid
))
1229 /* FIXME: use the LID/LWP, so that underlying process layer
1230 can read memory from specific threads? */
1231 inferior_pid
= main_prochandle
.pid
;
1234 ret
= target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
,
1236 do_cleanups (old_chain
);
1241 * fetch_registers has to determine if inferior_pid is a user-space thread.
1242 * If so, we use the thread_db API to get the registers.
1243 * And if not, we call the underlying process stratum.
1247 thread_db_fetch_registers (int regno
)
1249 td_thrhandle_t thandle
;
1250 gdb_prfpregset_t fpregset
;
1251 prgregset_t gregset
;
1255 if (!is_thread (inferior_pid
)) /* kernel thread */
1256 { /* pass the request on to the target underneath. */
1257 target_beneath
->to_fetch_registers (regno
);
1261 /* convert inferior_pid into a td_thrhandle_t */
1263 if ((thread
= GET_THREAD (inferior_pid
)) == 0)
1264 error ("fetch_registers: thread == 0");
1266 if ((ret
= p_td_ta_map_id2thr (main_threadagent
, thread
, &thandle
)) != TD_OK
)
1267 error ("fetch_registers: td_ta_map_id2thr: %s", thr_err_string (ret
));
1269 /* Get the integer regs:
1270 For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7,
1271 pc and sp are saved (by a thread context switch). */
1272 if ((ret
= p_td_thr_getgregs (&thandle
, gregset
)) != TD_OK
&&
1273 ret
!= TD_PARTIALREG
)
1274 error ("fetch_registers: td_thr_getgregs %s", thr_err_string (ret
));
1276 /* And, now the fp regs */
1277 if ((ret
= p_td_thr_getfpregs (&thandle
, &fpregset
)) != TD_OK
&&
1279 error ("fetch_registers: td_thr_getfpregs %s", thr_err_string (ret
));
1281 /* Note that we must call supply_{g fp}regset *after* calling the td routines
1282 because the td routines call ps_lget* which affect the values stored in the
1285 supply_gregset (gregset
);
1286 supply_fpregset (&fpregset
);
1291 * store_registers has to determine if inferior_pid is a user-space thread.
1292 * If so, we use the thread_db API to get the registers.
1293 * And if not, we call the underlying process stratum.
1297 thread_db_store_registers (int regno
)
1299 td_thrhandle_t thandle
;
1300 gdb_prfpregset_t fpregset
;
1301 prgregset_t gregset
;
1305 if (!is_thread (inferior_pid
)) /* Kernel thread: */
1306 { /* pass the request on to the underlying target vector. */
1307 target_beneath
->to_store_registers (regno
);
1311 /* convert inferior_pid into a td_thrhandle_t */
1313 if ((thread
= GET_THREAD (inferior_pid
)) == 0)
1314 error ("store_registers: thread == 0");
1316 if ((ret
= p_td_ta_map_id2thr (main_threadagent
, thread
, &thandle
)) != TD_OK
)
1317 error ("store_registers: td_ta_map_id2thr %s", thr_err_string (ret
));
1320 { /* Not writing all the regs */
1321 /* save new register value */
1322 /* MVS: I don't understand this... */
1323 char old_value
[REGISTER_SIZE
];
1325 memcpy (old_value
, ®isters
[REGISTER_BYTE (regno
)], REGISTER_SIZE
);
1327 if ((ret
= p_td_thr_getgregs (&thandle
, gregset
)) != TD_OK
)
1328 error ("store_registers: td_thr_getgregs %s", thr_err_string (ret
));
1329 if ((ret
= p_td_thr_getfpregs (&thandle
, &fpregset
)) != TD_OK
)
1330 error ("store_registers: td_thr_getfpregs %s", thr_err_string (ret
));
1332 /* restore new register value */
1333 memcpy (®isters
[REGISTER_BYTE (regno
)], old_value
, REGISTER_SIZE
);
1337 fill_gregset (gregset
, regno
);
1338 fill_fpregset (&fpregset
, regno
);
1340 if ((ret
= p_td_thr_setgregs (&thandle
, gregset
)) != TD_OK
)
1341 error ("store_registers: td_thr_setgregs %s", thr_err_string (ret
));
1342 if ((ret
= p_td_thr_setfpregs (&thandle
, &fpregset
)) != TD_OK
&&
1344 error ("store_registers: td_thr_setfpregs %s", thr_err_string (ret
));
1348 handle_new_thread (int tid
, /* user thread id */
1349 int lid
, /* kernel thread id */
1352 int gdb_pid
= BUILD_THREAD (tid
, main_prochandle
.pid
);
1353 int wait_pid
, wait_status
;
1356 printf_filtered ("[New %s]\n", target_pid_to_str (gdb_pid
));
1357 add_thread (gdb_pid
);
1359 if (lid
!= main_prochandle
.pid
)
1361 attach_thread (lid
);
1362 /* According to the Eric Paire model, we now have to send
1363 the restart signal to the new thread -- however, empirically,
1364 I do not find that to be necessary. */
1370 test_for_new_thread (int tid
, int lid
, int verbose
)
1372 if (!in_thread_list (BUILD_THREAD (tid
, main_prochandle
.pid
)))
1373 handle_new_thread (tid
, lid
, verbose
);
1377 * Callback function that gets called once per USER thread
1378 * (i.e., not kernel) thread by td_ta_thr_iter.
1382 find_new_threads_callback (const td_thrhandle_t
*th
, void *ignored
)
1387 if ((ret
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1389 warning ("find_new_threads_callback: %s", thr_err_string (ret
));
1390 return -1; /* bail out, get_info failed. */
1394 As things now stand, this should never detect a new thread.
1395 But if it does, we could be in trouble because we aren't calling
1396 wait_thread_callback for it. */
1397 test_for_new_thread (ti
.ti_tid
, ti
.ti_lid
, 0);
1402 * find_new_threads uses the thread_db iterator function to discover
1403 * user-space threads. Then if the underlying process stratum has a
1404 * find_new_threads method, we call that too.
1408 thread_db_find_new_threads (void)
1410 if (inferior_pid
== -1) /* FIXME: still necessary? */
1412 printf_filtered ("No process.\n");
1415 p_td_ta_thr_iter (main_threadagent
,
1416 find_new_threads_callback
,
1419 TD_THR_LOWEST_PRIORITY
,
1421 TD_THR_ANY_USER_FLAGS
);
1422 if (target_beneath
->to_find_new_threads
)
1423 target_beneath
->to_find_new_threads ();
1427 * Resume all threads, or resume a single thread.
1428 * If step is true, then single-step the appropriate thread
1429 * (or single-step inferior_pid, but continue everyone else).
1430 * If signo is true, then send that signal to at least one thread.
1434 * This function is called once for each thread before resuming.
1435 * It sends continue (no step, and no signal) to each thread except
1436 * the main thread, and
1437 * the event thread (the one that stopped at a breakpoint etc.)
1439 * The event thread is handled separately so that it can be sent
1440 * the stepping and signal args with which target_resume was called.
1442 * The main thread is resumed last, so that the thread_db proc_service
1443 * callbacks will still work during the iterator function.
1447 resume_thread_callback (const td_thrhandle_t
*th
, void *data
)
1452 if ((ret
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1454 warning ("resume_thread_callback: %s", thr_err_string (ret
));
1455 return -1; /* bail out, get_info failed. */
1458 As things now stand, this should never detect a new thread.
1459 But if it does, we could be in trouble because we aren't calling
1460 wait_thread_callback for it. */
1461 test_for_new_thread (ti
.ti_tid
, ti
.ti_lid
, 1);
1463 if (ti
.ti_lid
!= main_prochandle
.pid
&&
1464 ti
.ti_lid
!= event_pid
)
1466 /* Unconditionally continue the thread with no signal.
1467 Only the event thread will get a signal of any kind. */
1469 target_beneath
->to_resume (ti
.ti_lid
, 0, 0);
1475 new_resume_thread_callback (threadinfo
*thread
, void *data
)
1477 if (thread
->lid
!= event_pid
&&
1478 thread
->lid
!= main_prochandle
.pid
)
1480 /* Unconditionally continue the thread with no signal (for now). */
1482 target_beneath
->to_resume (thread
->lid
, 0, 0);
1487 static int last_resume_pid
;
1488 static int last_resume_step
;
1489 static int last_resume_signo
;
1492 thread_db_resume (int pid
, int step
, enum target_signal signo
)
1494 last_resume_pid
= pid
;
1495 last_resume_step
= step
;
1496 last_resume_signo
= signo
;
1498 /* resuming a specific pid? */
1501 if (is_thread (pid
))
1502 pid
= get_lwp_from_thread_id (GET_THREAD (pid
));
1503 else if (GET_LWP (pid
))
1504 pid
= GET_LWP (pid
);
1507 /* Apparently the interpretation of 'pid' is dependent on 'step':
1508 If step is true, then a specific pid means 'step only this pid'.
1509 But if step is not true, then pid means 'continue ALL pids, but
1510 give the signal only to this one'. */
1511 if (pid
!= -1 && step
)
1513 /* FIXME: is this gonna work in all circumstances? */
1514 target_beneath
->to_resume (pid
, step
, signo
);
1518 /* 1) Continue all threads except the event thread and the main thread.
1519 2) resume the event thread with step and signo.
1520 3) If event thread != main thread, continue the main thread.
1522 Note: order of 2 and 3 may need to be reversed. */
1524 threadlist_iter (new_resume_thread_callback
,
1528 /* now resume event thread, and if necessary also main thread. */
1531 target_beneath
->to_resume (event_pid
, step
, signo
);
1533 if (event_pid
!= main_prochandle
.pid
)
1535 target_beneath
->to_resume (main_prochandle
.pid
, 0, 0);
1540 /* All new threads will be attached.
1541 All previously known threads will be stopped using kill (SIGKILL). */
1544 stop_or_attach_thread_callback (const td_thrhandle_t
*th
, void *data
)
1551 if ((ret
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1553 warning ("stop_or_attach_thread_callback: %s", thr_err_string (ret
));
1554 return -1; /* bail out, get_info failed. */
1557 /* First add it to our internal list.
1558 We build this list anew at every wait event. */
1559 insert_thread (ti
.ti_tid
, ti
.ti_lid
, ti
.ti_state
, ti
.ti_type
);
1560 /* Now: if we've already seen it, stop it, else add it and attach it. */
1561 gdb_pid
= BUILD_THREAD (ti
.ti_tid
, main_prochandle
.pid
);
1562 if (!in_thread_list (gdb_pid
)) /* new thread */
1564 handle_new_thread (ti
.ti_tid
, ti
.ti_lid
, 1);
1565 /* Enable thread events */
1566 if (p_td_thr_event_enable
)
1567 if ((ret
= p_td_thr_event_enable (th
, on_off
)) != TD_OK
)
1568 warning ("stop_or_attach_thread: %s", thr_err_string (ret
));
1570 else if (ti
.ti_lid
!= event_pid
&&
1571 ti
.ti_lid
!= main_prochandle
.pid
)
1573 ret
= (td_err_e
) kill (ti
.ti_lid
, SIGSTOP
);
1580 * Wait for signal N from pid PID.
1581 * If wait returns any other signals, put them back before returning.
1585 wait_for_stop (int pid
)
1591 /* Array of wait/signal status */
1592 /* FIXME: wrong data structure, we need a queue.
1593 Realtime signals may be delivered more than once.
1594 And at that, we really can't handle them (see below). */
1596 static int wstatus
[NSIG
];
1597 #elif defined (_NSIG)
1598 static int wstatus
[_NSIG
];
1600 #error No definition for number of signals!
1603 /* clear wait/status list */
1604 memset (&wstatus
, 0, sizeof (wstatus
));
1606 /* Now look for SIGSTOP event on all threads except event thread. */
1609 if (pid
== main_prochandle
.pid
)
1610 retpid
= waitpid (pid
, &status
, 0);
1612 retpid
= waitpid (pid
, &status
, __WCLONE
);
1615 if (WSTOPSIG (status
) == SIGSTOP
)
1617 /* Got the SIGSTOP event we're looking for.
1618 Throw it away, and throw any other events back! */
1619 for (i
= 0; i
< sizeof(wstatus
) / sizeof (wstatus
[0]); i
++)
1625 break; /* all done */
1630 /* Oops, got an event other than SIGSTOP.
1631 Save it, and throw it back after we find the SIGSTOP event. */
1633 /* FIXME (how?) This method is going to fail for realtime
1634 signals, which cannot be put back simply by using kill. */
1636 if (WIFEXITED (status
))
1637 error ("Ack! Thread Exited event. What do I do now???");
1638 else if (WIFSTOPPED (status
))
1639 signo
= WSTOPSIG (status
);
1641 signo
= WTERMSIG (status
);
1643 /* If a thread other than the event thread has hit a GDB
1644 breakpoint (as opposed to some random trap signal), then
1645 just arrange for it to hit it again later. Back up the
1646 PC if necessary. Don't forward the SIGTRAP signal to
1647 the thread. We will handle the current event, eventually
1648 we will resume all the threads, and this one will get
1649 it's breakpoint trap again.
1651 If we do not do this, then we run the risk that the user
1652 will delete or disable the breakpoint, but the thread will
1653 have already tripped on it. */
1655 if (retpid
!= event_pid
&&
1657 breakpoint_inserted_here_p (read_pc_pid (retpid
) -
1658 DECR_PC_AFTER_BREAK
))
1660 /* Set the pc to before the trap and DO NOT re-send the signal */
1661 if (DECR_PC_AFTER_BREAK
)
1662 write_pc_pid (read_pc_pid (retpid
) - DECR_PC_AFTER_BREAK
,
1666 /* Since SIGINT gets forwarded to the entire process group
1667 (in the case where ^C is typed at the tty / console),
1668 just ignore all SIGINTs from other than the event thread. */
1669 else if (retpid
!= event_pid
&& signo
== SIGINT
)
1670 { /* do nothing. Signal will disappear into oblivion! */
1674 else /* This is some random signal other than a breakpoint. */
1676 wstatus
[signo
] = 1;
1678 child_resume (retpid
, 0, TARGET_SIGNAL_0
);
1682 } while (errno
== 0 || errno
== EINTR
);
1686 * wait_thread_callback
1688 * Calls waitpid for each thread, repeatedly if necessary, until
1689 * SIGSTOP is returned. Afterward, if any other signals were returned
1690 * by waitpid, return them to the thread's pending queue by calling kill.
1694 wait_thread_callback (const td_thrhandle_t
*th
, void *data
)
1699 if ((ret
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1701 warning ("wait_thread_callback: %s", thr_err_string (ret
));
1702 return -1; /* bail out, get_info failed. */
1705 /* This callback to act on all threads except the event thread: */
1706 if (ti
.ti_lid
== event_pid
|| /* no need to wait (no sigstop) */
1707 ti
.ti_lid
== main_prochandle
.pid
) /* no need to wait (already waited) */
1708 return 0; /* don't wait on the event thread. */
1710 wait_for_stop (ti
.ti_lid
);
1711 return 0; /* finished: next thread. */
1715 new_wait_thread_callback (threadinfo
*thread
, void *data
)
1717 /* don't wait on the event thread -- it's already stopped and waited.
1718 Ditto the main thread. */
1719 if (thread
->lid
!= event_pid
&&
1720 thread
->lid
!= main_prochandle
.pid
)
1722 wait_for_stop (thread
->lid
);
1728 * Wait for any thread to stop, by calling the underlying wait method.
1729 * The PID returned by the underlying target may be a kernel thread,
1730 * in which case we will want to convert it to the corresponding
1731 * user-space thread.
1735 thread_db_wait (int pid
, struct target_waitstatus
*ourstatus
)
1737 td_thrhandle_t thandle
;
1745 /* OK, we're about to wait for an event from the running inferior.
1746 Make sure we're ignoring the right signals. */
1748 check_all_signal_numbers (); /* see if magic signals changed. */
1753 /* FIXME: should I do the wait right here inline? */
1758 lwp
= get_lwp_from_thread_id (GET_THREAD (pid
));
1762 save_errno
= linux_child_wait (-1, &retpid
, &status
);
1763 store_waitstatus (ourstatus
, status
);
1765 /* Thread ID is irrelevant if the target process exited.
1766 FIXME: do I have any killing to do?
1767 Can I get this event mistakenly from a thread? */
1768 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
1771 /* OK, we got an event of interest.
1772 Go stop all threads and look for new ones.
1773 FIXME: maybe don't do this for the restart signal? Optimization... */
1776 /* If the last call to resume was for a specific thread, then we don't
1777 need to stop everyone else: they should already be stopped. */
1778 if (last_resume_step
== 0 || last_resume_pid
== -1)
1780 /* Main thread must be stopped before calling the iterator. */
1781 if (retpid
!= main_prochandle
.pid
)
1783 kill (main_prochandle
.pid
, SIGSTOP
);
1784 wait_for_stop (main_prochandle
.pid
);
1787 empty_threadlist ();
1788 /* Now stop everyone else, and attach any new threads you find. */
1789 p_td_ta_thr_iter (main_threadagent
,
1790 stop_or_attach_thread_callback
,
1793 TD_THR_LOWEST_PRIORITY
,
1795 TD_THR_ANY_USER_FLAGS
);
1797 /* Now go call wait on all the threads we've stopped:
1798 This allows us to absorb the SIGKILL event, and to make sure
1799 that the thread knows that it is stopped (Linux peculiarity). */
1801 threadlist_iter (new_wait_thread_callback
,
1807 /* Convert the kernel thread id to the corresponding thread id. */
1809 /* If the process layer does not furnish an lwp,
1810 then perhaps the returned pid IS the lwp... */
1811 if ((lwp
= GET_LWP (retpid
)) == 0)
1814 if ((ret
= p_td_ta_map_lwp2thr (main_threadagent
, lwp
, &thandle
)) != TD_OK
)
1815 return retpid
; /* LWP is not mapped onto a user-space thread. */
1817 if ((ret
= p_td_thr_validate (&thandle
)) != TD_OK
)
1818 return retpid
; /* LWP is not mapped onto a valid thread. */
1820 if ((ret
= p_td_thr_get_info (&thandle
, &ti
)) != TD_OK
)
1822 warning ("thread_db: thr_get_info failed ('%s')", thr_err_string (ret
));
1826 retpid
= BUILD_THREAD (ti
.ti_tid
, main_prochandle
.pid
);
1827 /* If this is a new user thread, notify GDB about it. */
1828 if (!in_thread_list (retpid
))
1830 printf_filtered ("[New %s]\n", target_pid_to_str (retpid
));
1831 add_thread (retpid
);
1835 /* Now detect if this is a thread creation/deletion event: */
1836 check_for_thread_event (ourstatus
, retpid
);
1842 * kill has to call the underlying kill.
1843 * FIXME: I'm not sure if it's necessary to check inferior_pid any more,
1844 * but we might need to fix inferior_pid up if it's a user thread.
1848 kill_thread_callback (td_thrhandle_t
*th
, void *data
)
1854 For Linux, threads may need to be waited. */
1855 if ((ret
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1857 warning ("kill_thread_callback: %s", thr_err_string (ret
));
1858 return -1; /* bail out, get_info failed. */
1861 if (ti
.ti_lid
!= main_prochandle
.pid
)
1863 kill (ti
.ti_lid
, SIGKILL
);
1869 static void thread_db_kill (void)
1875 For Linux, threads may need to be waited. */
1876 if (inferior_pid
!= 0)
1878 /* Go kill the children first. Save the main thread for last. */
1879 p_td_ta_thr_iter (main_threadagent
,
1880 kill_thread_callback
,
1883 TD_THR_LOWEST_PRIORITY
,
1885 TD_THR_ANY_USER_FLAGS
);
1887 /* Turn off thread_db event-reporting API *before* killing the
1888 main thread, since this operation requires child memory access.
1889 Can't move this into thread_db_unpush target because then
1890 detach would not work. */
1891 disable_thread_event_reporting (main_threadagent
);
1893 inferior_pid
= main_prochandle
.pid
;
1896 * Since both procfs_kill and ptrace_kill call target_mourn,
1897 * it should be sufficient for me to call one of them.
1898 * That will result in my mourn being called, which will both
1899 * unpush me and call the underlying mourn.
1901 target_beneath
->to_kill ();
1904 /* Wait for all threads. */
1905 /* FIXME: need a universal wait_for_signal func? */
1908 rpid
= waitpid (-1, &status
, __WCLONE
| WNOHANG
);
1910 while (rpid
> 0 || errno
== EINTR
);
1914 rpid
= waitpid (-1, &status
, WNOHANG
);
1916 while (rpid
> 0 || errno
== EINTR
);
1920 * Mourn has to remove us from the target stack,
1921 * and then call the underlying mourn.
1924 static void thread_db_mourn_inferior (void)
1926 thread_db_unpush_target ();
1927 target_mourn_inferior (); /* call the underlying mourn */
1931 * Detach has to remove us from the target stack,
1932 * and then call the underlying detach.
1934 * But first, it has to detach all the cloned threads!
1938 detach_thread_callback (td_thrhandle_t
*th
, void *data
)
1940 /* Called once per thread. */
1944 if ((ret
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1946 warning ("detach_thread_callback: %s", thr_err_string (ret
));
1947 return -1; /* bail out, get_info failed. */
1950 if (!in_thread_list (BUILD_THREAD (ti
.ti_tid
, main_prochandle
.pid
)))
1951 return 0; /* apparently we don't know this one. */
1953 /* Save main thread for last, or the iterator will fail! */
1954 if (ti
.ti_lid
!= main_prochandle
.pid
)
1956 struct cleanup
*old_chain
;
1959 /* Time to detach this thread.
1960 First disable thread_db event reporting for the thread. */
1961 if (p_td_thr_event_enable
&&
1962 (ret
= p_td_thr_event_enable (th
, off
)) != TD_OK
)
1964 warning ("detach_thread_callback: %s\n", thr_err_string (ret
));
1968 /* Now cancel any pending SIGTRAPS. FIXME! */
1970 /* Call underlying detach method. FIXME just detach it. */
1971 old_chain
= save_inferior_pid ();
1972 inferior_pid
= ti
.ti_lid
;
1973 detach (TARGET_SIGNAL_0
);
1974 do_cleanups (old_chain
);
1980 thread_db_detach (char *args
, int from_tty
)
1984 if ((ret
= p_td_ta_thr_iter (main_threadagent
,
1985 detach_thread_callback
,
1988 TD_THR_LOWEST_PRIORITY
,
1990 TD_THR_ANY_USER_FLAGS
))
1992 warning ("detach (thr_iter): %s", thr_err_string (ret
));
1994 /* Turn off thread_db event-reporting API
1995 (before detaching the main thread) */
1996 disable_thread_event_reporting (main_threadagent
);
1998 thread_db_unpush_target ();
2000 /* above call nullifies target_beneath, so don't use that! */
2001 inferior_pid
= PIDGET (inferior_pid
);
2002 target_detach (args
, from_tty
);
2007 * We never want to actually create the inferior!
2009 * If this is ever called, it means we were on the target stack
2010 * when the user said "run". But we don't want to be on the new
2011 * inferior's target stack until the thread_db / libthread
2012 * connection is ready to be made.
2014 * So, what shall we do?
2015 * Unpush ourselves from the stack, and then invoke
2016 * find_default_create_inferior, which will invoke the
2017 * appropriate process_stratum target to do the create.
2021 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
)
2023 thread_db_unpush_target ();
2024 find_default_create_inferior (exec_file
, allargs
, env
);
2028 * Thread_db target vector initializer.
2032 init_thread_db_ops (void)
2034 thread_db_ops
.to_shortname
= "multi-thread";
2035 thread_db_ops
.to_longname
= "multi-threaded child process.";
2036 thread_db_ops
.to_doc
= "Threads and pthreads support.";
2037 thread_db_ops
.to_files_info
= thread_db_files_info
;
2038 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
2039 thread_db_ops
.to_detach
= thread_db_detach
;
2040 thread_db_ops
.to_wait
= thread_db_wait
;
2041 thread_db_ops
.to_resume
= thread_db_resume
;
2042 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
2043 thread_db_ops
.to_kill
= thread_db_kill
;
2044 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
2045 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
2046 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
2047 thread_db_ops
.to_thread_alive
= thread_db_alive
;
2048 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
2049 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
2050 thread_db_ops
.to_stratum
= thread_stratum
;
2051 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
2052 thread_db_ops
.to_magic
= OPS_MAGIC
;
2054 #endif /* HAVE_STDINT_H */
2057 * Module constructor / initializer function.
2058 * If connection to thread_db dynamic library is successful,
2059 * then initialize this module's target vectors and the
2065 _initialize_thread_db (void)
2067 #ifdef HAVE_STDINT_H /* stub out entire module, leave initializer empty */
2068 if (init_thread_db_library ())
2070 init_thread_db_ops ();
2071 add_target (&thread_db_ops
);
2073 * Hook up to the new_objfile event.
2074 * If someone is already there, arrange for him to be called
2077 target_new_objfile_chain
= target_new_objfile_hook
;
2078 target_new_objfile_hook
= thread_db_new_objfile
;
2080 #endif /* HAVE_STDINT_H */