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"
38 /* Structure that identifies the child process for the
39 <proc_service.h> interface. */
40 static struct ps_prochandle proc_handle;
42 /* Connection to the libthread_db library. */
43 static td_thragent_t *thread_agent;
45 static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data);
48 thread_db_err_str (td_err_e err)
55 return "generic 'call succeeded'";
57 return "generic error";
59 return "no thread to satisfy query";
61 return "no sync handle to satisfy query";
63 return "no LWP to satisfy query";
65 return "invalid process handle";
67 return "invalid thread handle";
69 return "invalid synchronization handle";
71 return "invalid thread agent";
75 return "no event message for getmsg";
77 return "FPU register set not available";
79 return "application not linked with libthread";
81 return "requested event is not supported";
83 return "capability not available";
85 return "debugger service failed";
87 return "operation not applicable to";
89 return "no thread-specific data for this thread";
91 return "malloc failed";
93 return "only part of register set was written/read";
95 return "X register set not available for this thread";
96 #ifdef HAVE_TD_VERSION
98 return "version mismatch between libthread_db and libpthread";
101 snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
108 thread_db_state_str (td_thr_state_e state)
115 return "stopped by debugger";
124 case TD_THR_STOPPED_ASLEEP:
125 return "stopped by debugger AND blocked";
127 snprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
134 thread_db_create_event (CORE_ADDR where)
138 struct inferior_linux_data *tdata;
141 fprintf (stderr, "Thread creation event.\n");
143 tdata = inferior_target_data (current_inferior);
145 /* FIXME: This assumes we don't get another event.
146 In the LinuxThreads implementation, this is safe,
147 because all events come from the manager thread
148 (except for its own creation, of course). */
149 err = td_ta_event_getmsg (thread_agent, &msg);
151 fprintf (stderr, "thread getmsg err: %s\n",
152 thread_db_err_str (err));
154 /* msg.event == TD_EVENT_CREATE */
156 find_new_threads_callback (msg.th_p, NULL);
161 thread_db_death_event (CORE_ADDR where)
164 fprintf (stderr, "Thread death event.\n");
169 thread_db_enable_reporting ()
171 td_thr_events_t events;
175 /* Set the process wide mask saying which events we're interested in. */
176 td_event_emptyset (&events);
177 td_event_addset (&events, TD_CREATE);
180 /* This is reported to be broken in glibc 2.1.3. A different approach
181 will be necessary to support that. */
182 td_event_addset (&events, TD_DEATH);
185 err = td_ta_set_event (thread_agent, &events);
188 warning ("Unable to set global thread event mask: %s",
189 thread_db_err_str (err));
193 /* Get address for thread creation breakpoint. */
194 err = td_ta_event_addr (thread_agent, TD_CREATE, ¬ify);
197 warning ("Unable to get location for thread creation breakpoint: %s",
198 thread_db_err_str (err));
201 set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
202 thread_db_create_event);
205 /* Don't concern ourselves with reported thread deaths, only
206 with actual thread deaths (via wait). */
208 /* Get address for thread death breakpoint. */
209 err = td_ta_event_addr (thread_agent, TD_DEATH, ¬ify);
212 warning ("Unable to get location for thread death breakpoint: %s",
213 thread_db_err_str (err));
216 set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
217 thread_db_death_event);
224 maybe_attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p)
227 struct thread_info *inferior;
228 struct process_info *process;
230 /* If we are attaching to our first thread, things are a little
232 if (all_threads.head == all_threads.tail)
234 inferior = (struct thread_info *) all_threads.head;
235 process = get_thread_process (inferior);
236 if (process->thread_known == 0)
238 /* Switch to indexing the threads list by TID. */
239 change_inferior_id (&all_threads, ti_p->ti_tid);
244 inferior = (struct thread_info *) find_inferior_id (&all_threads,
246 if (inferior != NULL)
250 fprintf (stderr, "Attaching to thread %ld (LWP %d)\n",
251 ti_p->ti_tid, ti_p->ti_lid);
252 linux_attach_lwp (ti_p->ti_lid, ti_p->ti_tid);
253 inferior = (struct thread_info *) find_inferior_id (&all_threads,
255 if (inferior == NULL)
257 warning ("Could not attach to thread %ld (LWP %d)\n",
258 ti_p->ti_tid, ti_p->ti_lid);
262 process = inferior_target_data (inferior);
265 new_thread_notify (ti_p->ti_tid);
267 process->tid = ti_p->ti_tid;
268 process->lwpid = ti_p->ti_lid;
270 process->thread_known = 1;
272 err = td_thr_event_enable (th_p, 1);
274 error ("Cannot enable thread event reporting for %d: %s",
275 ti_p->ti_lid, thread_db_err_str (err));
279 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
284 err = td_thr_get_info (th_p, &ti);
286 error ("Cannot get thread info: %s", thread_db_err_str (err));
288 /* Check for zombies. */
289 if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
292 maybe_attach_thread (th_p, &ti);
298 thread_db_find_new_threads (void)
302 /* Iterate over all user-space threads to discover new threads. */
303 err = td_ta_thr_iter (thread_agent, find_new_threads_callback, NULL,
304 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
305 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
307 error ("Cannot find new threads: %s", thread_db_err_str (err));
310 /* Cache all future symbols that thread_db might request. We can not
311 request symbols at arbitrary states in the remote protocol, only
312 when the client tells us that new symbols are available. So when
313 we load the thread library, make sure to check the entire list. */
316 thread_db_look_up_symbols (void)
318 const char **sym_list = td_symbol_list ();
321 for (sym_list = td_symbol_list (); *sym_list; sym_list++)
322 look_up_one_symbol (*sym_list, &unused);
326 thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
327 CORE_ADDR load_module, CORE_ADDR *address)
329 #if HAVE_TD_THR_TLS_GET_ADDR
332 struct process_info *process;
334 process = get_thread_process (thread);
335 if (!process->thread_known)
338 /* Note the cast through uintptr_t: this interface only works if
339 a target address fits in a psaddr_t, which is a host pointer.
340 So a 32-bit debugger can not access 64-bit TLS through this. */
341 err = td_thr_tls_get_addr (&process->th, (psaddr_t) (uintptr_t) load_module,
345 *address = (CORE_ADDR) (uintptr_t) addr;
360 /* FIXME drow/2004-10-16: This is the "overall process ID", which
361 GNU/Linux calls tgid, "thread group ID". When we support
362 attaching to threads, the original thread may not be the correct
363 thread. We would have to get the process ID from /proc for NPTL.
364 For LinuxThreads we could do something similar: follow the chain
365 of parent processes until we find the highest one we're attached
366 to, and use its tgid.
368 This isn't the only place in gdbserver that assumes that the first
369 process in the list is the thread group leader. */
370 proc_handle.pid = ((struct inferior_list_entry *)current_inferior)->id;
372 /* Allow new symbol lookups. */
373 all_symbols_looked_up = 0;
375 err = td_ta_new (&proc_handle, &thread_agent);
379 /* No thread library was detected. */
383 /* The thread library was detected. */
385 if (thread_db_enable_reporting () == 0)
387 thread_db_find_new_threads ();
388 thread_db_look_up_symbols ();
389 all_symbols_looked_up = 1;
393 warning ("error initializing thread_db library: %s",
394 thread_db_err_str (err));