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 ()
 464           && 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 ())
 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   ptid_t ptid;
1039
1040   retval = p_td_thr_get_info (th, &ti);
1041   if (retval != TD_OK)
1042     return -1;
1043
1044   ptid = ptid_t (inferior_ptid.pid (), 0, ti.ti_tid);
1045   if (!in_thread_list (ptid) || is_exited (ptid))
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 }