1 /* Thread management interface, for the remote server for GDB.
2 Copyright (C) 2002, 2004, 2005, 2006
3 Free Software Foundation, Inc.
5 Contributed by MontaVista Software.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
26 #include "linux-low.h"
28 extern int debug_threads;
30 #ifdef HAVE_THREAD_DB_H
31 #include <thread_db.h>
34 #include "gdb_proc_service.h"
36 /* Structure that identifies the child process for the
37 <proc_service.h> interface. */
38 static struct ps_prochandle proc_handle;
40 /* Connection to the libthread_db library. */
41 static td_thragent_t *thread_agent;
43 static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data);
46 thread_db_err_str (td_err_e err)
53 return "generic 'call succeeded'";
55 return "generic error";
57 return "no thread to satisfy query";
59 return "no sync handle to satisfy query";
61 return "no LWP to satisfy query";
63 return "invalid process handle";
65 return "invalid thread handle";
67 return "invalid synchronization handle";
69 return "invalid thread agent";
73 return "no event message for getmsg";
75 return "FPU register set not available";
77 return "application not linked with libthread";
79 return "requested event is not supported";
81 return "capability not available";
83 return "debugger service failed";
85 return "operation not applicable to";
87 return "no thread-specific data for this thread";
89 return "malloc failed";
91 return "only part of register set was written/read";
93 return "X register set not available for this thread";
94 #ifdef HAVE_TD_VERSION
96 return "version mismatch between libthread_db and libpthread";
99 snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
106 thread_db_state_str (td_thr_state_e state)
113 return "stopped by debugger";
122 case TD_THR_STOPPED_ASLEEP:
123 return "stopped by debugger AND blocked";
125 snprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
132 thread_db_create_event (CORE_ADDR where)
136 struct inferior_linux_data *tdata;
139 fprintf (stderr, "Thread creation event.\n");
141 tdata = inferior_target_data (current_inferior);
143 /* FIXME: This assumes we don't get another event.
144 In the LinuxThreads implementation, this is safe,
145 because all events come from the manager thread
146 (except for its own creation, of course). */
147 err = td_ta_event_getmsg (thread_agent, &msg);
149 fprintf (stderr, "thread getmsg err: %s\n",
150 thread_db_err_str (err));
152 /* msg.event == TD_EVENT_CREATE */
154 find_new_threads_callback (msg.th_p, NULL);
159 thread_db_death_event (CORE_ADDR where)
162 fprintf (stderr, "Thread death event.\n");
167 thread_db_enable_reporting ()
169 td_thr_events_t events;
173 /* Set the process wide mask saying which events we're interested in. */
174 td_event_emptyset (&events);
175 td_event_addset (&events, TD_CREATE);
178 /* This is reported to be broken in glibc 2.1.3. A different approach
179 will be necessary to support that. */
180 td_event_addset (&events, TD_DEATH);
183 err = td_ta_set_event (thread_agent, &events);
186 warning ("Unable to set global thread event mask: %s",
187 thread_db_err_str (err));
191 /* Get address for thread creation breakpoint. */
192 err = td_ta_event_addr (thread_agent, TD_CREATE, ¬ify);
195 warning ("Unable to get location for thread creation breakpoint: %s",
196 thread_db_err_str (err));
199 set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
200 thread_db_create_event);
203 /* Don't concern ourselves with reported thread deaths, only
204 with actual thread deaths (via wait). */
206 /* Get address for thread death breakpoint. */
207 err = td_ta_event_addr (thread_agent, TD_DEATH, ¬ify);
210 warning ("Unable to get location for thread death breakpoint: %s",
211 thread_db_err_str (err));
214 set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
215 thread_db_death_event);
222 maybe_attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p)
225 struct thread_info *inferior;
226 struct process_info *process;
228 /* If we are attaching to our first thread, things are a little
230 if (all_threads.head == all_threads.tail)
232 inferior = (struct thread_info *) all_threads.head;
233 process = get_thread_process (inferior);
234 if (process->thread_known == 0)
236 /* Switch to indexing the threads list by TID. */
237 change_inferior_id (&all_threads, ti_p->ti_tid);
242 inferior = (struct thread_info *) find_inferior_id (&all_threads,
244 if (inferior != NULL)
248 fprintf (stderr, "Attaching to thread %ld (LWP %d)\n",
249 ti_p->ti_tid, ti_p->ti_lid);
250 linux_attach_lwp (ti_p->ti_lid, ti_p->ti_tid);
251 inferior = (struct thread_info *) find_inferior_id (&all_threads,
253 if (inferior == NULL)
255 warning ("Could not attach to thread %ld (LWP %d)\n",
256 ti_p->ti_tid, ti_p->ti_lid);
260 process = inferior_target_data (inferior);
263 new_thread_notify (ti_p->ti_tid);
265 process->tid = ti_p->ti_tid;
266 process->lwpid = ti_p->ti_lid;
268 process->thread_known = 1;
269 err = td_thr_event_enable (th_p, 1);
271 error ("Cannot enable thread event reporting for %d: %s",
272 ti_p->ti_lid, thread_db_err_str (err));
276 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
281 err = td_thr_get_info (th_p, &ti);
283 error ("Cannot get thread info: %s", thread_db_err_str (err));
285 /* Check for zombies. */
286 if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
289 maybe_attach_thread (th_p, &ti);
295 thread_db_find_new_threads (void)
299 /* Iterate over all user-space threads to discover new threads. */
300 err = td_ta_thr_iter (thread_agent, find_new_threads_callback, NULL,
301 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
302 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
304 error ("Cannot find new threads: %s", thread_db_err_str (err));
307 /* Cache all future symbols that thread_db might request. We can not
308 request symbols at arbitrary states in the remote protocol, only
309 when the client tells us that new symbols are available. So when
310 we load the thread library, make sure to check the entire list. */
313 thread_db_look_up_symbols (void)
315 const char **sym_list = td_symbol_list ();
318 for (sym_list = td_symbol_list (); *sym_list; sym_list++)
319 look_up_one_symbol (*sym_list, &unused);
327 /* FIXME drow/2004-10-16: This is the "overall process ID", which
328 GNU/Linux calls tgid, "thread group ID". When we support
329 attaching to threads, the original thread may not be the correct
330 thread. We would have to get the process ID from /proc for NPTL.
331 For LinuxThreads we could do something similar: follow the chain
332 of parent processes until we find the highest one we're attached
333 to, and use its tgid.
335 This isn't the only place in gdbserver that assumes that the first
336 process in the list is the thread group leader. */
337 proc_handle.pid = ((struct inferior_list_entry *)current_inferior)->id;
339 err = td_ta_new (&proc_handle, &thread_agent);
343 /* No thread library was detected. */
347 /* The thread library was detected. */
349 if (thread_db_enable_reporting () == 0)
351 thread_db_find_new_threads ();
352 thread_db_look_up_symbols ();
356 warning ("error initializing thread_db library: %s",
357 thread_db_err_str (err));