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   sol_thread_target ()
  82   { this->to_stratum = thread_stratum; }
  83
  84   const target_info &info () const override
  85   { return thread_db_target_info; }
  86
  87   void detach (inferior *, int) override;
  88   ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
  89   void resume (ptid_t, int, enum gdb_signal) override;
  90   void mourn_inferior () override;
  91   const char *pid_to_str (ptid_t) override;
  92   ptid_t get_ada_task_ptid (long lwp, long thread) override;
  93
  94   void fetch_registers (struct regcache *, int) override;
  95   void store_registers (struct regcache *, int) override;
  96
  97   enum target_xfer_status xfer_partial (enum target_object object,
  98                                         const char *annex,
  99                                         gdb_byte *readbuf,
 100                                         const gdb_byte *writebuf,
 101                                         ULONGEST offset, ULONGEST len,
 102                                         ULONGEST *xfered_len) override;
 103
 104   bool thread_alive (ptid_t ptid) override;
 105   void update_thread_list () override;
 106 };
 107
 108 static sol_thread_target sol_thread_ops;
 109
 110 /* Prototypes for supply_gregset etc.  */
 111 #include "gregset.h"
 112
 113 /* This struct is defined by us, but mainly used for the proc_service
 114    interface.  We don't have much use for it, except as a handy place
 115    to get a real PID for memory accesses.  */
 116
 117 struct ps_prochandle
 118 {
 119   ptid_t ptid;
 120 };
 121
 122 struct string_map
 123 {
 124   int num;
 125   const char *str;
 126 };
 127
 128 static struct ps_prochandle main_ph;
 129 static td_thragent_t *main_ta;
 130 static int sol_thread_active = 0;
 131
 132 /* Default definitions: These must be defined in tm.h if they are to
 133    be shared with a process module such as procfs.  */
 134
 135 /* Types of the libthread_db functions.  */
 136
 137 typedef void (td_log_ftype)(const int on_off);
 138 typedef td_err_e (td_ta_new_ftype)(const struct ps_prochandle *ph_p,
 139                                    td_thragent_t **ta_pp);
 140 typedef td_err_e (td_ta_delete_ftype)(td_thragent_t *ta_p);
 141 typedef td_err_e (td_init_ftype)(void);
 142 typedef td_err_e (td_ta_get_ph_ftype)(const td_thragent_t *ta_p,
 143                                       struct ps_prochandle **ph_pp);
 144 typedef td_err_e (td_ta_get_nthreads_ftype)(const td_thragent_t *ta_p,
 145                                             int *nthread_p);
 146 typedef td_err_e (td_ta_tsd_iter_ftype)(const td_thragent_t *ta_p,
 147                                         td_key_iter_f *cb, void *cbdata_p);
 148 typedef td_err_e (td_ta_thr_iter_ftype)(const td_thragent_t *ta_p,
 149                                         td_thr_iter_f *cb, void *cbdata_p,
 150                                         td_thr_state_e state, int ti_pri,
 151                                         sigset_t *ti_sigmask_p,
 152                                         unsigned ti_user_flags);
 153 typedef td_err_e (td_thr_validate_ftype)(const td_thrhandle_t *th_p);
 154 typedef td_err_e (td_thr_tsd_ftype)(const td_thrhandle_t * th_p,
 155                                     const thread_key_t key, void **data_pp);
 156 typedef td_err_e (td_thr_get_info_ftype)(const td_thrhandle_t *th_p,
 157                                          td_thrinfo_t *ti_p);
 158 typedef td_err_e (td_thr_getfpregs_ftype)(const td_thrhandle_t *th_p,
 159                                           prfpregset_t *fpregset);
 160 typedef td_err_e (td_thr_getxregsize_ftype)(const td_thrhandle_t *th_p,
 161                                             int *xregsize);
 162 typedef td_err_e (td_thr_getxregs_ftype)(const td_thrhandle_t *th_p,
 163                                          const caddr_t xregset);
 164 typedef td_err_e (td_thr_sigsetmask_ftype)(const td_thrhandle_t *th_p,
 165                                            const sigset_t ti_sigmask);
 166 typedef td_err_e (td_thr_setprio_ftype)(const td_thrhandle_t *th_p,
 167                                         const int ti_pri);
 168 typedef td_err_e (td_thr_setsigpending_ftype)(const td_thrhandle_t *th_p,
 169                                               const uchar_t ti_pending_flag,
 170                                               const sigset_t ti_pending);
 171 typedef td_err_e (td_thr_setfpregs_ftype)(const td_thrhandle_t *th_p,
 172                                           const prfpregset_t *fpregset);
 173 typedef td_err_e (td_thr_setxregs_ftype)(const td_thrhandle_t *th_p,
 174                                          const caddr_t xregset);
 175 typedef td_err_e (td_ta_map_id2thr_ftype)(const td_thragent_t *ta_p,
 176                                           thread_t tid,
 177                                           td_thrhandle_t *th_p);
 178 typedef td_err_e (td_ta_map_lwp2thr_ftype)(const td_thragent_t *ta_p,
 179                                            lwpid_t lwpid,
 180                                            td_thrhandle_t *th_p);
 181 typedef td_err_e (td_thr_getgregs_ftype)(const td_thrhandle_t *th_p,
 182                                          prgregset_t regset);
 183 typedef td_err_e (td_thr_setgregs_ftype)(const td_thrhandle_t *th_p,
 184                                          const prgregset_t regset);
 185
 186 /* Pointers to routines from libthread_db resolved by dlopen().  */
 187
 188 static td_log_ftype *p_td_log;
 189 static td_ta_new_ftype *p_td_ta_new;
 190 static td_ta_delete_ftype *p_td_ta_delete;
 191 static td_init_ftype *p_td_init;
 192 static td_ta_get_ph_ftype *p_td_ta_get_ph;
 193 static td_ta_get_nthreads_ftype *p_td_ta_get_nthreads;
 194 static td_ta_tsd_iter_ftype *p_td_ta_tsd_iter;
 195 static td_ta_thr_iter_ftype *p_td_ta_thr_iter;
 196 static td_thr_validate_ftype *p_td_thr_validate;
 197 static td_thr_tsd_ftype *p_td_thr_tsd;
 198 static td_thr_get_info_ftype *p_td_thr_get_info;
 199 static td_thr_getfpregs_ftype *p_td_thr_getfpregs;
 200 static td_thr_getxregsize_ftype *p_td_thr_getxregsize;
 201 static td_thr_getxregs_ftype *p_td_thr_getxregs;
 202 static td_thr_sigsetmask_ftype *p_td_thr_sigsetmask;
 203 static td_thr_setprio_ftype *p_td_thr_setprio;
 204 static td_thr_setsigpending_ftype *p_td_thr_setsigpending;
 205 static td_thr_setfpregs_ftype *p_td_thr_setfpregs;
 206 static td_thr_setxregs_ftype *p_td_thr_setxregs;
 207 static td_ta_map_id2thr_ftype *p_td_ta_map_id2thr;
 208 static td_ta_map_lwp2thr_ftype *p_td_ta_map_lwp2thr;
 209 static td_thr_getgregs_ftype *p_td_thr_getgregs;
 210 static td_thr_setgregs_ftype *p_td_thr_setgregs;
 211 \f
 212
 213 /* Return the libthread_db error string associated with ERRCODE.  If
 214    ERRCODE is unknown, return an appropriate message.  */
 215
 216 static const char *
 217 td_err_string (td_err_e errcode)
 218 {
 219   static struct string_map td_err_table[] =
 220   {
 221     { TD_OK, "generic \"call succeeded\"" },
 222     { TD_ERR, "generic error." },
 223     { TD_NOTHR, "no thread can be found to satisfy query" },
 224     { TD_NOSV, "no synch. variable can be found to satisfy query" },
 225     { TD_NOLWP, "no lwp can be found to satisfy query" },
 226     { TD_BADPH, "invalid process handle" },
 227     { TD_BADTH, "invalid thread handle" },
 228     { TD_BADSH, "invalid synchronization handle" },
 229     { TD_BADTA, "invalid thread agent" },
 230     { TD_BADKEY, "invalid key" },
 231     { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" },
 232     { TD_NOFPREGS, "FPU register set not available for given thread" },
 233     { TD_NOLIBTHREAD, "application not linked with libthread" },
 234     { TD_NOEVENT, "requested event is not supported" },
 235     { TD_NOCAPAB, "capability not available" },
 236     { TD_DBERR, "Debugger service failed" },
 237     { TD_NOAPLIC, "Operation not applicable to" },
 238     { TD_NOTSD, "No thread specific data for this thread" },
 239     { TD_MALLOC, "Malloc failed" },
 240     { TD_PARTIALREG, "Only part of register set was written/read" },
 241     { TD_NOXREGS, "X register set not available for given thread" }
 242   };
 243   const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
 244   int i;
 245   static char buf[50];
 246
 247   for (i = 0; i < td_err_size; i++)
 248     if (td_err_table[i].num == errcode)
 249       return td_err_table[i].str;
 250
 251   xsnprintf (buf, sizeof (buf), "Unknown libthread_db error code: %d",
 252              errcode);
 253
 254   return buf;
 255 }
 256
 257 /* Return the libthread_db state string assicoated with STATECODE.
 258    If STATECODE is unknown, return an appropriate message.  */
 259
 260 static const char *
 261 td_state_string (td_thr_state_e statecode)
 262 {
 263   static struct string_map td_thr_state_table[] =
 264   {
 265     { TD_THR_ANY_STATE, "any state" },
 266     { TD_THR_UNKNOWN, "unknown" },
 267     { TD_THR_STOPPED, "stopped" },
 268     { TD_THR_RUN, "run" },
 269     { TD_THR_ACTIVE, "active" },
 270     { TD_THR_ZOMBIE, "zombie" },
 271     { TD_THR_SLEEP, "sleep" },
 272     { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
 273   };
 274   const int td_thr_state_table_size =
 275     sizeof td_thr_state_table / sizeof (struct string_map);
 276   int i;
 277   static char buf[50];
 278
 279   for (i = 0; i < td_thr_state_table_size; i++)
 280     if (td_thr_state_table[i].num == statecode)
 281       return td_thr_state_table[i].str;
 282
 283   xsnprintf (buf, sizeof (buf), "Unknown libthread_db state code: %d",
 284              statecode);
 285
 286   return buf;
 287 }
 288 \f
 289
 290 /* Convert a POSIX or Solaris thread ID into a LWP ID.  If THREAD_ID
 291    doesn't exist, that's an error.  If it's an inactive thread, return
 292    DEFAULT_LWP.
 293
 294    NOTE: This function probably shouldn't call error().  */
 295
 296 static ptid_t
 297 thread_to_lwp (ptid_t thread_id, int default_lwp)
 298 {
 299   td_thrinfo_t ti;
 300   td_thrhandle_t th;
 301   td_err_e val;
 302
 303   if (ptid_lwp_p (thread_id))
 304     return thread_id;           /* It's already an LWP ID.  */
 305
 306   /* It's a thread.  Convert to LWP.  */
 307
 308   val = p_td_ta_map_id2thr (main_ta, ptid_get_tid (thread_id), &th);
 309   if (val == TD_NOTHR)
 310     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 311   else if (val != TD_OK)
 312     error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
 313
 314   val = p_td_thr_get_info (&th, &ti);
 315   if (val == TD_NOTHR)
 316     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 317   else if (val != TD_OK)
 318     error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
 319
 320   if (ti.ti_state != TD_THR_ACTIVE)
 321     {
 322       if (default_lwp != -1)
 323         return pid_to_ptid (default_lwp);
 324       error (_("thread_to_lwp: thread state not active: %s"),
 325              td_state_string (ti.ti_state));
 326     }
 327
 328   return ptid_build (ptid_get_pid (thread_id), ti.ti_lid, 0);
 329 }
 330
 331 /* Convert an LWP ID into a POSIX or Solaris thread ID.  If LWP_ID
 332    doesn't exists, that's an error.
 333
 334    NOTE: This function probably shouldn't call error().  */
 335
 336 static ptid_t
 337 lwp_to_thread (ptid_t lwp)
 338 {
 339   td_thrinfo_t ti;
 340   td_thrhandle_t th;
 341   td_err_e val;
 342
 343   if (ptid_tid_p (lwp))
 344     return lwp;                 /* It's already a thread ID.  */
 345
 346   /* It's an LWP.  Convert it to a thread ID.  */
 347
 348   if (!target_thread_alive (lwp))
 349     return pid_to_ptid (-1);    /* Must be a defunct LPW.  */
 350
 351   val = p_td_ta_map_lwp2thr (main_ta, ptid_get_lwp (lwp), &th);
 352   if (val == TD_NOTHR)
 353     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 354   else if (val != TD_OK)
 355     error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
 356
 357   val = p_td_thr_validate (&th);
 358   if (val == TD_NOTHR)
 359     return lwp;                 /* Unknown to libthread; just return LPW,  */
 360   else if (val != TD_OK)
 361     error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
 362
 363   val = p_td_thr_get_info (&th, &ti);
 364   if (val == TD_NOTHR)
 365     return pid_to_ptid (-1);    /* Thread must have terminated.  */
 366   else if (val != TD_OK)
 367     error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
 368
 369   return ptid_build (ptid_get_pid (lwp), 0 , ti.ti_tid);
 370 }
 371 \f
 372
 373 /* Most target vector functions from here on actually just pass
 374    through to the layer beneath, as they don't need to do anything
 375    specific for threads.  */
 376
 377 /* Take a program previously attached to and detaches it.  The program
 378    resumes execution and will no longer stop on signals, etc.  We'd
 379    better not have left any breakpoints in the program or it'll die
 380    when it hits one.  For this to work, it may be necessary for the
 381    process to have been previously attached.  It *might* work if the
 382    program was started via the normal ptrace (PTRACE_TRACEME).  */
 383
 384 void
 385 sol_thread_target::detach (inferior *inf, int from_tty)
 386 {
 387   target_ops *beneath = this->beneath ();
 388
 389   sol_thread_active = 0;
 390   inferior_ptid = pid_to_ptid (ptid_get_pid (main_ph.ptid));
 391   unpush_target (this);
 392   beneath->detach (inf, from_tty);
 393 }
 394
 395 /* Resume execution of process PTID.  If STEP is nozero, then just
 396    single step it.  If SIGNAL is nonzero, restart it with that signal
 397    activated.  We may have to convert PTID from a thread ID to an LWP
 398    ID for procfs.  */
 399
 400 void
 401 sol_thread_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
 402 {
 403   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 404
 405   inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
 406   if (ptid_get_pid (inferior_ptid) == -1)
 407     inferior_ptid = procfs_first_available ();
 408
 409   if (ptid_get_pid (ptid) != -1)
 410     {
 411       ptid_t save_ptid = ptid;
 412
 413       ptid = thread_to_lwp (ptid, -2);
 414       if (ptid_get_pid (ptid) == -2)            /* Inactive thread.  */
 415         error (_("This version of Solaris can't start inactive threads."));
 416       if (info_verbose && ptid_get_pid (ptid) == -1)
 417         warning (_("Specified thread %ld seems to have terminated"),
 418                  ptid_get_tid (save_ptid));
 419     }
 420
 421   beneath ()->resume (ptid, step, signo);
 422 }
 423
 424 /* Wait for any threads to stop.  We may have to convert PTID from a
 425    thread ID to an LWP ID, and vice versa on the way out.  */
 426
 427 ptid_t
 428 sol_thread_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
 429                          int options)
 430 {
 431   ptid_t rtnval;
 432   ptid_t save_ptid;
 433
 434   save_ptid = inferior_ptid;
 435   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 436
 437   inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
 438   if (ptid_get_pid (inferior_ptid) == -1)
 439     inferior_ptid = procfs_first_available ();
 440
 441   if (ptid_get_pid (ptid) != -1)
 442     {
 443       ptid_t save_ptid = ptid;
 444
 445       ptid = thread_to_lwp (ptid, -2);
 446       if (ptid_get_pid (ptid) == -2)            /* Inactive thread.  */
 447         error (_("This version of Solaris can't start inactive threads."));
 448       if (info_verbose && ptid_get_pid (ptid) == -1)
 449         warning (_("Specified thread %ld seems to have terminated"),
 450                  ptid_get_tid (save_ptid));
 451     }
 452
 453   rtnval = beneath ()->wait (ptid, ourstatus, options);
 454
 455   if (ourstatus->kind != TARGET_WAITKIND_EXITED)
 456     {
 457       /* Map the LWP of interest back to the appropriate thread ID.  */
 458       rtnval = lwp_to_thread (rtnval);
 459       if (ptid_get_pid (rtnval) == -1)
 460         rtnval = save_ptid;
 461
 462       /* See if we have a new thread.  */
 463       if (ptid_tid_p (rtnval)
 464           && !ptid_equal (rtnval, save_ptid)
 465           && (!in_thread_list (rtnval)
 466               || is_exited (rtnval)))
 467         add_thread (rtnval);
 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 (ptid))
 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_get_tid (ptid);
 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 (ptid))
 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_get_tid (ptid);
 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 (ptid_tid_p (inferior_ptid) || !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_get_pid (ptid) != -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 (ptid))
 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_get_tid (ptid);
 708       if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
 709         return false;           /* Thread not found.  */
 710       if ((val = p_td_thr_validate (&th)) != TD_OK)
 711         return false;           /* Thread not valid.  */
 712       return true;              /* Known thread.  */
 713     }
 714   else
 715     {
 716       /* It's an LPW; pass the request on to the layer below.  */
 717       return beneath ()->thread_alive (ptid);
 718     }
 719 }
 720
 721 \f
 722 /* These routines implement the lower half of the thread_db interface,
 723    i.e. the ps_* routines.  */
 724
 725 /* The next four routines are called by libthread_db to tell us to
 726    stop and stop a particular process or lwp.  Since GDB ensures that
 727    these are all stopped by the time we call anything in thread_db,
 728    these routines need to do nothing.  */
 729
 730 /* Process stop.  */
 731
 732 ps_err_e
 733 ps_pstop (struct ps_prochandle *ph)
 734 {
 735   return PS_OK;
 736 }
 737
 738 /* Process continue.  */
 739
 740 ps_err_e
 741 ps_pcontinue (struct ps_prochandle *ph)
 742 {
 743   return PS_OK;
 744 }
 745
 746 /* LWP stop.  */
 747
 748 ps_err_e
 749 ps_lstop (struct ps_prochandle *ph, lwpid_t lwpid)
 750 {
 751   return PS_OK;
 752 }
 753
 754 /* LWP continue.  */
 755
 756 ps_err_e
 757 ps_lcontinue (struct ps_prochandle *ph, lwpid_t lwpid)
 758 {
 759   return PS_OK;
 760 }
 761
 762 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table.  */
 763
 764 ps_err_e
 765 ps_pglobal_lookup (struct ps_prochandle *ph, const char *ld_object_name,
 766                    const char *ld_symbol_name, psaddr_t *ld_symbol_addr)
 767 {
 768   struct bound_minimal_symbol ms;
 769
 770   ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
 771   if (!ms.minsym)
 772     return PS_NOSYM;
 773
 774   *ld_symbol_addr = BMSYMBOL_VALUE_ADDRESS (ms);
 775   return PS_OK;
 776 }
 777
 778 /* Common routine for reading and writing memory.  */
 779
 780 static ps_err_e
 781 rw_common (int dowrite, const struct ps_prochandle *ph, psaddr_t addr,
 782            gdb_byte *buf, int size)
 783 {
 784   int ret;
 785
 786   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 787
 788   if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
 789     {
 790       /* It's either a thread or an LWP that isn't alive.  Any live
 791          LWP will do so use the first available.
 792
 793          NOTE: We don't need to call switch_to_thread; we're just
 794          reading memory.  */
 795       inferior_ptid = procfs_first_available ();
 796     }
 797
 798 #if defined (__sparcv9)
 799   /* For Sparc64 cross Sparc32, make sure the address has not been
 800      accidentally sign-extended (or whatever) to beyond 32 bits.  */
 801   if (bfd_get_arch_size (exec_bfd) == 32)
 802     addr &= 0xffffffff;
 803 #endif
 804
 805   if (dowrite)
 806     ret = target_write_memory (addr, (gdb_byte *) buf, size);
 807   else
 808     ret = target_read_memory (addr, (gdb_byte *) buf, size);
 809
 810   return (ret == 0 ? PS_OK : PS_ERR);
 811 }
 812
 813 /* Copies SIZE bytes from target process .data segment to debugger memory.  */
 814
 815 ps_err_e
 816 ps_pdread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
 817 {
 818   return rw_common (0, ph, addr, (gdb_byte *) buf, size);
 819 }
 820
 821 /* Copies SIZE bytes from debugger memory .data segment to target process.  */
 822
 823 ps_err_e
 824 ps_pdwrite (struct ps_prochandle *ph, psaddr_t addr,
 825             const void *buf, size_t size)
 826 {
 827   return rw_common (1, ph, addr, (gdb_byte *) buf, size);
 828 }
 829
 830 /* Copies SIZE bytes from target process .text segment to debugger memory.  */
 831
 832 ps_err_e
 833 ps_ptread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
 834 {
 835   return rw_common (0, ph, addr, (gdb_byte *) buf, size);
 836 }
 837
 838 /* Copies SIZE bytes from debugger memory .text segment to target process.  */
 839
 840 ps_err_e
 841 ps_ptwrite (struct ps_prochandle *ph, psaddr_t addr,
 842             const void *buf, size_t size)
 843 {
 844   return rw_common (1, ph, addr, (gdb_byte *) buf, size);
 845 }
 846
 847 /* Get general-purpose registers for LWP.  */
 848
 849 ps_err_e
 850 ps_lgetregs (struct ps_prochandle *ph, lwpid_t lwpid, prgregset_t gregset)
 851 {
 852   ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
 853   struct regcache *regcache
 854     = get_thread_arch_regcache (ptid, target_gdbarch ());
 855
 856   target_fetch_registers (regcache, -1);
 857   fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
 858
 859   return PS_OK;
 860 }
 861
 862 /* Set general-purpose registers for LWP.  */
 863
 864 ps_err_e
 865 ps_lsetregs (struct ps_prochandle *ph, lwpid_t lwpid,
 866              const prgregset_t gregset)
 867 {
 868   ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
 869   struct regcache *regcache
 870     = get_thread_arch_regcache (ptid, target_gdbarch ());
 871
 872   supply_gregset (regcache, (const gdb_gregset_t *) gregset);
 873   target_store_registers (regcache, -1);
 874
 875   return PS_OK;
 876 }
 877
 878 /* Log a message (sends to gdb_stderr).  */
 879
 880 void
 881 ps_plog (const char *fmt, ...)
 882 {
 883   va_list args;
 884
 885   va_start (args, fmt);
 886
 887   vfprintf_filtered (gdb_stderr, fmt, args);
 888 }
 889
 890 /* Get size of extra register set.  Currently a noop.  */
 891
 892 ps_err_e
 893 ps_lgetxregsize (struct ps_prochandle *ph, lwpid_t lwpid, int *xregsize)
 894 {
 895   return PS_OK;
 896 }
 897
 898 /* Get extra register set.  Currently a noop.  */
 899
 900 ps_err_e
 901 ps_lgetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
 902 {
 903   return PS_OK;
 904 }
 905
 906 /* Set extra register set.  Currently a noop.  */
 907
 908 ps_err_e
 909 ps_lsetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
 910 {
 911   return PS_OK;
 912 }
 913
 914 /* Get floating-point registers for LWP.  */
 915
 916 ps_err_e
 917 ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
 918                prfpregset_t *fpregset)
 919 {
 920   ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
 921   struct regcache *regcache
 922     = get_thread_arch_regcache (ptid, target_gdbarch ());
 923
 924   target_fetch_registers (regcache, -1);
 925   fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
 926
 927   return PS_OK;
 928 }
 929
 930 /* Set floating-point regs for LWP.  */
 931
 932 ps_err_e
 933 ps_lsetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
 934                const prfpregset_t * fpregset)
 935 {
 936   ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
 937   struct regcache *regcache
 938     = get_thread_arch_regcache (ptid, target_gdbarch ());
 939
 940   supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
 941   target_store_registers (regcache, -1);
 942
 943   return PS_OK;
 944 }
 945
 946 #ifdef PR_MODEL_LP64
 947 /* Identify process as 32-bit or 64-bit.  At the moment we're using
 948    BFD to do this.  There might be a more Solaris-specific
 949    (e.g. procfs) method, but this ought to work.  */
 950
 951 ps_err_e
 952 ps_pdmodel (struct ps_prochandle *ph, int *data_model)
 953 {
 954   if (exec_bfd == 0)
 955     *data_model = PR_MODEL_UNKNOWN;
 956   else if (bfd_get_arch_size (exec_bfd) == 32)
 957     *data_model = PR_MODEL_ILP32;
 958   else
 959     *data_model = PR_MODEL_LP64;
 960
 961   return PS_OK;
 962 }
 963 #endif /* PR_MODEL_LP64 */
 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,
 974             struct ssd *pldt)
 975 {
 976   /* NOTE: only used on Solaris, therefore OK to refer to procfs.c.  */
 977   struct ssd *ret;
 978
 979   /* FIXME: can't I get the process ID from the prochandle or
 980      something?  */
 981
 982   if (ptid_get_pid (inferior_ptid) <= 0 || lwpid <= 0)
 983     return PS_BADLID;
 984
 985   ret = procfs_find_LDT_entry (ptid_build (ptid_get_pid (inferior_ptid),
 986                                lwpid, 0));
 987   if (ret)
 988     {
 989       memcpy (pldt, ret, sizeof (struct ssd));
 990       return PS_OK;
 991     }
 992   else
 993     /* LDT not found.  */
 994     return PS_ERR;
 995 }
 996 #endif
 997 \f
 998
 999 /* Convert PTID to printable form.  */
