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 (thread_id.lwp_p ())
 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, thread_id.tid (), &th);
 309   if (val == TD_NOTHR)
 310     return ptid_t (-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 ptid_t (-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 ptid_t (default_lwp);
 324       error (_("thread_to_lwp: thread state not active: %s"),
 325              td_state_string (ti.ti_state));
 326     }
 327
 328   return ptid_t (thread_id.pid (), 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 (lwp.tid_p ())
 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 ptid_t (-1); /* Must be a defunct LPW.  */
 350
 351   val = p_td_ta_map_lwp2thr (main_ta, lwp.lwp (), &th);
 352   if (val == TD_NOTHR)
 353     return ptid_t (-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 ptid_t (-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_t (lwp.pid (), 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 = ptid_t (main_ph.ptid.pid ());
 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, main_ph.ptid.pid ());
 406   if (inferior_ptid.pid () == -1)
 407     inferior_ptid = procfs_first_available ();
 408
 409   if (ptid.pid () != -1)
 410     {
 411       ptid_t save_ptid = ptid;
 412
 413       ptid = thread_to_lwp (ptid, -2);
 414       if (ptid.pid () == -2)            /* Inactive thread.  */
 415         error (_("This version of Solaris can't start inactive threads."));
 416       if (info_verbose && ptid.pid () == -1)
 417         warning (_("Specified thread %ld seems to have terminated"),
 418                  save_ptid.tid ());
 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, main_ph.ptid.pid ());
 438   if (inferior_ptid.pid () == -1)
 439     inferior_ptid = procfs_first_available ();
 440
 441   if (ptid.pid () != -1)
 442     {
 443       ptid_t ptid_for_warning = ptid;
 444
 445       ptid = thread_to_lwp (ptid, -2);
 446       if (ptid.pid () == -2)            /* Inactive thread.  */
 447         error (_("This version of Solaris can't start inactive threads."));
 448       if (info_verbose && ptid.pid () == -1)
 449         warning (_("Specified thread %ld seems to have terminated"),
 450                  ptid_for_warning.tid ());
 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 (rtnval.pid () == -1)
 460         rtnval = save_ptid;
 461
 462       /* See if we have a new thread.  */
 463       if (rtnval.tid_p () && rtnval != save_ptid)
 464         {
 465           thread_info *thr = find_thread_ptid (rtnval);
 466           if (thr == NULL || thr->state == THREAD_EXITED)
 467             add_thread (rtnval);
 468         }
 469     }
 470
 471   /* During process initialization, we may get here without the thread
 472      package being initialized, since that can only happen after we've
 473      found the shared libs.  */
 474
 475   return rtnval;
 476 }
 477
 478 void
 479 sol_thread_target::fetch_registers (struct regcache *regcache, int regnum)
 480 {
 481   thread_t thread;
 482   td_thrhandle_t thandle;
 483   td_err_e val;
 484   prgregset_t gregset;
 485   prfpregset_t fpregset;
 486   gdb_gregset_t *gregset_p = &gregset;
 487   gdb_fpregset_t *fpregset_p = &fpregset;
 488   ptid_t ptid = regcache->ptid ();
 489
 490   if (!ptid.tid_p ())
 491     {
 492       /* It's an LWP; pass the request on to the layer beneath.  */
 493       beneath ()->fetch_registers (regcache, regnum);
 494       return;
 495     }
 496
 497   /* Solaris thread: convert PTID into a td_thrhandle_t.  */
 498   thread = ptid.tid ();
 499   if (thread == 0)
 500     error (_("sol_thread_fetch_registers: thread == 0"));
 501
 502   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
 503   if (val != TD_OK)
 504     error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
 505            td_err_string (val));
 506
 507   /* Get the general-purpose registers.  */
 508
 509   val = p_td_thr_getgregs (&thandle, gregset);
 510   if (val != TD_OK && val != TD_PARTIALREG)
 511     error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
 512            td_err_string (val));
 513
 514   /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
 515      and %sp are saved (by a thread context switch).  */
 516
 517   /* And, now the floating-point registers.  */
 518
 519   val = p_td_thr_getfpregs (&thandle, &fpregset);
 520   if (val != TD_OK && val != TD_NOFPREGS)
 521     error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
 522            td_err_string (val));
 523
 524   /* Note that we must call supply_gregset and supply_fpregset *after*
 525      calling the td routines because the td routines call ps_lget*
 526      which affect the values stored in the registers array.  */
 527
 528   supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);
 529   supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
 530 }
 531
 532 void
 533 sol_thread_target::store_registers (struct regcache *regcache, int regnum)
 534 {
 535   thread_t thread;
 536   td_thrhandle_t thandle;
 537   td_err_e val;
 538   prgregset_t gregset;
 539   prfpregset_t fpregset;
 540   ptid_t ptid = regcache->ptid ();
 541
 542   if (!ptid.tid_p ())
 543     {
 544       /* It's an LWP; pass the request on to the layer beneath.  */
 545       beneath ()->store_registers (regcache, regnum);
 546       return;
 547     }
 548
 549   /* Solaris thread: convert PTID into a td_thrhandle_t.  */
 550   thread = ptid.tid ();
 551
 552   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
 553   if (val != TD_OK)
 554     error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
 555            td_err_string (val));
 556
 557   if (regnum != -1)
 558     {
 559       val = p_td_thr_getgregs (&thandle, gregset);
 560       if (val != TD_OK)
 561         error (_("sol_thread_store_registers: td_thr_getgregs %s"),
 562                td_err_string (val));
 563       val = p_td_thr_getfpregs (&thandle, &fpregset);
 564       if (val != TD_OK)
 565         error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
 566                td_err_string (val));
 567     }
 568
 569   fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
 570   fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
 571
 572   val = p_td_thr_setgregs (&thandle, gregset);
 573   if (val != TD_OK)
 574     error (_("sol_thread_store_registers: td_thr_setgregs %s"),
 575            td_err_string (val));
 576   val = p_td_thr_setfpregs (&thandle, &fpregset);
 577   if (val != TD_OK)
 578     error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
 579            td_err_string (val));
 580 }
 581
 582 /* Perform partial transfers on OBJECT.  See target_read_partial and
 583    target_write_partial for details of each variant.  One, and only
 584    one, of readbuf or writebuf must be non-NULL.  */
 585
 586 enum target_xfer_status
 587 sol_thread_target::xfer_partial (enum target_object object,
 588                                  const char *annex, gdb_byte *readbuf,
 589                                  const gdb_byte *writebuf,
 590                                  ULONGEST offset, ULONGEST len,
 591                                  ULONGEST *xfered_len)
 592 {
 593   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 594
 595   if (inferior_ptid.tid_p () || !target_thread_alive (inferior_ptid))
 596     {
 597       /* It's either a thread or an LWP that isn't alive.  Any live
 598          LWP will do so use the first available.
 599
 600          NOTE: We don't need to call switch_to_thread; we're just
 601          reading memory.  */
 602       inferior_ptid = procfs_first_available ();
 603     }
 604
 605   return beneath ()->xfer_partial (object, annex, readbuf,
 606                                    writebuf, offset, len, xfered_len);
 607 }
 608
 609 static void
 610 check_for_thread_db (void)
 611 {
 612   td_err_e err;
 613   ptid_t ptid;
 614
 615   /* Don't attempt to use thread_db for remote targets.  */
 616   if (!(target_can_run () || core_bfd))
 617     return;
 618
 619   /* Do nothing if we couldn't load libthread_db.so.1.  */
 620   if (p_td_ta_new == NULL)
 621     return;
 622
 623   if (sol_thread_active)
 624     /* Nothing to do.  The thread library was already detected and the
 625        target vector was already activated.  */
 626     return;
 627
 628   /* Now, initialize libthread_db.  This needs to be done after the
 629      shared libraries are located because it needs information from
 630      the user's thread library.  */
 631
 632   err = p_td_init ();
 633   if (err != TD_OK)
 634     {
 635       warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err));
 636       return;
 637     }
 638
 639   /* Now attempt to open a connection to the thread library.  */
 640   err = p_td_ta_new (&main_ph, &main_ta);
 641   switch (err)
 642     {
 643     case TD_NOLIBTHREAD:
 644       /* No thread library was detected.  */
 645       break;
 646
 647     case TD_OK:
 648       printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
 649
 650       /* The thread library was detected.  Activate the sol_thread target.  */
 651       push_target (&sol_thread_ops);
 652       sol_thread_active = 1;
 653
 654       main_ph.ptid = inferior_ptid; /* Save for xfer_memory.  */
 655       ptid = lwp_to_thread (inferior_ptid);
 656       if (ptid.pid () != -1)
 657         inferior_ptid = ptid;
 658
 659       target_update_thread_list ();
 660       break;
 661
 662     default:
 663       warning (_("Cannot initialize thread debugging library: %s"),
 664                td_err_string (err));
 665       break;
 666     }
 667 }
 668
 669 /* This routine is called whenever a new symbol table is read in, or
 670    when all symbol tables are removed.  libthread_db can only be
 671    initialized when it finds the right variables in libthread.so.
 672    Since it's a shared library, those variables don't show up until
 673    the library gets mapped and the symbol table is read in.  */
 674
 675 static void
 676 sol_thread_new_objfile (struct objfile *objfile)
 677 {
 678   if (objfile != NULL)
 679     check_for_thread_db ();
 680 }
 681
 682 /* Clean up after the inferior dies.  */
 683
 684 void
 685 sol_thread_target::mourn_inferior ()
 686 {
 687   target_ops *beneath = this->beneath ();
 688
 689   sol_thread_active = 0;
 690
 691   unpush_target (this);
 692
 693   beneath->mourn_inferior ();
 694 }
 695
 696 /* Return true if PTID is still active in the inferior.  */
 697
 698 bool
 699 sol_thread_target::thread_alive (ptid_t ptid)
 700 {
 701   if (ptid.tid_p ())
 702     {
 703       /* It's a (user-level) thread.  */
 704       td_err_e val;
 705       td_thrhandle_t th;
 706       int pid;
 707
 708       pid = ptid.tid ();
 709       val = p_td_ta_map_id2thr (main_ta, pid, &th);
 710       if (val != TD_OK)
 711         return false;           /* Thread not found.  */
 712       val = p_td_thr_validate (&th);
 713       if (val != TD_OK)
 714         return false;           /* Thread not valid.  */
 715       return true;              /* Known thread.  */
 716     }
 717   else
 718     {
 719       /* It's an LPW; pass the request on to the layer below.  */
 720       return beneath ()->thread_alive (ptid);
 721     }
 722 }
 723
 724 \f
 725 /* These routines implement the lower half of the thread_db interface,
 726    i.e. the ps_* routines.  */
 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 (struct ps_prochandle *ph)
 737 {
 738   return PS_OK;
 739 }
 740
 741 /* Process continue.  */
 742
 743 ps_err_e
 744 ps_pcontinue (struct ps_prochandle *ph)
 745 {
 746   return PS_OK;
 747 }
 748
 749 /* LWP stop.  */
 750
 751 ps_err_e
 752 ps_lstop (struct ps_prochandle *ph, lwpid_t lwpid)
 753 {
 754   return PS_OK;
 755 }
 756
 757 /* LWP continue.  */
 758
 759 ps_err_e
 760 ps_lcontinue (struct ps_prochandle *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 (struct ps_prochandle *ph, const char *ld_object_name,
 769                    const char *ld_symbol_name, psaddr_t *ld_symbol_addr)
 770 {
 771   struct bound_minimal_symbol ms;
 772
 773   ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
 774   if (!ms.minsym)
 775     return PS_NOSYM;
 776
 777   *ld_symbol_addr = BMSYMBOL_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, psaddr_t addr,
 785            gdb_byte *buf, int size)
 786 {
 787   int ret;
 788
 789   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 790
 791   if (inferior_ptid.tid_p () || !target_thread_alive (inferior_ptid))
 792     {
 793       /* It's either a thread or an LWP that isn't alive.  Any live
 794          LWP will do so use the first available.
 795
 796          NOTE: We don't need to call switch_to_thread; we're just
 797          reading memory.  */
 798       inferior_ptid = procfs_first_available ();
 799     }
 800
 801 #if defined (__sparcv9)
 802   /* For Sparc64 cross Sparc32, make sure the address has not been
 803      accidentally sign-extended (or whatever) to beyond 32 bits.  */
 804   if (bfd_get_arch_size (exec_bfd) == 32)
 805     addr &= 0xffffffff;
 806 #endif
 807
 808   if (dowrite)
 809     ret = target_write_memory (addr, (gdb_byte *) buf, size);
 810   else
 811     ret = target_read_memory (addr, (gdb_byte *) buf, size);
 812
 813   return (ret == 0 ? PS_OK : PS_ERR);
 814 }
 815
 816 /* Copies SIZE bytes from target process .data segment to debugger memory.  */
 817
 818 ps_err_e
 819 ps_pdread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
 820 {
 821   return rw_common (0, ph, addr, (gdb_byte *) buf, size);
 822 }
 823
 824 /* Copies SIZE bytes from debugger memory .data segment to target process.  */
 825
 826 ps_err_e
 827 ps_pdwrite (struct ps_prochandle *ph, psaddr_t addr,
 828             const void *buf, size_t size)
 829 {
 830   return rw_common (1, ph, addr, (gdb_byte *) buf, size);
 831 }
 832
 833 /* Copies SIZE bytes from target process .text segment to debugger memory.  */
 834
 835 ps_err_e
 836 ps_ptread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
 837 {
 838   return rw_common (0, ph, addr, (gdb_byte *) buf, size);
 839 }
 840
 841 /* Copies SIZE bytes from debugger memory .text segment to target process.  */
 842
 843 ps_err_e
 844 ps_ptwrite (struct ps_prochandle *ph, psaddr_t addr,
 845             const void *buf, size_t size)
 846 {
 847   return rw_common (1, ph, addr, (gdb_byte *) buf, size);
 848 }
 849
 850 /* Get general-purpose registers for LWP.  */
 851
 852 ps_err_e
 853 ps_lgetregs (struct ps_prochandle *ph, lwpid_t lwpid, prgregset_t gregset)
 854 {
 855   ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0);
 856   struct regcache *regcache
 857     = get_thread_arch_regcache (ptid, target_gdbarch ());
 858
 859   target_fetch_registers (regcache, -1);
 860   fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
 861
 862   return PS_OK;
 863 }
 864
 865 /* Set general-purpose registers for LWP.  */
 866
 867 ps_err_e
 868 ps_lsetregs (struct ps_prochandle *ph, lwpid_t lwpid,
 869              const prgregset_t gregset)
 870 {
 871   ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0);
 872   struct regcache *regcache
 873     = get_thread_arch_regcache (ptid, target_gdbarch ());
 874
 875   supply_gregset (regcache, (const gdb_gregset_t *) gregset);
 876   target_store_registers (regcache, -1);
 877
 878   return PS_OK;
 879 }
 880
 881 /* Log a message (sends to gdb_stderr).  */
 882
 883 void
 884 ps_plog (const char *fmt, ...)
 885 {
 886   va_list args;
 887
 888   va_start (args, fmt);
 889
 890   vfprintf_filtered (gdb_stderr, fmt, args);
 891 }
 892
 893 /* Get size of extra register set.  Currently a noop.  */
 894
 895 ps_err_e
 896 ps_lgetxregsize (struct ps_prochandle *ph, lwpid_t lwpid, int *xregsize)
 897 {
 898   return PS_OK;
 899 }
 900
 901 /* Get extra register set.  Currently a noop.  */
 902
 903 ps_err_e
 904 ps_lgetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
 905 {
 906   return PS_OK;
 907 }
 908
 909 /* Set extra register set.  Currently a noop.  */
 910
 911 ps_err_e
 912 ps_lsetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
 913 {
 914   return PS_OK;
 915 }
 916
 917 /* Get floating-point registers for LWP.  */
 918
 919 ps_err_e
 920 ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
 921                prfpregset_t *fpregset)
 922 {
 923   ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0);
 924   struct regcache *regcache
 925     = get_thread_arch_regcache (ptid, target_gdbarch ());
 926
 927   target_fetch_registers (regcache, -1);
 928   fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
 929
 930   return PS_OK;
 931 }
 932
 933 /* Set floating-point regs for LWP.  */
 934
 935 ps_err_e
 936 ps_lsetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
 937                const prfpregset_t * fpregset)
 938 {
 939   ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0);
 940   struct regcache *regcache
 941     = get_thread_arch_regcache (ptid, target_gdbarch ());
 942
 943   supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
 944   target_store_registers (regcache, -1);
 945
 946   return PS_OK;
 947 }
 948
 949 /* Identify process as 32-bit or 64-bit.  At the moment we're using
 950    BFD to do this.  There might be a more Solaris-specific
 951    (e.g. procfs) method, but this ought to work.  */
 952
 953 ps_err_e
 954 ps_pdmodel (struct ps_prochandle *ph, int *data_model)
 955 {
 956   if (exec_bfd == 0)
 957     *data_model = PR_MODEL_UNKNOWN;
 958   else if (bfd_get_arch_size (exec_bfd) == 32)
 959     *data_model = PR_MODEL_ILP32;
 960   else
 961     *data_model = PR_MODEL_LP64;
 962
 963   return PS_OK;
 964 }
 965
 966 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
 967
 968 /* Reads the local descriptor table of a LWP.
 969
 970    This function is necessary on x86-solaris only.  Without it, the loading
 971    of libthread_db would fail because of ps_lgetLDT being undefined.  */
 972
 973 ps_err_e
 974 ps_lgetLDT (struct ps_prochandle *ph, lwpid_t lwpid, struct ssd *pldt)  /* ARI: editCase function */
 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 (inferior_ptid.pid () <= 0 || lwpid <= 0)
 983     return PS_BADLID;
 984
 985   ret = procfs_find_LDT_entry (ptid_t (inferior_ptid.pid (),
 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 ())
1007     {
1008       ptid_t lwp;
1009
1010       lwp = thread_to_lwp (ptid, -2);
1011
1012       if (lwp.pid () == -1)
1013         xsnprintf (buf, sizeof (buf), "Thread %ld (defunct)",
1014                    ptid.tid ());
1015       else if (lwp.pid () != -2)
1016         xsnprintf (buf, sizeof (buf), "Thread %ld (LWP %ld)",
1017                  ptid.tid (), lwp.lwp ());
1018       else
1019         xsnprintf (buf, sizeof (buf), "Thread %ld        ",
1020                    ptid.tid ());
1021     }
1022   else if (ptid.lwp () != 0)
1023     xsnprintf (buf, sizeof (buf), "LWP    %ld        ", ptid.lwp ());
1024   else
1025     xsnprintf (buf, sizeof (buf), "process %d    ", ptid.pid ());
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
1040   retval = p_td_thr_get_info (th, &ti);
1041   if (retval != TD_OK)
1042     return -1;
1043
1044   ptid_t ptid = ptid_t (inferior_ptid.pid (), 0, ti.ti_tid);
1045   thread_info *thr = find_thread_ptid (ptid);
1046   if (thr == NULL || thr->state == THREAD_EXITED)
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 (thread->ptid.tid () == *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 }