more add_target removals
[external/binutils.git] / gdb / sol-thread.c
1 /* Solaris threads debugging interface.
2
3    Copyright (C) 1996-2013 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
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 3 of the License, or
10    (at your option) any later version.
11
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.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 /* This module implements a sort of half target that sits between the
21    machine-independent parts of GDB and the /proc interface (procfs.c)
22    to provide access to the Solaris user-mode thread implementation.
23
24    Solaris threads are true user-mode threads, which are invoked via
25    the thr_* and pthread_* (native and POSIX respectivly) interfaces.
26    These are mostly implemented in user-space, with all thread context
27    kept in various structures that live in the user's heap.  These
28    should not be confused with lightweight processes (LWPs), which are
29    implemented by the kernel, and scheduled without explicit
30    intervention by the process.
31
32    Just to confuse things a little, Solaris threads (both native and
33    POSIX) are actually implemented using LWPs.  In general, there are
34    going to be more threads than LWPs.  There is no fixed
35    correspondence between a thread and an LWP.  When a thread wants to
36    run, it gets scheduled onto the first available LWP and can
37    therefore migrate from one LWP to another as time goes on.  A
38    sleeping thread may not be associated with an LWP at all!
39
40    To make it possible to mess with threads, Sun provides a library
41    called libthread_db.so.1 (not to be confused with
42    libthread_db.so.0, which doesn't have a published interface).  This
43    interface has an upper part, which it provides, and a lower part
44    which we provide.  The upper part consists of the td_* routines,
45    which allow us to find all the threads, query their state, etc...
46    The lower part consists of all of the ps_*, which are used by the
47    td_* routines to read/write memory, manipulate LWPs, lookup
48    symbols, etc...  The ps_* routines actually do most of their work
49    by calling functions in procfs.c.  */
50
51 #include "defs.h"
52 #include <thread.h>
53 #include <proc_service.h>
54 #include <thread_db.h>
55 #include "gdbthread.h"
56 #include "target.h"
57 #include "inferior.h"
58 #include <fcntl.h>
59 #include "gdb_stat.h"
60 #include <dlfcn.h>
61 #include "gdbcmd.h"
62 #include "gdbcore.h"
63 #include "regcache.h"
64 #include "solib.h"
65 #include "symfile.h"
66 #include "observer.h"
67 #include "gdb_string.h"
68 #include "procfs.h"
69
70 struct target_ops sol_thread_ops;
71
72 /* Prototypes for supply_gregset etc.  */
73 #include "gregset.h"
74
75 /* This struct is defined by us, but mainly used for the proc_service
76    interface.  We don't have much use for it, except as a handy place
77    to get a real PID for memory accesses.  */
78
79 struct ps_prochandle
80 {
81   ptid_t ptid;
82 };
83
84 struct string_map
85 {
86   int num;
87   char *str;
88 };
89
90 static struct ps_prochandle main_ph;
91 static td_thragent_t *main_ta;
92 static int sol_thread_active = 0;
93
94 static void init_sol_thread_ops (void);
95
96 /* Default definitions: These must be defined in tm.h if they are to
97    be shared with a process module such as procfs.  */
98
99 #define GET_PID(ptid)           ptid_get_pid (ptid)
100 #define GET_LWP(ptid)           ptid_get_lwp (ptid)
101 #define GET_THREAD(ptid)        ptid_get_tid (ptid)
102
103 #define is_lwp(ptid)            (GET_LWP (ptid) != 0)
104 #define is_thread(ptid)         (GET_THREAD (ptid) != 0)
105
106 #define BUILD_LWP(lwp, pid)     ptid_build (pid, lwp, 0)
107 #define BUILD_THREAD(tid, pid)  ptid_build (pid, 0, tid)
108
109 /* Pointers to routines from libthread_db resolved by dlopen().  */
110
111 static void (*p_td_log)(const int on_off);
112 static td_err_e (*p_td_ta_new)(const struct ps_prochandle *ph_p,
113                                td_thragent_t **ta_pp);
114 static td_err_e (*p_td_ta_delete)(td_thragent_t *ta_p);
115 static td_err_e (*p_td_init)(void);
116 static td_err_e (*p_td_ta_get_ph)(const td_thragent_t *ta_p,
117                                   struct ps_prochandle **ph_pp);
118 static td_err_e (*p_td_ta_get_nthreads)(const td_thragent_t *ta_p,
119                                         int *nthread_p);
120 static td_err_e (*p_td_ta_tsd_iter)(const td_thragent_t *ta_p,
121                                     td_key_iter_f *cb, void *cbdata_p);
122 static td_err_e (*p_td_ta_thr_iter)(const td_thragent_t *ta_p,
123                                     td_thr_iter_f *cb, void *cbdata_p,
124                                     td_thr_state_e state, int ti_pri,
125                                     sigset_t *ti_sigmask_p,
126                                     unsigned ti_user_flags);
127 static td_err_e (*p_td_thr_validate)(const td_thrhandle_t *th_p);
128 static td_err_e (*p_td_thr_tsd)(const td_thrhandle_t * th_p,
129                                 const thread_key_t key, void **data_pp);
130 static td_err_e (*p_td_thr_get_info)(const td_thrhandle_t *th_p,
131                                      td_thrinfo_t *ti_p);
132 static td_err_e (*p_td_thr_getfpregs)(const td_thrhandle_t *th_p,
133                                       prfpregset_t *fpregset);
134 static td_err_e (*p_td_thr_getxregsize)(const td_thrhandle_t *th_p,
135                                         int *xregsize);
136 static td_err_e (*p_td_thr_getxregs)(const td_thrhandle_t *th_p,
137                                      const caddr_t xregset);
138 static td_err_e (*p_td_thr_sigsetmask)(const td_thrhandle_t *th_p,
139                                        const sigset_t ti_sigmask);
140 static td_err_e (*p_td_thr_setprio)(const td_thrhandle_t *th_p,
141                                     const int ti_pri);
142 static td_err_e (*p_td_thr_setsigpending)(const td_thrhandle_t *th_p,
143                                           const uchar_t ti_pending_flag,
144                                           const sigset_t ti_pending);
145 static td_err_e (*p_td_thr_setfpregs)(const td_thrhandle_t *th_p,
146                                       const prfpregset_t *fpregset);
147 static td_err_e (*p_td_thr_setxregs)(const td_thrhandle_t *th_p,
148                                      const caddr_t xregset);
149 static td_err_e (*p_td_ta_map_id2thr)(const td_thragent_t *ta_p,
150                                       thread_t tid,
151                                       td_thrhandle_t *th_p);
152 static td_err_e (*p_td_ta_map_lwp2thr)(const td_thragent_t *ta_p,
153                                        lwpid_t lwpid,
154                                        td_thrhandle_t *th_p);
155 static td_err_e (*p_td_thr_getgregs)(const td_thrhandle_t *th_p,
156                                      prgregset_t regset);
157 static td_err_e (*p_td_thr_setgregs)(const td_thrhandle_t *th_p,
158                                      const prgregset_t regset);
159 \f
160
161 /* Return the libthread_db error string associated with ERRCODE.  If
162    ERRCODE is unknown, return an appropriate message.  */
163
164 static char *
165 td_err_string (td_err_e errcode)
166 {
167   static struct string_map td_err_table[] =
168   {
169     { TD_OK, "generic \"call succeeded\"" },
170     { TD_ERR, "generic error." },
171     { TD_NOTHR, "no thread can be found to satisfy query" },
172     { TD_NOSV, "no synch. variable can be found to satisfy query" },
173     { TD_NOLWP, "no lwp can be found to satisfy query" },
174     { TD_BADPH, "invalid process handle" },
175     { TD_BADTH, "invalid thread handle" },
176     { TD_BADSH, "invalid synchronization handle" },
177     { TD_BADTA, "invalid thread agent" },
178     { TD_BADKEY, "invalid key" },
179     { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" },
180     { TD_NOFPREGS, "FPU register set not available for given thread" },
181     { TD_NOLIBTHREAD, "application not linked with libthread" },
182     { TD_NOEVENT, "requested event is not supported" },
183     { TD_NOCAPAB, "capability not available" },
184     { TD_DBERR, "Debugger service failed" },
185     { TD_NOAPLIC, "Operation not applicable to" },
186     { TD_NOTSD, "No thread specific data for this thread" },
187     { TD_MALLOC, "Malloc failed" },
188     { TD_PARTIALREG, "Only part of register set was written/read" },
189     { TD_NOXREGS, "X register set not available for given thread" }
190   };
191   const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
192   int i;
193   static char buf[50];
194
195   for (i = 0; i < td_err_size; i++)
196     if (td_err_table[i].num == errcode)
197       return td_err_table[i].str;
198
199   xsnprintf (buf, sizeof (buf), "Unknown libthread_db error code: %d",
200              errcode);
201
202   return buf;
203 }
204
205 /* Return the libthread_db state string assicoated with STATECODE.
206    If STATECODE is unknown, return an appropriate message.  */
207
208 static char *
209 td_state_string (td_thr_state_e statecode)
210 {
211   static struct string_map td_thr_state_table[] =
212   {
213     { TD_THR_ANY_STATE, "any state" },
214     { TD_THR_UNKNOWN, "unknown" },
215     { TD_THR_STOPPED, "stopped" },
216     { TD_THR_RUN, "run" },
217     { TD_THR_ACTIVE, "active" },
218     { TD_THR_ZOMBIE, "zombie" },
219     { TD_THR_SLEEP, "sleep" },
220     { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
221   };
222   const int td_thr_state_table_size =
223     sizeof td_thr_state_table / sizeof (struct string_map);
224   int i;
225   static char buf[50];
226
227   for (i = 0; i < td_thr_state_table_size; i++)
228     if (td_thr_state_table[i].num == statecode)
229       return td_thr_state_table[i].str;
230
231   xsnprintf (buf, sizeof (buf), "Unknown libthread_db state code: %d",
232              statecode);
233
234   return buf;
235 }
236 \f
237
238 /* Convert a POSIX or Solaris thread ID into a LWP ID.  If THREAD_ID
239    doesn't exist, that's an error.  If it's an inactive thread, return
240    DEFAULT_LWP.
241
242    NOTE: This function probably shouldn't call error().  */
243
244 static ptid_t
245 thread_to_lwp (ptid_t thread_id, int default_lwp)
246 {
247   td_thrinfo_t ti;
248   td_thrhandle_t th;
249   td_err_e val;
250
251   if (is_lwp (thread_id))
252     return thread_id;           /* It's already an LWP ID.  */
253
254   /* It's a thread.  Convert to LWP.  */
255
256   val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th);
257   if (val == TD_NOTHR)
258     return pid_to_ptid (-1);    /* Thread must have terminated.  */
259   else if (val != TD_OK)
260     error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
261
262   val = p_td_thr_get_info (&th, &ti);
263   if (val == TD_NOTHR)
264     return pid_to_ptid (-1);    /* Thread must have terminated.  */
265   else if (val != TD_OK)
266     error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
267
268   if (ti.ti_state != TD_THR_ACTIVE)
269     {
270       if (default_lwp != -1)
271         return pid_to_ptid (default_lwp);
272       error (_("thread_to_lwp: thread state not active: %s"),
273              td_state_string (ti.ti_state));
274     }
275
276   return BUILD_LWP (ti.ti_lid, PIDGET (thread_id));
277 }
278
279 /* Convert an LWP ID into a POSIX or Solaris thread ID.  If LWP_ID
280    doesn't exists, that's an error.
281
282    NOTE: This function probably shouldn't call error().  */
283
284 static ptid_t
285 lwp_to_thread (ptid_t lwp)
286 {
287   td_thrinfo_t ti;
288   td_thrhandle_t th;
289   td_err_e val;
290
291   if (is_thread (lwp))
292     return lwp;                 /* It's already a thread ID.  */
293
294   /* It's an LWP.  Convert it to a thread ID.  */
295
296   if (!target_thread_alive (lwp))
297     return pid_to_ptid (-1);    /* Must be a defunct LPW.  */
298
299   val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);
300   if (val == TD_NOTHR)
301     return pid_to_ptid (-1);    /* Thread must have terminated.  */
302   else if (val != TD_OK)
303     error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
304
305   val = p_td_thr_validate (&th);
306   if (val == TD_NOTHR)
307     return lwp;                 /* Unknown to libthread; just return LPW,  */
308   else if (val != TD_OK)
309     error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
310
311   val = p_td_thr_get_info (&th, &ti);
312   if (val == TD_NOTHR)
313     return pid_to_ptid (-1);    /* Thread must have terminated.  */
314   else if (val != TD_OK)
315     error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
316
317   return BUILD_THREAD (ti.ti_tid, PIDGET (lwp));
318 }
319 \f
320
321 /* Most target vector functions from here on actually just pass
322    through to the layer beneath, as they don't need to do anything
323    specific for threads.  */
324
325 /* Take a program previously attached to and detaches it.  The program
326    resumes execution and will no longer stop on signals, etc.  We'd
327    better not have left any breakpoints in the program or it'll die
328    when it hits one.  For this to work, it may be necessary for the
329    process to have been previously attached.  It *might* work if the
330    program was started via the normal ptrace (PTRACE_TRACEME).  */
331
332 static void
333 sol_thread_detach (struct target_ops *ops, char *args, int from_tty)
334 {
335   struct target_ops *beneath = find_target_beneath (ops);
336
337   sol_thread_active = 0;
338   inferior_ptid = pid_to_ptid (PIDGET (main_ph.ptid));
339   unpush_target (ops);
340   beneath->to_detach (beneath, args, from_tty);
341 }
342
343 /* Resume execution of process PTID.  If STEP is nozero, then just
344    single step it.  If SIGNAL is nonzero, restart it with that signal
345    activated.  We may have to convert PTID from a thread ID to an LWP
346    ID for procfs.  */
347
348 static void
349 sol_thread_resume (struct target_ops *ops,
350                    ptid_t ptid, int step, enum gdb_signal signo)
351 {
352   struct cleanup *old_chain;
353   struct target_ops *beneath = find_target_beneath (ops);
354
355   old_chain = save_inferior_ptid ();
356
357   inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
358   if (PIDGET (inferior_ptid) == -1)
359     inferior_ptid = procfs_first_available ();
360
361   if (PIDGET (ptid) != -1)
362     {
363       ptid_t save_ptid = ptid;
364
365       ptid = thread_to_lwp (ptid, -2);
366       if (PIDGET (ptid) == -2)          /* Inactive thread.  */
367         error (_("This version of Solaris can't start inactive threads."));
368       if (info_verbose && PIDGET (ptid) == -1)
369         warning (_("Specified thread %ld seems to have terminated"),
370                  GET_THREAD (save_ptid));
371     }
372
373   beneath->to_resume (beneath, ptid, step, signo);
374
375   do_cleanups (old_chain);
376 }
377
378 /* Wait for any threads to stop.  We may have to convert PTID from a
379    thread ID to an LWP ID, and vice versa on the way out.  */
380
381 static ptid_t
382 sol_thread_wait (struct target_ops *ops,
383                  ptid_t ptid, struct target_waitstatus *ourstatus, int options)
384 {
385   ptid_t rtnval;
386   ptid_t save_ptid;
387   struct target_ops *beneath = find_target_beneath (ops);
388   struct cleanup *old_chain;
389
390   save_ptid = inferior_ptid;
391   old_chain = save_inferior_ptid ();
392
393   inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
394   if (PIDGET (inferior_ptid) == -1)
395     inferior_ptid = procfs_first_available ();
396
397   if (PIDGET (ptid) != -1)
398     {
399       ptid_t save_ptid = ptid;
400
401       ptid = thread_to_lwp (ptid, -2);
402       if (PIDGET (ptid) == -2)          /* Inactive thread.  */
403         error (_("This version of Solaris can't start inactive threads."));
404       if (info_verbose && PIDGET (ptid) == -1)
405         warning (_("Specified thread %ld seems to have terminated"),
406                  GET_THREAD (save_ptid));
407     }
408
409   rtnval = beneath->to_wait (beneath, ptid, ourstatus, options);
410
411   if (ourstatus->kind != TARGET_WAITKIND_EXITED)
412     {
413       /* Map the LWP of interest back to the appropriate thread ID.  */
414       rtnval = lwp_to_thread (rtnval);
415       if (PIDGET (rtnval) == -1)
416         rtnval = save_ptid;
417
418       /* See if we have a new thread.  */
419       if (is_thread (rtnval)
420           && !ptid_equal (rtnval, save_ptid)
421           && (!in_thread_list (rtnval)
422               || is_exited (rtnval)))
423         add_thread (rtnval);
424     }
425
426   /* During process initialization, we may get here without the thread
427      package being initialized, since that can only happen after we've
428      found the shared libs.  */
429
430   do_cleanups (old_chain);
431
432   return rtnval;
433 }
434
435 static void
436 sol_thread_fetch_registers (struct target_ops *ops,
437                             struct regcache *regcache, int regnum)
438 {
439   thread_t thread;
440   td_thrhandle_t thandle;
441   td_err_e val;
442   prgregset_t gregset;
443   prfpregset_t fpregset;
444   gdb_gregset_t *gregset_p = &gregset;
445   gdb_fpregset_t *fpregset_p = &fpregset;
446   struct target_ops *beneath = find_target_beneath (ops);
447
448   if (!is_thread (inferior_ptid))
449     {
450       /* It's an LWP; pass the request on to the layer beneath.  */
451       beneath->to_fetch_registers (beneath, regcache, regnum);
452       return;
453     }
454
455   /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t.  */
456   thread = GET_THREAD (inferior_ptid);
457   if (thread == 0)
458     error (_("sol_thread_fetch_registers: thread == 0"));
459
460   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
461   if (val != TD_OK)
462     error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
463            td_err_string (val));
464
465   /* Get the general-purpose registers.  */
466
467   val = p_td_thr_getgregs (&thandle, gregset);
468   if (val != TD_OK && val != TD_PARTIALREG)
469     error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
470            td_err_string (val));
471
472   /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
473      and %sp are saved (by a thread context switch).  */
474
475   /* And, now the floating-point registers.  */
476
477   val = p_td_thr_getfpregs (&thandle, &fpregset);
478   if (val != TD_OK && val != TD_NOFPREGS)
479     error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
480            td_err_string (val));
481
482   /* Note that we must call supply_gregset and supply_fpregset *after*
483      calling the td routines because the td routines call ps_lget*
484      which affect the values stored in the registers array.  */
485
486   supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);
487   supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
488 }
489
490 static void
491 sol_thread_store_registers (struct target_ops *ops,
492                             struct regcache *regcache, int regnum)
493 {
494   thread_t thread;
495   td_thrhandle_t thandle;
496   td_err_e val;
497   prgregset_t gregset;
498   prfpregset_t fpregset;
499
500   if (!is_thread (inferior_ptid))
501     {
502       struct target_ops *beneath = find_target_beneath (ops);
503
504       /* It's an LWP; pass the request on to the layer beneath.  */
505       beneath->to_store_registers (beneath, regcache, regnum);
506       return;
507     }
508
509   /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t.  */
510   thread = GET_THREAD (inferior_ptid);
511
512   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
513   if (val != TD_OK)
514     error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
515            td_err_string (val));
516
517   if (regnum != -1)
518     {
519       /* Not writing all the registers.  */
520       char old_value[MAX_REGISTER_SIZE];
521
522       /* Save new register value.  */
523       regcache_raw_collect (regcache, regnum, old_value);
524
525       val = p_td_thr_getgregs (&thandle, gregset);
526       if (val != TD_OK)
527         error (_("sol_thread_store_registers: td_thr_getgregs %s"),
528                td_err_string (val));
529       val = p_td_thr_getfpregs (&thandle, &fpregset);
530       if (val != TD_OK)
531         error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
532                td_err_string (val));
533
534       /* Restore new register value.  */
535       regcache_raw_supply (regcache, regnum, old_value);
536     }
537
538   fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
539   fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
540
541   val = p_td_thr_setgregs (&thandle, gregset);
542   if (val != TD_OK)
543     error (_("sol_thread_store_registers: td_thr_setgregs %s"),
544            td_err_string (val));
545   val = p_td_thr_setfpregs (&thandle, &fpregset);
546   if (val != TD_OK)
547     error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
548            td_err_string (val));
549 }
550
551 /* Perform partial transfers on OBJECT.  See target_read_partial and
552    target_write_partial for details of each variant.  One, and only
553    one, of readbuf or writebuf must be non-NULL.  */
554
555 static LONGEST
556 sol_thread_xfer_partial (struct target_ops *ops, enum target_object object,
557                           const char *annex, gdb_byte *readbuf,
558                           const gdb_byte *writebuf,
559                          ULONGEST offset, LONGEST len)
560 {
561   int retval;
562   struct cleanup *old_chain;
563   struct target_ops *beneath = find_target_beneath (ops);
564
565   old_chain = save_inferior_ptid ();
566
567   if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
568     {
569       /* It's either a thread or an LWP that isn't alive.  Any live
570          LWP will do so use the first available.
571
572          NOTE: We don't need to call switch_to_thread; we're just
573          reading memory.  */
574       inferior_ptid = procfs_first_available ();
575     }
576
577   retval = beneath->to_xfer_partial (beneath, object, annex,
578                                      readbuf, writebuf, offset, len);
579
580   do_cleanups (old_chain);
581
582   return retval;
583 }
584
585 static void
586 check_for_thread_db (void)
587 {
588   td_err_e err;
589   ptid_t ptid;
590
591   /* Do nothing if we couldn't load libthread_db.so.1.  */
592   if (p_td_ta_new == NULL)
593     return;
594
595   if (sol_thread_active)
596     /* Nothing to do.  The thread library was already detected and the
597        target vector was already activated.  */
598     return;
599
600   /* Now, initialize libthread_db.  This needs to be done after the
601      shared libraries are located because it needs information from
602      the user's thread library.  */
603
604   err = p_td_init ();
605   if (err != TD_OK)
606     {
607       warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err));
608       return;
609     }
610
611   /* Now attempt to open a connection to the thread library.  */
612   err = p_td_ta_new (&main_ph, &main_ta);
613   switch (err)
614     {
615     case TD_NOLIBTHREAD:
616       /* No thread library was detected.  */
617       break;
618
619     case TD_OK:
620       printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
621
622       /* The thread library was detected.  Activate the sol_thread target.  */
623       push_target (&sol_thread_ops);
624       sol_thread_active = 1;
625
626       main_ph.ptid = inferior_ptid; /* Save for xfer_memory.  */
627       ptid = lwp_to_thread (inferior_ptid);
628       if (PIDGET (ptid) != -1)
629         inferior_ptid = ptid;
630
631       target_find_new_threads ();
632       break;
633
634     default:
635       warning (_("Cannot initialize thread debugging library: %s"),
636                td_err_string (err));
637       break;
638     }
639 }
640
641 /* This routine is called whenever a new symbol table is read in, or
642    when all symbol tables are removed.  libthread_db can only be
643    initialized when it finds the right variables in libthread.so.
644    Since it's a shared library, those variables don't show up until
645    the library gets mapped and the symbol table is read in.  */
646
647 static void
648 sol_thread_new_objfile (struct objfile *objfile)
649 {
650   if (objfile != NULL)
651     check_for_thread_db ();
652 }
653
654 /* Clean up after the inferior dies.  */
655
656 static void
657 sol_thread_mourn_inferior (struct target_ops *ops)
658 {
659   struct target_ops *beneath = find_target_beneath (ops);
660
661   sol_thread_active = 0;
662
663   unpush_target (ops);
664
665   beneath->to_mourn_inferior (beneath);
666 }
667
668 /* Return true if PTID is still active in the inferior.  */
669
670 static int
671 sol_thread_alive (struct target_ops *ops, ptid_t ptid)
672 {
673   if (is_thread (ptid))
674     {
675       /* It's a (user-level) thread.  */
676       td_err_e val;
677       td_thrhandle_t th;
678       int pid;
679
680       pid = GET_THREAD (ptid);
681       if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
682         return 0;               /* Thread not found.  */
683       if ((val = p_td_thr_validate (&th)) != TD_OK)
684         return 0;               /* Thread not valid.  */
685       return 1;                 /* Known thread.  */
686     }
687   else
688     {
689       struct target_ops *beneath = find_target_beneath (ops);
690
691       /* It's an LPW; pass the request on to the layer below.  */
692       return beneath->to_thread_alive (beneath, ptid);
693     }
694 }
695
696 \f
697 /* These routines implement the lower half of the thread_db interface,
698    i.e. the ps_* routines.  */
699
700 /* Various versions of <proc_service.h> have slightly different
701    function prototypes.  In particular, we have
702
703    NEWER                        OLDER
704    struct ps_prochandle *       const struct ps_prochandle *
705    void*                        char*
706    const void*                  char*
707    int                          size_t
708
709    Which one you have depends on the Solaris version and what patches
710    you've applied.  On the theory that there are only two major
711    variants, we have configure check the prototype of ps_pdwrite (),
712    and use that info to make appropriate typedefs here.  */
713
714 #ifdef PROC_SERVICE_IS_OLD
715 typedef const struct ps_prochandle *gdb_ps_prochandle_t;
716 typedef char *gdb_ps_read_buf_t;
717 typedef char *gdb_ps_write_buf_t;
718 typedef int gdb_ps_size_t;
719 typedef psaddr_t gdb_ps_addr_t;
720 #else
721 typedef struct ps_prochandle *gdb_ps_prochandle_t;
722 typedef void *gdb_ps_read_buf_t;
723 typedef const void *gdb_ps_write_buf_t;
724 typedef size_t gdb_ps_size_t;
725 typedef psaddr_t gdb_ps_addr_t;
726 #endif
727
728 /* The next four routines are called by libthread_db to tell us to
729    stop and stop a particular process or lwp.  Since GDB ensures that
730    these are all stopped by the time we call anything in thread_db,
731    these routines need to do nothing.  */
732
733 /* Process stop.  */
734
735 ps_err_e
736 ps_pstop (gdb_ps_prochandle_t ph)
737 {
738   return PS_OK;
739 }
740
741 /* Process continue.  */
742
743 ps_err_e
744 ps_pcontinue (gdb_ps_prochandle_t ph)
745 {
746   return PS_OK;
747 }
748
749 /* LWP stop.  */
750
751 ps_err_e
752 ps_lstop (gdb_ps_prochandle_t ph, lwpid_t lwpid)
753 {
754   return PS_OK;
755 }
756
757 /* LWP continue.  */
758
759 ps_err_e
760 ps_lcontinue (gdb_ps_prochandle_t ph, lwpid_t lwpid)
761 {
762   return PS_OK;
763 }
764
765 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table.  */
766
767 ps_err_e
768 ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *ld_object_name,
769                    const char *ld_symbol_name, gdb_ps_addr_t *ld_symbol_addr)
770 {
771   struct minimal_symbol *ms;
772
773   ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
774   if (!ms)
775     return PS_NOSYM;
776
777   *ld_symbol_addr = SYMBOL_VALUE_ADDRESS (ms);
778   return PS_OK;
779 }
780
781 /* Common routine for reading and writing memory.  */
782
783 static ps_err_e
784 rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr,
785            gdb_byte *buf, int size)
786 {
787   int ret;
788   struct cleanup *old_chain;
789
790   old_chain = save_inferior_ptid ();
791
792   if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
793     {
794       /* It's either a thread or an LWP that isn't alive.  Any live
795          LWP will do so use the first available.
796
797          NOTE: We don't need to call switch_to_thread; we're just
798          reading memory.  */
799       inferior_ptid = procfs_first_available ();
800     }
801
802 #if defined (__sparcv9)
803   /* For Sparc64 cross Sparc32, make sure the address has not been
804      accidentally sign-extended (or whatever) to beyond 32 bits.  */
805   if (bfd_get_arch_size (exec_bfd) == 32)
806     addr &= 0xffffffff;
807 #endif
808
809   if (dowrite)
810     ret = target_write_memory (addr, (gdb_byte *) buf, size);
811   else
812     ret = target_read_memory (addr, (gdb_byte *) buf, size);
813
814   do_cleanups (old_chain);
815
816   return (ret == 0 ? PS_OK : PS_ERR);
817 }
818
819 /* Copies SIZE bytes from target process .data segment to debugger memory.  */
820
821 ps_err_e
822 ps_pdread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
823            gdb_ps_read_buf_t buf, gdb_ps_size_t size)
824 {
825   return rw_common (0, ph, addr, buf, size);
826 }
827
828 /* Copies SIZE bytes from debugger memory .data segment to target process.  */
829
830 ps_err_e
831 ps_pdwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
832             gdb_ps_write_buf_t buf, gdb_ps_size_t size)
833 {
834   return rw_common (1, ph, addr, (gdb_byte *) buf, size);
835 }
836
837 /* Copies SIZE bytes from target process .text segment to debugger memory.  */
838
839 ps_err_e
840 ps_ptread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
841            gdb_ps_read_buf_t buf, gdb_ps_size_t size)
842 {
843   return rw_common (0, ph, addr, buf, size);
844 }
845
846 /* Copies SIZE bytes from debugger memory .text segment to target process.  */
847
848 ps_err_e
849 ps_ptwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
850             gdb_ps_write_buf_t buf, gdb_ps_size_t size)
851 {
852   return rw_common (1, ph, addr, (gdb_byte *) buf, size);
853 }
854
855 /* Get general-purpose registers for LWP.  */
856
857 ps_err_e
858 ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
859 {
860   struct cleanup *old_chain;
861   struct regcache *regcache;
862
863   old_chain = save_inferior_ptid ();
864
865   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
866   regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
867
868   target_fetch_registers (regcache, -1);
869   fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
870
871   do_cleanups (old_chain);
872
873   return PS_OK;
874 }
875
876 /* Set general-purpose registers for LWP.  */
877
878 ps_err_e
879 ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
880              const prgregset_t gregset)
881 {
882   struct cleanup *old_chain;
883   struct regcache *regcache;
884
885   old_chain = save_inferior_ptid ();
886
887   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
888   regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
889
890   supply_gregset (regcache, (const gdb_gregset_t *) gregset);
891   target_store_registers (regcache, -1);
892
893   do_cleanups (old_chain);
894
895   return PS_OK;
896 }
897
898 /* Log a message (sends to gdb_stderr).  */
899
900 void
901 ps_plog (const char *fmt, ...)
902 {
903   va_list args;
904
905   va_start (args, fmt);
906
907   vfprintf_filtered (gdb_stderr, fmt, args);
908 }
909
910 /* Get size of extra register set.  Currently a noop.  */
911
912 ps_err_e
913 ps_lgetxregsize (gdb_ps_prochandle_t ph, lwpid_t lwpid, int *xregsize)
914 {
915   return PS_OK;
916 }
917
918 /* Get extra register set.  Currently a noop.  */
919
920 ps_err_e
921 ps_lgetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
922 {
923   return PS_OK;
924 }
925
926 /* Set extra register set.  Currently a noop.  */
927
928 ps_err_e
929 ps_lsetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
930 {
931   return PS_OK;
932 }
933
934 /* Get floating-point registers for LWP.  */
935
936 ps_err_e
937 ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
938                prfpregset_t *fpregset)
939 {
940   struct cleanup *old_chain;
941   struct regcache *regcache;
942
943   old_chain = save_inferior_ptid ();
944
945   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
946   regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
947
948   target_fetch_registers (regcache, -1);
949   fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
950
951   do_cleanups (old_chain);
952
953   return PS_OK;
954 }
955
956 /* Set floating-point regs for LWP.  */
957
958 ps_err_e
959 ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
960                const prfpregset_t * fpregset)
961 {
962   struct cleanup *old_chain;
963   struct regcache *regcache;
964
965   old_chain = save_inferior_ptid ();
966
967   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
968   regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
969
970   supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
971   target_store_registers (regcache, -1);
972
973   do_cleanups (old_chain);
974
975   return PS_OK;
976 }
977
978 #ifdef PR_MODEL_LP64
979 /* Identify process as 32-bit or 64-bit.  At the moment we're using
980    BFD to do this.  There might be a more Solaris-specific
981    (e.g. procfs) method, but this ought to work.  */
982
983 ps_err_e
984 ps_pdmodel (gdb_ps_prochandle_t ph, int *data_model)
985 {
986   if (exec_bfd == 0)
987     *data_model = PR_MODEL_UNKNOWN;
988   else if (bfd_get_arch_size (exec_bfd) == 32)
989     *data_model = PR_MODEL_ILP32;
990   else
991     *data_model = PR_MODEL_LP64;
992
993   return PS_OK;
994 }
995 #endif /* PR_MODEL_LP64 */
996
997 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
998
999 /* Reads the local descriptor table of a LWP.
1000
1001    This function is necessary on x86-solaris only.  Without it, the loading
1002    of libthread_db would fail because of ps_lgetLDT being undefined.  */
1003
1004 ps_err_e
1005 ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1006             struct ssd *pldt)
1007 {
1008   /* NOTE: only used on Solaris, therefore OK to refer to procfs.c.  */
1009   struct ssd *ret;
1010
1011   /* FIXME: can't I get the process ID from the prochandle or
1012      something?  */
1013
1014   if (PIDGET (inferior_ptid) <= 0 || lwpid <= 0)
1015     return PS_BADLID;
1016
1017   ret = procfs_find_LDT_entry (BUILD_LWP (lwpid, PIDGET (inferior_ptid)));
1018   if (ret)
1019     {
1020       memcpy (pldt, ret, sizeof (struct ssd));
1021       return PS_OK;
1022     }
1023   else
1024     /* LDT not found.  */
1025     return PS_ERR;
1026 }
1027 #endif
1028 \f
1029
1030 /* Convert PTID to printable form.  */
1031
1032 static char *
1033 solaris_pid_to_str (struct target_ops *ops, ptid_t ptid)
1034 {
1035   static char buf[100];
1036
1037   if (is_thread (ptid))
1038     {
1039       ptid_t lwp;
1040
1041       lwp = thread_to_lwp (ptid, -2);
1042
1043       if (PIDGET (lwp) == -1)
1044         xsnprintf (buf, sizeof (buf), "Thread %ld (defunct)",
1045                    GET_THREAD (ptid));
1046       else if (PIDGET (lwp) != -2)
1047         xsnprintf (buf, sizeof (buf), "Thread %ld (LWP %ld)",
1048                  GET_THREAD (ptid), GET_LWP (lwp));
1049       else
1050         xsnprintf (buf, sizeof (buf), "Thread %ld        ", GET_THREAD (ptid));
1051     }
1052   else if (GET_LWP (ptid) != 0)
1053     xsnprintf (buf, sizeof (buf), "LWP    %ld        ", GET_LWP (ptid));
1054   else
1055     xsnprintf (buf, sizeof (buf), "process %d    ", PIDGET (ptid));
1056
1057   return buf;
1058 }
1059 \f
1060
1061 /* Worker bee for find_new_threads.  Callback function that gets
1062    called once per user-level thread (i.e. not for LWP's).  */
1063
1064 static int
1065 sol_find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
1066 {
1067   td_err_e retval;
1068   td_thrinfo_t ti;
1069   ptid_t ptid;
1070
1071   retval = p_td_thr_get_info (th, &ti);
1072   if (retval != TD_OK)
1073     return -1;
1074
1075   ptid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_ptid));
1076   if (!in_thread_list (ptid) || is_exited (ptid))
1077     add_thread (ptid);
1078
1079   return 0;
1080 }
1081
1082 static void
1083 sol_find_new_threads (struct target_ops *ops)
1084 {
1085   struct target_ops *beneath = find_target_beneath (ops);
1086
1087   /* First Find any new LWP's.  */
1088   if (beneath->to_find_new_threads != NULL)
1089     beneath->to_find_new_threads (beneath);
1090
1091   /* Then find any new user-level threads.  */
1092   p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *) 0,
1093                     TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1094                     TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1095 }
1096
1097 /* Worker bee for the "info sol-thread" command.  This is a callback
1098    function that gets called once for each Solaris user-level thread
1099    (i.e. not for LWPs) in the inferior.  Print anything interesting
1100    that we can think of.  */
1101
1102 static int
1103 info_cb (const td_thrhandle_t *th, void *s)
1104 {
1105   td_err_e ret;
1106   td_thrinfo_t ti;
1107
1108   ret = p_td_thr_get_info (th, &ti);
1109   if (ret == TD_OK)
1110     {
1111       printf_filtered ("%s thread #%d, lwp %d, ",
1112                        ti.ti_type == TD_THR_SYSTEM ? "system" : "user  ",
1113                        ti.ti_tid, ti.ti_lid);
1114       switch (ti.ti_state)
1115         {
1116         default:
1117         case TD_THR_UNKNOWN:
1118           printf_filtered ("<unknown state>");
1119           break;
1120         case TD_THR_STOPPED:
1121           printf_filtered ("(stopped)");
1122           break;
1123         case TD_THR_RUN:
1124           printf_filtered ("(run)    ");
1125           break;
1126         case TD_THR_ACTIVE:
1127           printf_filtered ("(active) ");
1128           break;
1129         case TD_THR_ZOMBIE:
1130           printf_filtered ("(zombie) ");
1131           break;
1132         case TD_THR_SLEEP:
1133           printf_filtered ("(asleep) ");
1134           break;
1135         case TD_THR_STOPPED_ASLEEP:
1136           printf_filtered ("(stopped asleep)");
1137           break;
1138         }
1139       /* Print thr_create start function.  */
1140       if (ti.ti_startfunc != 0)
1141         {
1142           const struct bound_minimal_symbol msym
1143             = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
1144
1145           printf_filtered ("   startfunc=%s",
1146                            msym.minsym
1147                            ? SYMBOL_PRINT_NAME (msym.minsym)
1148                            : paddress (target_gdbarch (), ti.ti_startfunc));
1149         }
1150
1151       /* If thread is asleep, print function that went to sleep.  */
1152       if (ti.ti_state == TD_THR_SLEEP)
1153         {
1154           const struct bound_minimal_symbol msym
1155             = lookup_minimal_symbol_by_pc (ti.ti_pc);
1156
1157           printf_filtered ("   sleepfunc=%s",
1158                            msym.minsym
1159                            ? SYMBOL_PRINT_NAME (msym.minsym)
1160                            : paddress (target_gdbarch (), ti.ti_pc));
1161         }
1162
1163       printf_filtered ("\n");
1164     }
1165   else
1166     warning (_("info sol-thread: failed to get info for thread."));
1167
1168   return 0;
1169 }
1170
1171 /* List some state about each Solaris user-level thread in the
1172    inferior.  */
1173
1174 static void
1175 info_solthreads (char *args, int from_tty)
1176 {
1177   p_td_ta_thr_iter (main_ta, info_cb, args,
1178                     TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1179                     TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1180 }
1181
1182 /* Callback routine used to find a thread based on the TID part of
1183    its PTID.  */
1184
1185 static int
1186 thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
1187 {
1188   long *tid = (long *) data;
1189
1190   if (ptid_get_tid (thread->ptid) == *tid)
1191     return 1;
1192
1193   return 0;
1194 }
1195
1196 static ptid_t
1197 sol_get_ada_task_ptid (long lwp, long thread)
1198 {
1199   struct thread_info *thread_info =
1200     iterate_over_threads (thread_db_find_thread_from_tid, &thread);
1201
1202   if (thread_info == NULL)
1203     {
1204       /* The list of threads is probably not up to date.  Find any
1205          thread that is missing from the list, and try again.  */
1206       sol_find_new_threads (&current_target);
1207       thread_info = iterate_over_threads (thread_db_find_thread_from_tid,
1208                                           &thread);
1209     }
1210
1211   gdb_assert (thread_info != NULL);
1212
1213   return (thread_info->ptid);
1214 }
1215
1216 static void
1217 init_sol_thread_ops (void)
1218 {
1219   sol_thread_ops.to_shortname = "solaris-threads";
1220   sol_thread_ops.to_longname = "Solaris threads and pthread.";
1221   sol_thread_ops.to_doc = "Solaris threads and pthread support.";
1222   sol_thread_ops.to_detach = sol_thread_detach;
1223   sol_thread_ops.to_resume = sol_thread_resume;
1224   sol_thread_ops.to_wait = sol_thread_wait;
1225   sol_thread_ops.to_fetch_registers = sol_thread_fetch_registers;
1226   sol_thread_ops.to_store_registers = sol_thread_store_registers;
1227   sol_thread_ops.to_xfer_partial = sol_thread_xfer_partial;
1228   sol_thread_ops.to_mourn_inferior = sol_thread_mourn_inferior;
1229   sol_thread_ops.to_thread_alive = sol_thread_alive;
1230   sol_thread_ops.to_pid_to_str = solaris_pid_to_str;
1231   sol_thread_ops.to_find_new_threads = sol_find_new_threads;
1232   sol_thread_ops.to_stratum = thread_stratum;
1233   sol_thread_ops.to_get_ada_task_ptid = sol_get_ada_task_ptid;
1234   sol_thread_ops.to_magic = OPS_MAGIC;
1235 }
1236
1237 /* Silence -Wmissing-prototypes.  */
1238 extern void _initialize_sol_thread (void);
1239
1240 void
1241 _initialize_sol_thread (void)
1242 {
1243   void *dlhandle;
1244
1245   init_sol_thread_ops ();
1246
1247   dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
1248   if (!dlhandle)
1249     goto die;
1250
1251 #define resolve(X) \
1252   if (!(p_##X = dlsym (dlhandle, #X))) \
1253     goto die;
1254
1255   resolve (td_log);
1256   resolve (td_ta_new);
1257   resolve (td_ta_delete);
1258   resolve (td_init);
1259   resolve (td_ta_get_ph);
1260   resolve (td_ta_get_nthreads);
1261   resolve (td_ta_tsd_iter);
1262   resolve (td_ta_thr_iter);
1263   resolve (td_thr_validate);
1264   resolve (td_thr_tsd);
1265   resolve (td_thr_get_info);
1266   resolve (td_thr_getfpregs);
1267   resolve (td_thr_getxregsize);
1268   resolve (td_thr_getxregs);
1269   resolve (td_thr_sigsetmask);
1270   resolve (td_thr_setprio);
1271   resolve (td_thr_setsigpending);
1272   resolve (td_thr_setfpregs);
1273   resolve (td_thr_setxregs);
1274   resolve (td_ta_map_id2thr);
1275   resolve (td_ta_map_lwp2thr);
1276   resolve (td_thr_getgregs);
1277   resolve (td_thr_setgregs);
1278
1279   complete_target_initialization (&sol_thread_ops);
1280
1281   add_cmd ("sol-threads", class_maintenance, info_solthreads,
1282            _("Show info on Solaris user threads."), &maintenanceinfolist);
1283
1284   /* Hook into new_objfile notification.  */
1285   observer_attach_new_objfile (sol_thread_new_objfile);
1286   return;
1287
1288  die:
1289   fprintf_unfiltered (gdb_stderr, "\
1290 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1291
1292   if (dlhandle)
1293     dlclose (dlhandle);
1294
1295   return;
1296 }