1/* Thread management interface, for the remote server for GDB.
2   Copyright (C) 2002, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
3
4   Contributed by MontaVista Software.
5
6   This file is part of GDB.
7
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 3 of the License, or
11   (at your option) any later version.
12
13   This program is distributed in the hope that it will be useful,
14   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   GNU General Public License for more details.
17
18   You should have received a copy of the GNU General Public License
19   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21#include "server.h"
22
23#include "linux-low.h"
24
25extern int debug_threads;
26
27#ifdef HAVE_THREAD_DB_H
28#include <thread_db.h>
29#endif
30
31#include "gdb_proc_service.h"
32
33#include <stdint.h>
34
35/* Structure that identifies the child process for the
36   <proc_service.h> interface.  */
37static struct ps_prochandle proc_handle;
38
39/* Connection to the libthread_db library.  */
40static td_thragent_t *thread_agent;
41
42static int find_first_thread (void);
43static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data);
44
45static char *
46thread_db_err_str (td_err_e err)
47{
48  static char buf[64];
49
50  switch (err)
51    {
52    case TD_OK:
53      return "generic 'call succeeded'";
54    case TD_ERR:
55      return "generic error";
56    case TD_NOTHR:
57      return "no thread to satisfy query";
58    case TD_NOSV:
59      return "no sync handle to satisfy query";
60    case TD_NOLWP:
61      return "no LWP to satisfy query";
62    case TD_BADPH:
63      return "invalid process handle";
64    case TD_BADTH:
65      return "invalid thread handle";
66    case TD_BADSH:
67      return "invalid synchronization handle";
68    case TD_BADTA:
69      return "invalid thread agent";
70    case TD_BADKEY:
71      return "invalid key";
72    case TD_NOMSG:
73      return "no event message for getmsg";
74    case TD_NOFPREGS:
75      return "FPU register set not available";
76    case TD_NOLIBTHREAD:
77      return "application not linked with libthread";
78    case TD_NOEVENT:
79      return "requested event is not supported";
80    case TD_NOCAPAB:
81      return "capability not available";
82    case TD_DBERR:
83      return "debugger service failed";
84    case TD_NOAPLIC:
85      return "operation not applicable to";
86    case TD_NOTSD:
87      return "no thread-specific data for this thread";
88    case TD_MALLOC:
89      return "malloc failed";
90    case TD_PARTIALREG:
91      return "only part of register set was written/read";
92    case TD_NOXREGS:
93      return "X register set not available for this thread";
94#ifdef HAVE_TD_VERSION
95    case TD_VERSION:
96      return "version mismatch between libthread_db and libpthread";
97#endif
98    default:
99      snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
100      return buf;
101    }
102}
103
104#if 0
105static char *
106thread_db_state_str (td_thr_state_e state)
107{
108  static char buf[64];
109
110  switch (state)
111    {
112    case TD_THR_STOPPED:
113      return "stopped by debugger";
114    case TD_THR_RUN:
115      return "runnable";
116    case TD_THR_ACTIVE:
117      return "active";
118    case TD_THR_ZOMBIE:
119      return "zombie";
120    case TD_THR_SLEEP:
121      return "sleeping";
122    case TD_THR_STOPPED_ASLEEP:
123      return "stopped by debugger AND blocked";
124    default:
125      snprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
126      return buf;
127    }
128}
129#endif
130
131static void
132thread_db_create_event (CORE_ADDR where)
133{
134  td_event_msg_t msg;
135  td_err_e err;
136  struct process_info *process;
137
138  if (debug_threads)
139    fprintf (stderr, "Thread creation event.\n");
140
141  /* FIXME: This assumes we don't get another event.
142     In the LinuxThreads implementation, this is safe,
143     because all events come from the manager thread
144     (except for its own creation, of course).  */
145  err = td_ta_event_getmsg (thread_agent, &msg);
146  if (err != TD_OK)
147    fprintf (stderr, "thread getmsg err: %s\n",
148	     thread_db_err_str (err));
149
150  /* If we do not know about the main thread yet, this would be a good time to
151     find it.  We need to do this to pick up the main thread before any newly
152     created threads.  */
153  process = get_thread_process (current_inferior);
154  if (process->thread_known == 0)
155    find_first_thread ();
156
157  /* msg.event == TD_EVENT_CREATE */
158
159  find_new_threads_callback (msg.th_p, NULL);
160}
161
162#if 0
163static void
164thread_db_death_event (CORE_ADDR where)
165{
166  if (debug_threads)
167    fprintf (stderr, "Thread death event.\n");
168}
169#endif
170
171static int
172thread_db_enable_reporting ()
173{
174  td_thr_events_t events;
175  td_notify_t notify;
176  td_err_e err;
177
178  /* Set the process wide mask saying which events we're interested in.  */
179  td_event_emptyset (&events);
180  td_event_addset (&events, TD_CREATE);
181
182#if 0
183  /* This is reported to be broken in glibc 2.1.3.  A different approach
184     will be necessary to support that.  */
185  td_event_addset (&events, TD_DEATH);
186#endif
187
188  err = td_ta_set_event (thread_agent, &events);
189  if (err != TD_OK)
190    {
191      warning ("Unable to set global thread event mask: %s",
192               thread_db_err_str (err));
193      return 0;
194    }
195
196  /* Get address for thread creation breakpoint.  */
197  err = td_ta_event_addr (thread_agent, TD_CREATE, &notify);
198  if (err != TD_OK)
199    {
200      warning ("Unable to get location for thread creation breakpoint: %s",
201	       thread_db_err_str (err));
202      return 0;
203    }
204  set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
205		     thread_db_create_event);
206
207#if 0
208  /* Don't concern ourselves with reported thread deaths, only
209     with actual thread deaths (via wait).  */
210
211  /* Get address for thread death breakpoint.  */
212  err = td_ta_event_addr (thread_agent, TD_DEATH, &notify);
213  if (err != TD_OK)
214    {
215      warning ("Unable to get location for thread death breakpoint: %s",
216	       thread_db_err_str (err));
217      return;
218    }
219  set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
220		     thread_db_death_event);
221#endif
222
223  return 1;
224}
225
226static int
227find_first_thread (void)
228{
229  td_thrhandle_t th;
230  td_thrinfo_t ti;
231  td_err_e err;
232  struct thread_info *inferior;
233  struct process_info *process;
234
235  inferior = (struct thread_info *) all_threads.head;
236  process = get_thread_process (inferior);
237  if (process->thread_known)
238    return 1;
239
240  /* Get information about the one thread we know we have.  */
241  err = td_ta_map_lwp2thr (thread_agent, process->lwpid, &th);
242  if (err != TD_OK)
243    error ("Cannot get first thread handle: %s", thread_db_err_str (err));
244
245  err = td_thr_get_info (&th, &ti);
246  if (err != TD_OK)
247    error ("Cannot get first thread info: %s", thread_db_err_str (err));
248
249  if (debug_threads)
250    fprintf (stderr, "Found first thread %ld (LWP %d)\n",
251	     ti.ti_tid, ti.ti_lid);
252
253  if (process->lwpid != ti.ti_lid)
254    fatal ("PID mismatch!  Expected %ld, got %ld",
255	   (long) process->lwpid, (long) ti.ti_lid);
256
257  /* If the new thread ID is zero, a final thread ID will be available
258     later.  Do not enable thread debugging yet.  */
259  if (ti.ti_tid == 0)
260    {
261      err = td_thr_event_enable (&th, 1);
262      if (err != TD_OK)
263	error ("Cannot enable thread event reporting for %d: %s",
264	       ti.ti_lid, thread_db_err_str (err));
265      return 0;
266    }
267
268  /* Switch to indexing the threads list by TID.  */
269  change_inferior_id (&all_threads, ti.ti_tid);
270
271  new_thread_notify (ti.ti_tid);
272
273  process->tid = ti.ti_tid;
274  process->lwpid = ti.ti_lid;
275  process->thread_known = 1;
276  process->th = th;
277
278  err = td_thr_event_enable (&th, 1);
279  if (err != TD_OK)
280    error ("Cannot enable thread event reporting for %d: %s",
281           ti.ti_lid, thread_db_err_str (err));
282
283  return 1;
284}
285
286static void
287maybe_attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p)
288{
289  td_err_e err;
290  struct thread_info *inferior;
291  struct process_info *process;
292
293  inferior = (struct thread_info *) find_inferior_id (&all_threads,
294						      ti_p->ti_tid);
295  if (inferior != NULL)
296    return;
297
298  if (debug_threads)
299    fprintf (stderr, "Attaching to thread %ld (LWP %d)\n",
300	     ti_p->ti_tid, ti_p->ti_lid);
301  linux_attach_lwp (ti_p->ti_lid, ti_p->ti_tid);
302  inferior = (struct thread_info *) find_inferior_id (&all_threads,
303						      ti_p->ti_tid);
304  if (inferior == NULL)
305    {
306      warning ("Could not attach to thread %ld (LWP %d)\n",
307	       ti_p->ti_tid, ti_p->ti_lid);
308      return;
309    }
310
311  process = inferior_target_data (inferior);
312
313  new_thread_notify (ti_p->ti_tid);
314
315  process->tid = ti_p->ti_tid;
316  process->lwpid = ti_p->ti_lid;
317
318  process->thread_known = 1;
319  process->th = *th_p;
320  err = td_thr_event_enable (th_p, 1);
321  if (err != TD_OK)
322    error ("Cannot enable thread event reporting for %d: %s",
323           ti_p->ti_lid, thread_db_err_str (err));
324}
325
326static int
327find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
328{
329  td_thrinfo_t ti;
330  td_err_e err;
331
332  err = td_thr_get_info (th_p, &ti);
333  if (err != TD_OK)
334    error ("Cannot get thread info: %s", thread_db_err_str (err));
335
336  /* Check for zombies.  */
337  if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
338    return 0;
339
340  maybe_attach_thread (th_p, &ti);
341
342  return 0;
343}
344
345static void
346thread_db_find_new_threads (void)
347{
348  td_err_e err;
349
350  /* This function is only called when we first initialize thread_db.
351     First locate the initial thread.  If it is not ready for
352     debugging yet, then stop.  */
353  if (find_first_thread () == 0)
354    return;
355
356  /* Iterate over all user-space threads to discover new threads.  */
357  err = td_ta_thr_iter (thread_agent, find_new_threads_callback, NULL,
358			TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
359			TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
360  if (err != TD_OK)
361    error ("Cannot find new threads: %s", thread_db_err_str (err));
362}
363
364/* Cache all future symbols that thread_db might request.  We can not
365   request symbols at arbitrary states in the remote protocol, only
366   when the client tells us that new symbols are available.  So when
367   we load the thread library, make sure to check the entire list.  */
368
369static void
370thread_db_look_up_symbols (void)
371{
372  const char **sym_list = td_symbol_list ();
373  CORE_ADDR unused;
374
375  for (sym_list = td_symbol_list (); *sym_list; sym_list++)
376    look_up_one_symbol (*sym_list, &unused);
377}
378
379int
380thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
381			   CORE_ADDR load_module, CORE_ADDR *address)
382{
383#if HAVE_TD_THR_TLS_GET_ADDR
384  psaddr_t addr;
385  td_err_e err;
386  struct process_info *process;
387
388  process = get_thread_process (thread);
389  if (!process->thread_known)
390    find_first_thread ();
391  if (!process->thread_known)
392    return TD_NOTHR;
393
394  /* Note the cast through uintptr_t: this interface only works if
395     a target address fits in a psaddr_t, which is a host pointer.
396     So a 32-bit debugger can not access 64-bit TLS through this.  */
397  err = td_thr_tls_get_addr (&process->th, (psaddr_t) (uintptr_t) load_module,
398			     offset, &addr);
399  if (err == TD_OK)
400    {
401      *address = (CORE_ADDR) (uintptr_t) addr;
402      return 0;
403    }
404  else
405    return err;
406#else
407  return -1;
408#endif
409}
410
411int
412thread_db_init ()
413{
414  int err;
415
416  /* FIXME drow/2004-10-16: This is the "overall process ID", which
417     GNU/Linux calls tgid, "thread group ID".  When we support
418     attaching to threads, the original thread may not be the correct
419     thread.  We would have to get the process ID from /proc for NPTL.
420     For LinuxThreads we could do something similar: follow the chain
421     of parent processes until we find the highest one we're attached
422     to, and use its tgid.
423
424     This isn't the only place in gdbserver that assumes that the first
425     process in the list is the thread group leader.  */
426  proc_handle.pid = ((struct inferior_list_entry *)current_inferior)->id;
427
428  /* Allow new symbol lookups.  */
429  all_symbols_looked_up = 0;
430
431  err = td_ta_new (&proc_handle, &thread_agent);
432  switch (err)
433    {
434    case TD_NOLIBTHREAD:
435      /* No thread library was detected.  */
436      return 0;
437
438    case TD_OK:
439      /* The thread library was detected.  */
440
441      if (thread_db_enable_reporting () == 0)
442	return 0;
443      thread_db_find_new_threads ();
444      thread_db_look_up_symbols ();
445      all_symbols_looked_up = 1;
446      return 1;
447
448    default:
449      warning ("error initializing thread_db library: %s",
450	       thread_db_err_str (err));
451    }
452
453  return 0;
454}
455