1 /* Multi-threaded debugging support for the thread_db interface,
2 used on operating systems such as Solaris and Linux.
3 Copyright 1999, 2000, 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 PIDGET0(PID) (((PID) & 0xffff))
131 #define PIDGET(PID) ((PIDGET0 (PID) == 0xffff) ? -1 : PIDGET0 (PID))
132 #define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
135 /* Macros for superimposing PID and TID into inferior_ptid. */
136 #define THREAD_FLAG 0x80000000
137 #define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
138 #define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
139 #define GET_LWP(PID) TIDGET (PID)
140 #define GET_THREAD(PID) TIDGET (PID)
141 #define BUILD_LWP(TID, PID) MERGEPID (PID, TID)
142 #define BUILD_THREAD(TID, PID) (MERGEPID (PID, TID) | THREAD_FLAG)
145 * target_beneath is a pointer to the target_ops underlying this one.
148 static struct target_ops *target_beneath;
152 * target vector defined in this module:
155 static struct target_ops thread_db_ops;
158 * Typedefs required to resolve differences between the thread_db
159 * and proc_service API defined on different versions of Solaris:
162 #if defined(PROC_SERVICE_IS_OLD)
163 typedef const struct ps_prochandle *gdb_ps_prochandle_t;
164 typedef char *gdb_ps_read_buf_t;
165 typedef char *gdb_ps_write_buf_t;
166 typedef int gdb_ps_size_t;
168 typedef struct ps_prochandle *gdb_ps_prochandle_t;
169 typedef void *gdb_ps_read_buf_t;
170 typedef const void *gdb_ps_write_buf_t;
171 typedef size_t gdb_ps_size_t;
175 * proc_service callback functions, called by thread_db.
179 ps_pstop (gdb_ps_prochandle_t ph) /* Process stop */
185 ps_pcontinue (gdb_ps_prochandle_t ph) /* Process continue */
191 ps_lstop (gdb_ps_prochandle_t ph, /* LWP stop */
198 ps_lcontinue (gdb_ps_prochandle_t ph, /* LWP continue */
205 ps_lgetxregsize (gdb_ps_prochandle_t ph, /* Get XREG size */
213 ps_lgetxregs (gdb_ps_prochandle_t ph, /* Get XREGS */
221 ps_lsetxregs (gdb_ps_prochandle_t ph, /* Set XREGS */
229 ps_plog (const char *fmt, ...)
233 va_start (args, fmt);
234 vfprintf_filtered (gdb_stderr, fmt, args);
237 /* Look up a symbol in GDB's global symbol table.
238 Return the symbol's address.
239 FIXME: it would be more correct to look up the symbol in the context
240 of the LD_OBJECT_NAME provided. However we're probably fairly safe
241 as long as there aren't name conflicts with other libraries. */
244 ps_pglobal_lookup (gdb_ps_prochandle_t ph,
245 const char *ld_object_name, /* the library name */
246 const char *ld_symbol_name, /* the symbol name */
247 paddr_t *ld_symbol_addr) /* return the symbol addr */
249 struct minimal_symbol *ms;
251 ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
256 *ld_symbol_addr = SYMBOL_VALUE_ADDRESS (ms);
261 /* Worker function for all memory reads and writes: */
262 static ps_err_e rw_common (const struct ps_prochandle *ph,
268 /* target_xfer_memory direction consts */
269 enum {PS_READ = 0, PS_WRITE = 1};
272 ps_pdread (gdb_ps_prochandle_t ph, /* read from data segment */
274 gdb_ps_read_buf_t buf,
277 return rw_common (ph, addr, buf, size, PS_READ);
281 ps_pdwrite (gdb_ps_prochandle_t ph, /* write to data segment */
283 gdb_ps_write_buf_t buf,
286 return rw_common (ph, addr, (char *) buf, size, PS_WRITE);
290 ps_ptread (gdb_ps_prochandle_t ph, /* read from text segment */
292 gdb_ps_read_buf_t buf,
295 return rw_common (ph, addr, buf, size, PS_READ);
299 ps_ptwrite (gdb_ps_prochandle_t ph, /* write to text segment */
301 gdb_ps_write_buf_t buf,
304 return rw_common (ph, addr, (char *) buf, size, PS_WRITE);
307 static struct cleanup *save_inferior_ptid (void);
308 static void restore_inferior_ptid (void *saved_pid);
309 static char *thr_err_string (td_err_e);
310 static char *thr_state_string (td_thr_state_e);
312 struct ps_prochandle main_prochandle;
313 td_thragent_t * main_threadagent;
316 * Common proc_service routine for reading and writing memory.
319 /* FIXME: once we've munged the inferior_ptid, why can't we
320 simply call target_read/write_memory and return? */
323 rw_common (const struct ps_prochandle *ph,
329 struct cleanup *old_chain = save_inferior_ptid ();
333 inferior_ptid = pid_to_ptid (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_ptid). */
359 ps_lgetregs (gdb_ps_prochandle_t ph, /* Get LWP general regs */
363 struct cleanup *old_chain = save_inferior_ptid ();
365 inferior_ptid = BUILD_LWP (lwpid, main_prochandle.pid);
366 current_target.to_fetch_registers (-1);
368 fill_gregset ((gdb_gregset_t *) 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_ptid ();
381 inferior_ptid = BUILD_LWP (lwpid, main_prochandle.pid);
382 supply_gregset ((gdb_gregset_t *) 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_ptid ();
395 inferior_ptid = 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_ptid ();
409 inferior_ptid = 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_ptid - Save inferior_ptid on the cleanup list
632 restore_inferior_ptid - Restore inferior_ptid from the cleanup list
636 struct cleanup *save_inferior_ptid (void);
637 void restore_inferior_ptid (void *saved_pid);
641 These two functions act in unison to restore inferior_ptid in
646 inferior_ptid 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_ptid gets restored (in case of errors),
649 you need to call save_inferior_ptid 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_ptid (void)
657 ptid_t *saved_ptid_ptr;
659 saved_ptid_ptr = xmalloc (sizeof (ptid_t));
660 *saved_ptid_ptr = inferior_ptid;
661 return make_cleanup (restore_inferior_ptid, saved_ptid_ptr);
665 restore_inferior_ptid (void *arg)
667 ptid_t *saved_ptid_ptr = arg;
668 inferior_ptid = *saved_ptid_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 = xrealloc (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 ((CORE_ADDR) notify.u.bptaddr);
925 /* Save it's location. */
926 thread_creation_bkpt_address = (CORE_ADDR) 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 ((CORE_ADDR) notify.u.bptaddr);
938 /* Save it's location. */
939 thread_death_bkpt_address = (CORE_ADDR) 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). */
976 thread_db_push_target (void)
978 /* Called ONLY from thread_db_new_objfile after td_ta_new call succeeds. */
980 /* Push this target vector */
981 push_target (&thread_db_ops);
982 /* Find the underlying process-layer target for calling later. */
983 target_beneath = find_target_beneath (&thread_db_ops);
985 /* Turn on thread_db event-reporting API. */
986 enable_thread_event_reporting (main_threadagent);
990 thread_db_unpush_target (void)
992 /* Must be called whenever we remove ourself from the target stack! */
995 target_beneath = NULL;
997 /* delete local list of threads */
999 /* Turn off the thread_db API. */
1000 p_td_ta_delete (main_threadagent);
1001 /* Unpush this target vector */
1002 unpush_target (&thread_db_ops);
1003 /* Reset linuxthreads module. */
1004 linuxthreads_discard_global_state ();
1008 * New objfile hook function:
1009 * Called for each new objfile (image, shared lib) in the target process.
1011 * The purpose of this function is to detect that the target process
1012 * is linked with the (appropriate) thread library. So every time a
1013 * new target shared library is detected, we will call td_ta_new.
1014 * If it succeeds, we know we have a multi-threaded target process
1015 * that we can debug using the thread_db API.
1019 * new_objfile function:
1021 * connected to target_new_objfile_hook, this function gets called
1022 * every time a new binary image is loaded.
1024 * At each call, we attempt to open the thread_db connection to the
1025 * child process. If it succeeds, we know we have a libthread process
1026 * and we can debug it with this target vector. Therefore we push
1027 * ourself onto the target stack.
1030 static void (*target_new_objfile_chain) (struct objfile *objfile);
1031 static int stop_or_attach_thread_callback (const td_thrhandle_t *th,
1033 static int wait_thread_callback (const td_thrhandle_t *th,
1037 thread_db_new_objfile (struct objfile *objfile)
1041 if (using_thread_db) /* libthread already detected, and */
1042 goto quit; /* thread target vector activated. */
1044 if (objfile == NULL)
1045 goto quit; /* un-interesting object file */
1047 /* Initialize our "main prochandle" with the main inferior pid. */
1048 main_prochandle.pid = PIDGET (inferior_ptid);
1050 /* Now attempt to open a thread_db connection to the
1051 thread library running in the child process. */
1052 ret = p_td_ta_new (&main_prochandle, &main_threadagent);
1055 warning ("Unexpected error initializing thread_db: %s",
1056 thr_err_string (ret));
1058 case TD_NOLIBTHREAD: /* expected: no libthread in child process (yet) */
1060 case TD_OK: /* libthread detected in child: we go live now! */
1061 thread_db_push_target ();
1062 event_pid = PIDGET (inferior_ptid); /* for resume */
1064 /* Now stop everyone else, and attach any new threads you find. */
1065 p_td_ta_thr_iter (main_threadagent,
1066 stop_or_attach_thread_callback,
1069 TD_THR_LOWEST_PRIORITY,
1071 TD_THR_ANY_USER_FLAGS);
1073 /* Now go call wait on all the threads you've stopped:
1074 This allows us to absorb the SIGKILL event, and to make sure
1075 that the thread knows that it is stopped (Linux peculiarity). */
1076 p_td_ta_thr_iter (main_threadagent,
1077 wait_thread_callback,
1080 TD_THR_LOWEST_PRIORITY,
1082 TD_THR_ANY_USER_FLAGS);
1087 if (target_new_objfile_chain)
1088 target_new_objfile_chain (objfile);
1096 thread_db_alive - test thread for "aliveness"
1100 static bool thread_db_alive (int pid);
1104 returns true if thread still active in inferior.
1109 thread_db_alive (ptid_t ptid)
1111 if (is_thread (ptid)) /* user-space (non-kernel) thread */
1115 int pid = GET_THREAD (ptid);
1117 if ((ret = p_td_ta_map_id2thr (main_threadagent, pid, &th)) != TD_OK)
1118 return 0; /* thread not found */
1119 if ((ret = p_td_thr_validate (&th)) != TD_OK)
1120 return 0; /* thread not valid */
1121 return 1; /* known thread: return true */
1123 else if (target_beneath->to_thread_alive)
1124 return target_beneath->to_thread_alive (ptid);
1126 return 0; /* default to "not alive" (shouldn't happen anyway) */
1130 * get_lwp_from_thread_handle
1133 static int /* lwpid_t or pid_t */
1134 get_lwp_from_thread_handle (td_thrhandle_t *th)
1139 if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
1140 error ("get_lwp_from_thread_handle: thr_get_info failed: %s",
1141 thr_err_string (ret));
1147 * get_lwp_from_thread_id
1150 static int /* lwpid_t or pid_t */
1151 get_lwp_from_thread_id (int tid /* thread_t? */)
1156 if ((ret = p_td_ta_map_id2thr (main_threadagent, tid, &th)) != TD_OK)
1157 error ("get_lwp_from_thread_id: map_id2thr failed: %s",
1158 thr_err_string (ret));
1160 return get_lwp_from_thread_handle (&th);
1164 * pid_to_str has to handle user-space threads.
1165 * If not a user-space thread, then pass the request on to the
1166 * underlying stratum if it can handle it: else call normal_pid_to_str.
1170 thread_db_pid_to_str (ptid_t ptid)
1172 static char buf[100];
1177 if (is_thread (ptid))
1179 if ((ret = p_td_ta_map_id2thr (main_threadagent,
1182 error ("thread_db: map_id2thr failed: %s", thr_err_string (ret));
1184 if ((ret = p_td_thr_get_info (&th, &ti)) != TD_OK)
1185 error ("thread_db: thr_get_info failed: %s", thr_err_string (ret));
1187 if (ti.ti_state == TD_THR_ACTIVE &&
1189 sprintf (buf, "Thread %ld (LWP %d)", ti.ti_tid, ti.ti_lid);
1191 sprintf (buf, "Thread %ld (%s)", ti.ti_tid,
1192 thr_state_string (ti.ti_state));
1194 else if (GET_LWP (ptid))
1195 sprintf (buf, "LWP %ld", GET_LWP (ptid));
1196 else return normal_pid_to_str (ptid);
1202 * thread_db target vector functions:
1206 thread_db_files_info (struct target_ops *tgt_vector)
1208 /* This function will be unnecessary in real life. */
1209 printf_filtered ("thread_db stratum:\n");
1210 target_beneath->to_files_info (tgt_vector);
1214 * xfer_memory has to munge the inferior_ptid before passing the call
1215 * down to the target layer.
1219 thread_db_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite,
1220 struct mem_attrib *attrib,
1221 struct target_ops *target)
1223 struct cleanup *old_chain;
1226 old_chain = save_inferior_ptid ();
1228 if (is_thread (inferior_ptid) ||
1229 !target_thread_alive (inferior_ptid))
1231 /* FIXME: use the LID/LWP, so that underlying process layer
1232 can read memory from specific threads? */
1233 inferior_ptid = pid_to_ptid (main_prochandle.pid);
1236 ret = target_beneath->to_xfer_memory (memaddr, myaddr, len,
1237 dowrite, attrib, target);
1238 do_cleanups (old_chain);
1243 * fetch_registers has to determine if inferior_ptid is a user-space thread.
1244 * If so, we use the thread_db API to get the registers.
1245 * And if not, we call the underlying process stratum.
1249 thread_db_fetch_registers (int regno)
1251 td_thrhandle_t thandle;
1252 gdb_prfpregset_t fpregset;
1253 prgregset_t gregset;
1257 if (!is_thread (inferior_ptid)) /* kernel thread */
1258 { /* pass the request on to the target underneath. */
1259 target_beneath->to_fetch_registers (regno);
1263 /* convert inferior_ptid into a td_thrhandle_t */
1265 if ((thread = GET_THREAD (inferior_ptid)) == 0)
1266 error ("fetch_registers: thread == 0");
1268 if ((ret = p_td_ta_map_id2thr (main_threadagent, thread, &thandle)) != TD_OK)
1269 error ("fetch_registers: td_ta_map_id2thr: %s", thr_err_string (ret));
1271 /* Get the integer regs:
1272 For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7,
1273 pc and sp are saved (by a thread context switch). */
1274 if ((ret = p_td_thr_getgregs (&thandle, gregset)) != TD_OK &&
1275 ret != TD_PARTIALREG)
1276 error ("fetch_registers: td_thr_getgregs %s", thr_err_string (ret));
1278 /* And, now the fp regs */
1279 if ((ret = p_td_thr_getfpregs (&thandle, &fpregset)) != TD_OK &&
1281 error ("fetch_registers: td_thr_getfpregs %s", thr_err_string (ret));
1283 /* Note that we must call supply_{g fp}regset *after* calling the td routines
1284 because the td routines call ps_lget* which affect the values stored in the
1287 supply_gregset ((gdb_gregset_t *) gregset);
1288 supply_fpregset (&fpregset);
1293 * store_registers has to determine if inferior_ptid is a user-space thread.
1294 * If so, we use the thread_db API to get the registers.
1295 * And if not, we call the underlying process stratum.
1299 thread_db_store_registers (int regno)
1301 td_thrhandle_t thandle;
1302 gdb_prfpregset_t fpregset;
1303 prgregset_t gregset;
1307 if (!is_thread (inferior_ptid)) /* Kernel thread: */
1308 { /* pass the request on to the underlying target vector. */
1309 target_beneath->to_store_registers (regno);
1313 /* convert inferior_ptid into a td_thrhandle_t */
1315 if ((thread = GET_THREAD (inferior_ptid)) == 0)
1316 error ("store_registers: thread == 0");
1318 if ((ret = p_td_ta_map_id2thr (main_threadagent, thread, &thandle)) != TD_OK)
1319 error ("store_registers: td_ta_map_id2thr %s", thr_err_string (ret));
1322 { /* Not writing all the regs */
1323 /* save new register value */
1324 /* MVS: I don't understand this... */
1325 char old_value[REGISTER_SIZE];
1327 memcpy (old_value, ®isters[REGISTER_BYTE (regno)], REGISTER_SIZE);
1329 if ((ret = p_td_thr_getgregs (&thandle, gregset)) != TD_OK)
1330 error ("store_registers: td_thr_getgregs %s", thr_err_string (ret));
1331 if ((ret = p_td_thr_getfpregs (&thandle, &fpregset)) != TD_OK)
1332 error ("store_registers: td_thr_getfpregs %s", thr_err_string (ret));
1334 /* restore new register value */
1335 memcpy (®isters[REGISTER_BYTE (regno)], old_value, REGISTER_SIZE);
1339 fill_gregset ((gdb_gregset_t *) gregset, regno);
1340 fill_fpregset (&fpregset, regno);
1342 if ((ret = p_td_thr_setgregs (&thandle, gregset)) != TD_OK)
1343 error ("store_registers: td_thr_setgregs %s", thr_err_string (ret));
1344 if ((ret = p_td_thr_setfpregs (&thandle, &fpregset)) != TD_OK &&
1346 error ("store_registers: td_thr_setfpregs %s", thr_err_string (ret));
1350 handle_new_thread (int tid, /* user thread id */
1351 int lid, /* kernel thread id */
1354 ptid_t gdb_ptid = BUILD_THREAD (tid, main_prochandle.pid);
1355 int wait_pid, wait_status;
1358 printf_filtered ("[New %s]\n", target_pid_to_str (gdb_ptid));
1359 add_thread (gdb_ptid);
1361 if (lid != main_prochandle.pid)
1363 attach_thread (lid);
1364 /* According to the Eric Paire model, we now have to send
1365 the restart signal to the new thread -- however, empirically,
1366 I do not find that to be necessary. */
1372 test_for_new_thread (int tid, int lid, int verbose)
1374 if (!in_thread_list (BUILD_THREAD (tid, main_prochandle.pid)))
1375 handle_new_thread (tid, lid, verbose);
1379 * Callback function that gets called once per USER thread
1380 * (i.e., not kernel) thread by td_ta_thr_iter.
1384 find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
1389 if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
1391 warning ("find_new_threads_callback: %s", thr_err_string (ret));
1392 return -1; /* bail out, get_info failed. */
1396 As things now stand, this should never detect a new thread.
1397 But if it does, we could be in trouble because we aren't calling
1398 wait_thread_callback for it. */
1399 test_for_new_thread (ti.ti_tid, ti.ti_lid, 0);
1404 * find_new_threads uses the thread_db iterator function to discover
1405 * user-space threads. Then if the underlying process stratum has a
1406 * find_new_threads method, we call that too.
1410 thread_db_find_new_threads (void)
1412 if (PIDGET (inferior_ptid) == -1) /* FIXME: still necessary? */
1414 printf_filtered ("No process.\n");
1417 p_td_ta_thr_iter (main_threadagent,
1418 find_new_threads_callback,
1421 TD_THR_LOWEST_PRIORITY,
1423 TD_THR_ANY_USER_FLAGS);
1424 if (target_beneath->to_find_new_threads)
1425 target_beneath->to_find_new_threads ();
1429 * Resume all threads, or resume a single thread.
1430 * If step is true, then single-step the appropriate thread
1431 * (or single-step inferior_ptid, but continue everyone else).
1432 * If signo is true, then send that signal to at least one thread.
1436 * This function is called once for each thread before resuming.
1437 * It sends continue (no step, and no signal) to each thread except
1438 * the main thread, and
1439 * the event thread (the one that stopped at a breakpoint etc.)
1441 * The event thread is handled separately so that it can be sent
1442 * the stepping and signal args with which target_resume was called.
1444 * The main thread is resumed last, so that the thread_db proc_service
1445 * callbacks will still work during the iterator function.
1449 resume_thread_callback (const td_thrhandle_t *th, void *data)
1454 if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
1456 warning ("resume_thread_callback: %s", thr_err_string (ret));
1457 return -1; /* bail out, get_info failed. */
1460 As things now stand, this should never detect a new thread.
1461 But if it does, we could be in trouble because we aren't calling
1462 wait_thread_callback for it. */
1463 test_for_new_thread (ti.ti_tid, ti.ti_lid, 1);
1465 if (ti.ti_lid != main_prochandle.pid &&
1466 ti.ti_lid != event_pid)
1468 /* Unconditionally continue the thread with no signal.
1469 Only the event thread will get a signal of any kind. */
1471 target_beneath->to_resume (pid_to_ptid (ti.ti_lid), 0, 0);
1477 new_resume_thread_callback (threadinfo *thread, void *data)
1479 if (thread->lid != event_pid &&
1480 thread->lid != main_prochandle.pid)
1482 /* Unconditionally continue the thread with no signal (for now). */
1484 target_beneath->to_resume (pid_to_ptid (thread->lid), 0, 0);
1489 static int last_resume_pid;
1490 static int last_resume_step;
1491 static int last_resume_signo;
1494 thread_db_resume (ptid_t ptid, int step, enum target_signal signo)
1496 last_resume_pid = PIDGET (ptid);
1497 last_resume_step = step;
1498 last_resume_signo = signo;
1500 /* resuming a specific pid? */
1501 if (PIDGET (ptid) != -1)
1503 if (is_thread (ptid))
1504 ptid = pid_to_ptid (get_lwp_from_thread_id (GET_THREAD (ptid)));
1505 else if (GET_LWP (ptid))
1506 ptid = pid_to_ptid (GET_LWP (ptid));
1509 /* Apparently the interpretation of 'pid' is dependent on 'step':
1510 If step is true, then a specific pid means 'step only this pid'.
1511 But if step is not true, then pid means 'continue ALL pids, but
1512 give the signal only to this one'. */
1513 if (PIDGET (ptid) != -1 && step)
1515 /* FIXME: is this gonna work in all circumstances? */
1516 target_beneath->to_resume (ptid, step, signo);
1520 /* 1) Continue all threads except the event thread and the main thread.
1521 2) resume the event thread with step and signo.
1522 3) If event thread != main thread, continue the main thread.
1524 Note: order of 2 and 3 may need to be reversed. */
1526 threadlist_iter (new_resume_thread_callback,
1530 /* now resume event thread, and if necessary also main thread. */
1533 target_beneath->to_resume (pid_to_ptid (event_pid), step, signo);
1535 if (event_pid != main_prochandle.pid)
1537 target_beneath->to_resume (pid_to_ptid (main_prochandle.pid), 0, 0);
1542 /* All new threads will be attached.
1543 All previously known threads will be stopped using kill (SIGKILL). */
1546 stop_or_attach_thread_callback (const td_thrhandle_t *th, void *data)
1553 if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
1555 warning ("stop_or_attach_thread_callback: %s", thr_err_string (ret));
1556 return -1; /* bail out, get_info failed. */
1559 /* First add it to our internal list.
1560 We build this list anew at every wait event. */
1561 insert_thread (ti.ti_tid, ti.ti_lid, ti.ti_state, ti.ti_type);
1562 /* Now: if we've already seen it, stop it, else add it and attach it. */
1563 gdb_ptid = BUILD_THREAD (ti.ti_tid, main_prochandle.pid);
1564 if (!in_thread_list (gdb_ptid)) /* new thread */
1566 handle_new_thread (ti.ti_tid, ti.ti_lid, 1);
1567 /* Enable thread events */
1568 if (p_td_thr_event_enable)
1569 if ((ret = p_td_thr_event_enable (th, on_off)) != TD_OK)
1570 warning ("stop_or_attach_thread: %s", thr_err_string (ret));
1572 else if (ti.ti_lid != event_pid &&
1573 ti.ti_lid != main_prochandle.pid)
1575 ret = (td_err_e) kill (ti.ti_lid, SIGSTOP);
1582 * Wait for signal N from pid PID.
1583 * If wait returns any other signals, put them back before returning.
1587 wait_for_stop (int pid)
1593 /* Array of wait/signal status */
1594 /* FIXME: wrong data structure, we need a queue.
1595 Realtime signals may be delivered more than once.
1596 And at that, we really can't handle them (see below). */
1598 static int wstatus [NSIG];
1599 #elif defined (_NSIG)
1600 static int wstatus [_NSIG];
1602 #error No definition for number of signals!
1605 /* clear wait/status list */
1606 memset (&wstatus, 0, sizeof (wstatus));
1608 /* Now look for SIGSTOP event on all threads except event thread. */
1611 if (pid == main_prochandle.pid)
1612 retpid = waitpid (pid, &status, 0);
1614 retpid = waitpid (pid, &status, __WCLONE);
1617 if (WSTOPSIG (status) == SIGSTOP)
1619 /* Got the SIGSTOP event we're looking for.
1620 Throw it away, and throw any other events back! */
1621 for (i = 0; i < sizeof(wstatus) / sizeof (wstatus[0]); i++)
1627 break; /* all done */
1632 /* Oops, got an event other than SIGSTOP.
1633 Save it, and throw it back after we find the SIGSTOP event. */
1635 /* FIXME (how?) This method is going to fail for realtime
1636 signals, which cannot be put back simply by using kill. */
1638 if (WIFEXITED (status))
1639 error ("Ack! Thread Exited event. What do I do now???");
1640 else if (WIFSTOPPED (status))
1641 signo = WSTOPSIG (status);
1643 signo = WTERMSIG (status);
1645 /* If a thread other than the event thread has hit a GDB
1646 breakpoint (as opposed to some random trap signal), then
1647 just arrange for it to hit it again later. Back up the
1648 PC if necessary. Don't forward the SIGTRAP signal to
1649 the thread. We will handle the current event, eventually
1650 we will resume all the threads, and this one will get
1651 it's breakpoint trap again.
1653 If we do not do this, then we run the risk that the user
1654 will delete or disable the breakpoint, but the thread will
1655 have already tripped on it. */
1657 if (retpid != event_pid &&
1659 breakpoint_inserted_here_p (read_pc_pid (pid_to_ptid (retpid)) -
1660 DECR_PC_AFTER_BREAK))
1662 /* Set the pc to before the trap and DO NOT re-send the signal */
1663 if (DECR_PC_AFTER_BREAK)
1664 write_pc_pid (read_pc_pid (pid_to_ptid (retpid))
1665 - DECR_PC_AFTER_BREAK,
1666 pid_to_ptid (retpid));
1669 /* Since SIGINT gets forwarded to the entire process group
1670 (in the case where ^C is typed at the tty / console),
1671 just ignore all SIGINTs from other than the event thread. */
1672 else if (retpid != event_pid && signo == SIGINT)
1673 { /* do nothing. Signal will disappear into oblivion! */
1677 else /* This is some random signal other than a breakpoint. */
1679 wstatus [signo] = 1;
1681 child_resume (pid_to_ptid (retpid), 0, TARGET_SIGNAL_0);
1685 } while (errno == 0 || errno == EINTR);
1689 * wait_thread_callback
1691 * Calls waitpid for each thread, repeatedly if necessary, until
1692 * SIGSTOP is returned. Afterward, if any other signals were returned
1693 * by waitpid, return them to the thread's pending queue by calling kill.
1697 wait_thread_callback (const td_thrhandle_t *th, void *data)
1702 if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
1704 warning ("wait_thread_callback: %s", thr_err_string (ret));
1705 return -1; /* bail out, get_info failed. */
1708 /* This callback to act on all threads except the event thread: */
1709 if (ti.ti_lid == event_pid || /* no need to wait (no sigstop) */
1710 ti.ti_lid == main_prochandle.pid) /* no need to wait (already waited) */
1711 return 0; /* don't wait on the event thread. */
1713 wait_for_stop (ti.ti_lid);
1714 return 0; /* finished: next thread. */
1718 new_wait_thread_callback (threadinfo *thread, void *data)
1720 /* don't wait on the event thread -- it's already stopped and waited.
1721 Ditto the main thread. */
1722 if (thread->lid != event_pid &&
1723 thread->lid != main_prochandle.pid)
1725 wait_for_stop (thread->lid);
1731 * Wait for any thread to stop, by calling the underlying wait method.
1732 * The PID returned by the underlying target may be a kernel thread,
1733 * in which case we will want to convert it to the corresponding
1734 * user-space thread.
1738 thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1740 td_thrhandle_t thandle;
1749 /* OK, we're about to wait for an event from the running inferior.
1750 Make sure we're ignoring the right signals. */
1752 check_all_signal_numbers (); /* see if magic signals changed. */
1757 /* FIXME: should I do the wait right here inline? */
1759 if (PIDGET (ptid) == -1)
1762 lwp = get_lwp_from_thread_id (GET_THREAD (ptid));
1766 save_errno = linux_child_wait (-1, &retpid, &status);
1767 store_waitstatus (ourstatus, status);
1769 /* Thread ID is irrelevant if the target process exited.
1770 FIXME: do I have any killing to do?
1771 Can I get this event mistakenly from a thread? */
1772 if (ourstatus->kind == TARGET_WAITKIND_EXITED)
1773 return pid_to_ptid (retpid);
1775 /* OK, we got an event of interest.
1776 Go stop all threads and look for new ones.
1777 FIXME: maybe don't do this for the restart signal? Optimization... */
1780 /* If the last call to resume was for a specific thread, then we don't
1781 need to stop everyone else: they should already be stopped. */
1782 if (last_resume_step == 0 || last_resume_pid == -1)
1784 /* Main thread must be stopped before calling the iterator. */
1785 if (retpid != main_prochandle.pid)
1787 kill (main_prochandle.pid, SIGSTOP);
1788 wait_for_stop (main_prochandle.pid);
1791 empty_threadlist ();
1792 /* Now stop everyone else, and attach any new threads you find. */
1793 p_td_ta_thr_iter (main_threadagent,
1794 stop_or_attach_thread_callback,
1797 TD_THR_LOWEST_PRIORITY,
1799 TD_THR_ANY_USER_FLAGS);
1801 /* Now go call wait on all the threads we've stopped:
1802 This allows us to absorb the SIGKILL event, and to make sure
1803 that the thread knows that it is stopped (Linux peculiarity). */
1805 threadlist_iter (new_wait_thread_callback,
1811 /* Convert the kernel thread id to the corresponding thread id. */
1813 /* If the process layer does not furnish an lwp,
1814 then perhaps the returned pid IS the lwp... */
1815 #if 0 /* Always true (if it'd compile...) */
1816 if ((lwp = GET_LWP (pid_to_ptid (retpid))) == 0)
1820 if ((ret = p_td_ta_map_lwp2thr (main_threadagent, lwp, &thandle)) != TD_OK)
1821 return pid_to_ptid (retpid); /* LWP is not mapped onto a user-space thread. */
1823 if ((ret = p_td_thr_validate (&thandle)) != TD_OK)
1824 return pid_to_ptid (retpid); /* LWP is not mapped onto a valid thread. */
1826 if ((ret = p_td_thr_get_info (&thandle, &ti)) != TD_OK)
1828 warning ("thread_db: thr_get_info failed ('%s')", thr_err_string (ret));
1829 return pid_to_ptid (retpid);
1832 retptid = BUILD_THREAD (ti.ti_tid, main_prochandle.pid);
1833 /* If this is a new user thread, notify GDB about it. */
1834 if (!in_thread_list (retptid))
1836 printf_filtered ("[New %s]\n", target_pid_to_str (retptid));
1837 add_thread (retptid);
1841 /* Now detect if this is a thread creation/deletion event: */
1842 check_for_thread_event (ourstatus, retpid);
1848 * kill has to call the underlying kill.
1849 * FIXME: I'm not sure if it's necessary to check inferior_ptid any more,
1850 * but we might need to fix inferior_ptid up if it's a user thread.
1854 kill_thread_callback (const td_thrhandle_t *th, void *data)
1860 For Linux, threads may need to be waited. */
1861 if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
1863 warning ("kill_thread_callback: %s", thr_err_string (ret));
1864 return -1; /* bail out, get_info failed. */
1867 if (ti.ti_lid != main_prochandle.pid)
1869 kill (ti.ti_lid, SIGKILL);
1875 static void thread_db_kill (void)
1881 For Linux, threads may need to be waited. */
1882 if (! ptid_equal (inferior_ptid, null_ptid))
1884 /* Go kill the children first. Save the main thread for last. */
1885 p_td_ta_thr_iter (main_threadagent,
1886 kill_thread_callback,
1889 TD_THR_LOWEST_PRIORITY,
1891 TD_THR_ANY_USER_FLAGS);
1893 /* Turn off thread_db event-reporting API *before* killing the
1894 main thread, since this operation requires child memory access.
1895 Can't move this into thread_db_unpush target because then
1896 detach would not work. */
1897 disable_thread_event_reporting (main_threadagent);
1899 inferior_ptid = pid_to_ptid (main_prochandle.pid);
1902 * Since both procfs_kill and ptrace_kill call target_mourn,
1903 * it should be sufficient for me to call one of them.
1904 * That will result in my mourn being called, which will both
1905 * unpush me and call the underlying mourn.
1907 target_beneath->to_kill ();
1910 /* Wait for all threads. */
1911 /* FIXME: need a universal wait_for_signal func? */
1914 rpid = waitpid (-1, &status, __WCLONE | WNOHANG);
1916 while (rpid > 0 || errno == EINTR);
1920 rpid = waitpid (-1, &status, WNOHANG);
1922 while (rpid > 0 || errno == EINTR);
1926 * Mourn has to remove us from the target stack,
1927 * and then call the underlying mourn.
1930 static void thread_db_mourn_inferior (void)
1932 thread_db_unpush_target ();
1933 target_mourn_inferior (); /* call the underlying mourn */
1937 * Detach has to remove us from the target stack,
1938 * and then call the underlying detach.
1940 * But first, it has to detach all the cloned threads!
1944 detach_thread_callback (const td_thrhandle_t *th, void *data)
1946 /* Called once per thread. */
1950 if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
1952 warning ("detach_thread_callback: %s", thr_err_string (ret));
1953 return -1; /* bail out, get_info failed. */
1956 if (!in_thread_list (BUILD_THREAD (ti.ti_tid, main_prochandle.pid)))
1957 return 0; /* apparently we don't know this one. */
1959 /* Save main thread for last, or the iterator will fail! */
1960 if (ti.ti_lid != main_prochandle.pid)
1962 struct cleanup *old_chain;
1965 /* Time to detach this thread.
1966 First disable thread_db event reporting for the thread. */
1967 if (p_td_thr_event_enable &&
1968 (ret = p_td_thr_event_enable (th, off)) != TD_OK)
1970 warning ("detach_thread_callback: %s\n", thr_err_string (ret));
1974 /* Now cancel any pending SIGTRAPS. FIXME! */
1976 /* Call underlying detach method. FIXME just detach it. */
1977 old_chain = save_inferior_ptid ();
1978 inferior_ptid = pid_to_ptid (ti.ti_lid);
1979 detach (TARGET_SIGNAL_0);
1980 do_cleanups (old_chain);
1986 thread_db_detach (char *args, int from_tty)
1990 if ((ret = p_td_ta_thr_iter (main_threadagent,
1991 detach_thread_callback,
1994 TD_THR_LOWEST_PRIORITY,
1996 TD_THR_ANY_USER_FLAGS))
1998 warning ("detach (thr_iter): %s", thr_err_string (ret));
2000 /* Turn off thread_db event-reporting API
2001 (before detaching the main thread) */
2002 disable_thread_event_reporting (main_threadagent);
2004 thread_db_unpush_target ();
2006 /* above call nullifies target_beneath, so don't use that! */
2007 inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
2008 target_detach (args, from_tty);
2013 * We never want to actually create the inferior!
2015 * If this is ever called, it means we were on the target stack
2016 * when the user said "run". But we don't want to be on the new
2017 * inferior's target stack until the thread_db / libthread
2018 * connection is ready to be made.
2020 * So, what shall we do?
2021 * Unpush ourselves from the stack, and then invoke
2022 * find_default_create_inferior, which will invoke the
2023 * appropriate process_stratum target to do the create.
2027 thread_db_create_inferior (char *exec_file, char *allargs, char **env)
2029 thread_db_unpush_target ();
2030 find_default_create_inferior (exec_file, allargs, env);
2034 * Thread_db target vector initializer.
2038 init_thread_db_ops (void)
2040 thread_db_ops.to_shortname = "multi-thread";
2041 thread_db_ops.to_longname = "multi-threaded child process.";
2042 thread_db_ops.to_doc = "Threads and pthreads support.";
2043 thread_db_ops.to_files_info = thread_db_files_info;
2044 thread_db_ops.to_create_inferior = thread_db_create_inferior;
2045 thread_db_ops.to_detach = thread_db_detach;
2046 thread_db_ops.to_wait = thread_db_wait;
2047 thread_db_ops.to_resume = thread_db_resume;
2048 thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
2049 thread_db_ops.to_kill = thread_db_kill;
2050 thread_db_ops.to_xfer_memory = thread_db_xfer_memory;
2051 thread_db_ops.to_fetch_registers = thread_db_fetch_registers;
2052 thread_db_ops.to_store_registers = thread_db_store_registers;
2053 thread_db_ops.to_thread_alive = thread_db_alive;
2054 thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
2055 thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
2056 thread_db_ops.to_stratum = thread_stratum;
2057 thread_db_ops.to_has_thread_control = tc_schedlock;
2058 thread_db_ops.to_magic = OPS_MAGIC;
2060 #endif /* HAVE_STDINT_H */
2063 * Module constructor / initializer function.
2064 * If connection to thread_db dynamic library is successful,
2065 * then initialize this module's target vectors and the
2071 _initialize_thread_db (void)
2073 #ifdef HAVE_STDINT_H /* stub out entire module, leave initializer empty */
2074 if (init_thread_db_library ())
2076 init_thread_db_ops ();
2077 add_target (&thread_db_ops);
2079 * Hook up to the new_objfile event.
2080 * If someone is already there, arrange for him to be called
2083 target_new_objfile_chain = target_new_objfile_hook;
2084 target_new_objfile_hook = thread_db_new_objfile;
2086 #endif /* HAVE_STDINT_H */