1000
1001 const char *
1002 sol_thread_target::pid_to_str (ptid_t ptid)
1003 {
1004   static char buf[100];
1005
1006   if (ptid_tid_p (ptid))
1007     {
1008       ptid_t lwp;
1009
1010       lwp = thread_to_lwp (ptid, -2);
1011
1012       if (ptid_get_pid (lwp) == -1)
1013         xsnprintf (buf, sizeof (buf), "Thread %ld (defunct)",
1014                    ptid_get_tid (ptid));
1015       else if (ptid_get_pid (lwp) != -2)
1016         xsnprintf (buf, sizeof (buf), "Thread %ld (LWP %ld)",
1017                  ptid_get_tid (ptid), ptid_get_lwp (lwp));
1018       else
1019         xsnprintf (buf, sizeof (buf), "Thread %ld        ",
1020                    ptid_get_tid (ptid));
1021     }
1022   else if (ptid_get_lwp (ptid) != 0)
1023     xsnprintf (buf, sizeof (buf), "LWP    %ld        ", ptid_get_lwp (ptid));
1024   else
1025     xsnprintf (buf, sizeof (buf), "process %d    ", ptid_get_pid (ptid));
1026
1027   return buf;
1028 }
1029 \f
1030
1031 /* Worker bee for update_thread_list.  Callback function that gets
1032    called once per user-level thread (i.e. not for LWP's).  */
1033
1034 static int
1035 sol_update_thread_list_callback (const td_thrhandle_t *th, void *ignored)
1036 {
1037   td_err_e retval;
1038   td_thrinfo_t ti;
1039   ptid_t ptid;
1040
1041   retval = p_td_thr_get_info (th, &ti);
1042   if (retval != TD_OK)
1043     return -1;
1044
1045   ptid = ptid_build (ptid_get_pid (inferior_ptid), 0, ti.ti_tid);
1046   if (!in_thread_list (ptid) || is_exited (ptid))
1047     add_thread (ptid);
1048
1049   return 0;
1050 }
1051
1052 void
1053 sol_thread_target::update_thread_list ()
1054 {
1055   /* Delete dead threads.  */
1056   prune_threads ();
1057
1058   /* Find any new LWP's.  */
1059   beneath ()->update_thread_list ();
1060
1061   /* Then find any new user-level threads.  */
1062   p_td_ta_thr_iter (main_ta, sol_update_thread_list_callback, (void *) 0,
1063                     TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1064                     TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1065 }
1066
1067 /* Worker bee for the "info sol-thread" command.  This is a callback
1068    function that gets called once for each Solaris user-level thread
1069    (i.e. not for LWPs) in the inferior.  Print anything interesting
1070    that we can think of.  */
1071
1072 static int
1073 info_cb (const td_thrhandle_t *th, void *s)
1074 {
1075   td_err_e ret;
1076   td_thrinfo_t ti;
1077
1078   ret = p_td_thr_get_info (th, &ti);
1079   if (ret == TD_OK)
1080     {
1081       printf_filtered ("%s thread #%d, lwp %d, ",
1082                        ti.ti_type == TD_THR_SYSTEM ? "system" : "user  ",
1083                        ti.ti_tid, ti.ti_lid);
1084       switch (ti.ti_state)
1085         {
1086         default:
1087         case TD_THR_UNKNOWN:
1088           printf_filtered ("<unknown state>");
1089           break;
1090         case TD_THR_STOPPED:
1091           printf_filtered ("(stopped)");
1092           break;
1093         case TD_THR_RUN:
1094           printf_filtered ("(run)    ");
1095           break;
1096         case TD_THR_ACTIVE:
1097           printf_filtered ("(active) ");
1098           break;
1099         case TD_THR_ZOMBIE:
1100           printf_filtered ("(zombie) ");
1101           break;
1102         case TD_THR_SLEEP:
1103           printf_filtered ("(asleep) ");
1104           break;
1105         case TD_THR_STOPPED_ASLEEP:
1106           printf_filtered ("(stopped asleep)");
1107           break;
1108         }
1109       /* Print thr_create start function.  */
1110       if (ti.ti_startfunc != 0)
1111         {
1112           const struct bound_minimal_symbol msym
1113             = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
1114
1115           printf_filtered ("   startfunc=%s",
1116                            msym.minsym
1117                            ? MSYMBOL_PRINT_NAME (msym.minsym)
1118                            : paddress (target_gdbarch (), ti.ti_startfunc));
1119         }
1120
1121       /* If thread is asleep, print function that went to sleep.  */
1122       if (ti.ti_state == TD_THR_SLEEP)
1123         {
1124           const struct bound_minimal_symbol msym
1125             = lookup_minimal_symbol_by_pc (ti.ti_pc);
1126
1127           printf_filtered ("   sleepfunc=%s",
1128                            msym.minsym
1129                            ? MSYMBOL_PRINT_NAME (msym.minsym)
1130                            : paddress (target_gdbarch (), ti.ti_pc));
1131         }
1132
1133       printf_filtered ("\n");
1134     }
1135   else
1136     warning (_("info sol-thread: failed to get info for thread."));
1137
1138   return 0;
1139 }
1140
1141 /* List some state about each Solaris user-level thread in the
1142    inferior.  */
1143
1144 static void
1145 info_solthreads (const char *args, int from_tty)
1146 {
1147   p_td_ta_thr_iter (main_ta, info_cb, (void *) args,
1148                     TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1149                     TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1150 }
1151
1152 /* Callback routine used to find a thread based on the TID part of
1153    its PTID.  */
1154
1155 static int
1156 thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
1157 {
1158   long *tid = (long *) data;
1159
1160   if (ptid_get_tid (thread->ptid) == *tid)
1161     return 1;
1162
1163   return 0;
1164 }
1165
1166 ptid_t
1167 sol_thread_target::get_ada_task_ptid (long lwp, long thread)
1168 {
1169   struct thread_info *thread_info =
1170     iterate_over_threads (thread_db_find_thread_from_tid, &thread);
1171
1172   if (thread_info == NULL)
1173     {
1174       /* The list of threads is probably not up to date.  Find any
1175          thread that is missing from the list, and try again.  */
1176       update_thread_list ();
1177       thread_info = iterate_over_threads (thread_db_find_thread_from_tid,
1178                                           &thread);
1179     }
1180
1181   gdb_assert (thread_info != NULL);
1182
1183   return (thread_info->ptid);
1184 }
1185
1186 void
1187 _initialize_sol_thread (void)
1188 {
1189   void *dlhandle;
1190
1191   dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
1192   if (!dlhandle)
1193     goto die;
1194
1195 #define resolve(X) \
1196   if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X)))  \
1197     goto die;
1198
1199   resolve (td_log);
1200   resolve (td_ta_new);
1201   resolve (td_ta_delete);
1202   resolve (td_init);
1203   resolve (td_ta_get_ph);
1204   resolve (td_ta_get_nthreads);
1205   resolve (td_ta_tsd_iter);
1206   resolve (td_ta_thr_iter);
1207   resolve (td_thr_validate);
1208   resolve (td_thr_tsd);
1209   resolve (td_thr_get_info);
1210   resolve (td_thr_getfpregs);
1211   resolve (td_thr_getxregsize);
1212   resolve (td_thr_getxregs);
1213   resolve (td_thr_sigsetmask);
1214   resolve (td_thr_setprio);
1215   resolve (td_thr_setsigpending);
1216   resolve (td_thr_setfpregs);
1217   resolve (td_thr_setxregs);
1218   resolve (td_ta_map_id2thr);
1219   resolve (td_ta_map_lwp2thr);
1220   resolve (td_thr_getgregs);
1221   resolve (td_thr_setgregs);
1222
1223   add_cmd ("sol-threads", class_maintenance, info_solthreads,
1224            _("Show info on Solaris user threads."), &maintenanceinfolist);
1225
1226   /* Hook into new_objfile notification.  */
1227   gdb::observers::new_objfile.attach (sol_thread_new_objfile);
1228   return;
1229
1230  die:
1231   fprintf_unfiltered (gdb_stderr, "\
1232 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1233
1234   if (dlhandle)
1235     dlclose (dlhandle);
1236
1237   return;
1238 }