gdb/sol-thread.c

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