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