gdb/sol-thread.c

   1 /* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
   3    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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 /* This module implements a sort of half target that sits between the
  23    machine-independent parts of GDB and the /proc interface (procfs.c) to
  24    provide access to the Solaris user-mode thread implementation.
  25
  26    Solaris threads are true user-mode threads, which are invoked via the thr_*
  27    and pthread_* (native and Posix respectivly) interfaces.  These are mostly
  28    implemented in user-space, with all thread context kept in various
  29    structures that live in the user's heap.  These should not be confused with
  30    lightweight processes (LWPs), which are implemented by the kernel, and
  31    scheduled without explicit intervention by the process.
  32
  33    Just to confuse things a little, Solaris threads (both native and Posix) are
  34    actually implemented using LWPs.  In general, there are going to be more
  35    threads than LWPs.  There is no fixed correspondence between a thread and an
  36    LWP.  When a thread wants to run, it gets scheduled onto the first available
  37    LWP and can 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 called
  41    libthread_db.so.1 (not to be confused with libthread_db.so.0, which doesn't
  42    have a published interface).  This interface has an upper part, which it
  43    provides, and a lower part which I provide.  The upper part consists of the
  44    td_* routines, which allow me to find all the threads, query their state,
  45    etc...  The lower part consists of all of the ps_*, which are used by the
  46    td_* routines to read/write memory, manipulate LWPs, lookup symbols, etc...
  47    The ps_* routines actually do most of their work by calling functions in
  48    procfs.c.  */
  49
  50 #include "defs.h"
  51 #include <thread.h>
  52 #include <proc_service.h>
  53 #include <thread_db.h>
  54 #include "gdbthread.h"
  55 #include "target.h"
  56 #include "inferior.h"
  57 #include <fcntl.h>
  58 #include <sys/stat.h>
  59 #include <dlfcn.h>
  60 #include "gdbcmd.h"
  61 #include "gdbcore.h"
  62 #include "regcache.h"
  63 #include "symfile.h"
  64
  65 extern struct target_ops sol_thread_ops;        /* Forward declaration */
  66 extern struct target_ops sol_core_ops;  /* Forward declaration */
  67
  68 /* place to store core_ops before we overwrite it */
  69 static struct target_ops orig_core_ops;
  70
  71 struct target_ops sol_thread_ops;
  72 struct target_ops sol_core_ops;
  73
  74 extern int procfs_suppress_run;
  75 extern struct target_ops procfs_ops;    /* target vector for procfs.c */
  76 extern struct target_ops core_ops;      /* target vector for corelow.c */
  77 extern char *procfs_pid_to_str (ptid_t ptid);
  78
  79 /* Prototypes for supply_gregset etc. */
  80 #include "gregset.h"
  81
  82 /* This struct is defined by us, but mainly used for the proc_service interface.
  83    We don't have much use for it, except as a handy place to get a real pid
  84    for memory accesses.  */
  85
  86 struct ps_prochandle
  87   {
  88     ptid_t ptid;
  89   };
  90
  91 struct string_map
  92   {
  93     int num;
  94     char *str;
  95   };
  96
  97 static struct ps_prochandle main_ph;
  98 static td_thragent_t *main_ta;
  99 static int sol_thread_active = 0;
 100
 101 static char *td_err_string (td_err_e errcode);
 102 static char *td_state_string (td_thr_state_e statecode);
 103 static ptid_t thread_to_lwp (ptid_t thread_id, int default_lwp);
 104 static void sol_thread_resume (ptid_t ptid, int step, enum target_signal signo);
 105 static ptid_t lwp_to_thread (ptid_t lwp);
 106 static int sol_thread_alive (ptid_t ptid);
 107 static void sol_core_close (int quitting);
 108
 109 static void init_sol_thread_ops (void);
 110 static void init_sol_core_ops (void);
 111
 112 /* Default definitions: These must be defined in tm.h
 113    if they are to be shared with a process module such as procfs.  */
 114
 115 #define GET_PID(ptid)           ptid_get_pid (ptid)
 116 #define GET_LWP(ptid)           ptid_get_lwp (ptid)
 117 #define GET_THREAD(ptid)        ptid_get_tid (ptid)
 118
 119 #define is_lwp(ptid)            (GET_LWP (ptid) != 0)
 120 #define is_thread(ptid)         (GET_THREAD (ptid) != 0)
 121
 122 #define BUILD_LWP(lwp, pid)     ptid_build (pid, lwp, 0)
 123 #define BUILD_THREAD(tid, pid)  ptid_build (pid, 0, tid)
 124
 125 /* Pointers to routines from lithread_db resolved by dlopen() */
 126
 127 static void     (*p_td_log)               (const int on_off);
 128 static td_err_e (*p_td_ta_new)            (const struct ps_prochandle * ph_p,
 129                                            td_thragent_t ** ta_pp);
 130 static td_err_e (*p_td_ta_delete)         (td_thragent_t * ta_p);
 131 static td_err_e (*p_td_init)              (void);
 132 static td_err_e (*p_td_ta_get_ph)         (const td_thragent_t * ta_p,
 133                                            struct ps_prochandle ** ph_pp);
 134 static td_err_e (*p_td_ta_get_nthreads)   (const td_thragent_t * ta_p,
 135                                            int *nthread_p);
 136 static td_err_e (*p_td_ta_tsd_iter)       (const td_thragent_t * ta_p,
 137                                            td_key_iter_f * cb,
 138                                            void *cbdata_p);
 139 static td_err_e (*p_td_ta_thr_iter)       (const td_thragent_t * ta_p,
 140                                            td_thr_iter_f * cb,
 141                                            void *cbdata_p,
 142                                            td_thr_state_e state,
 143                                            int ti_pri,
 144                                            sigset_t * ti_sigmask_p,
 145                                            unsigned ti_user_flags);
 146 static td_err_e (*p_td_thr_validate)      (const td_thrhandle_t * th_p);
 147 static td_err_e (*p_td_thr_tsd)           (const td_thrhandle_t * th_p,
 148                                            const thread_key_t key,
 149                                            void **data_pp);
 150 static td_err_e (*p_td_thr_get_info)      (const td_thrhandle_t * th_p,
 151                                            td_thrinfo_t * ti_p);
 152 static td_err_e (*p_td_thr_getfpregs)     (const td_thrhandle_t * th_p,
 153                                            prfpregset_t * fpregset);
 154 static td_err_e (*p_td_thr_getxregsize)   (const td_thrhandle_t * th_p,
 155                                            int *xregsize);
 156 static td_err_e (*p_td_thr_getxregs)      (const td_thrhandle_t * th_p,
 157                                            const caddr_t xregset);
 158 static td_err_e (*p_td_thr_sigsetmask)    (const td_thrhandle_t * th_p,
 159                                            const sigset_t ti_sigmask);
 160 static td_err_e (*p_td_thr_setprio)       (const td_thrhandle_t * th_p,
 161                                            const int ti_pri);
 162 static td_err_e (*p_td_thr_setsigpending) (const td_thrhandle_t * th_p,
 163                                            const uchar_t ti_pending_flag,
 164                                            const sigset_t ti_pending);
 165 static td_err_e (*p_td_thr_setfpregs)     (const td_thrhandle_t * th_p,
 166                                            const prfpregset_t * fpregset);
 167 static td_err_e (*p_td_thr_setxregs)      (const td_thrhandle_t * th_p,
 168                                            const caddr_t xregset);
 169 static td_err_e (*p_td_ta_map_id2thr)     (const td_thragent_t * ta_p,
 170                                            thread_t tid,
 171                                            td_thrhandle_t * th_p);
 172 static td_err_e (*p_td_ta_map_lwp2thr)    (const td_thragent_t * ta_p,
 173                                            lwpid_t lwpid,
 174                                            td_thrhandle_t * th_p);
 175 static td_err_e (*p_td_thr_getgregs)      (const td_thrhandle_t * th_p,
 176                                            prgregset_t regset);
 177 static td_err_e (*p_td_thr_setgregs)      (const td_thrhandle_t * th_p,
 178                                            const prgregset_t regset);
 179
 180 /*
 181
 182    LOCAL FUNCTION
 183
 184    td_err_string - Convert a thread_db error code to a string
 185
 186    SYNOPSIS
 187
 188    char * td_err_string (errcode)
 189
 190    DESCRIPTION
 191
 192    Return the thread_db error string associated with errcode.  If errcode
 193    is unknown, then return a message.
 194
 195  */
 196
 197 static char *
 198 td_err_string (td_err_e errcode)
 199 {
 200   static struct string_map
 201     td_err_table[] =
 202   {
 203     {TD_OK, "generic \"call succeeded\""},
 204     {TD_ERR, "generic error."},
 205     {TD_NOTHR, "no thread can be found to satisfy query"},
 206     {TD_NOSV, "no synch. variable can be found to satisfy query"},
 207     {TD_NOLWP, "no lwp can be found to satisfy query"},
 208     {TD_BADPH, "invalid process handle"},
 209     {TD_BADTH, "invalid thread handle"},
 210     {TD_BADSH, "invalid synchronization handle"},
 211     {TD_BADTA, "invalid thread agent"},
 212     {TD_BADKEY, "invalid key"},
 213     {TD_NOMSG, "td_thr_event_getmsg() called when there was no message"},
 214     {TD_NOFPREGS, "FPU register set not available for given thread"},
 215     {TD_NOLIBTHREAD, "application not linked with libthread"},
 216     {TD_NOEVENT, "requested event is not supported"},
 217     {TD_NOCAPAB, "capability not available"},
 218     {TD_DBERR, "Debugger service failed"},
 219     {TD_NOAPLIC, "Operation not applicable to"},
 220     {TD_NOTSD, "No thread specific data for this thread"},
 221     {TD_MALLOC, "Malloc failed"},
 222     {TD_PARTIALREG, "Only part of register set was written/read"},
 223     {TD_NOXREGS, "X register set not available for given thread"}
 224   };
 225   const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
 226   int i;
 227   static char buf[50];
 228
 229   for (i = 0; i < td_err_size; i++)
 230     if (td_err_table[i].num == errcode)
 231       return td_err_table[i].str;
 232
 233   sprintf (buf, "Unknown thread_db error code: %d", errcode);
 234
 235   return buf;
 236 }
 237 \f
 238 /*
 239
 240    LOCAL FUNCTION
 241
 242    td_state_string - Convert a thread_db state code to a string
 243
 244    SYNOPSIS
 245
 246    char * td_state_string (statecode)
 247
 248    DESCRIPTION
 249
 250    Return the thread_db state string associated with statecode.  If
 251    statecode is unknown, then return a message.
 252
 253  */
 254
 255 static char *
 256 td_state_string (td_thr_state_e statecode)
 257 {
 258   static struct string_map
 259     td_thr_state_table[] =
 260   {
 261     {TD_THR_ANY_STATE, "any state"},
 262     {TD_THR_UNKNOWN, "unknown"},
 263     {TD_THR_STOPPED, "stopped"},
 264     {TD_THR_RUN, "run"},
 265     {TD_THR_ACTIVE, "active"},
 266     {TD_THR_ZOMBIE, "zombie"},
 267     {TD_THR_SLEEP, "sleep"},
 268     {TD_THR_STOPPED_ASLEEP, "stopped asleep"}
 269   };
 270   const int td_thr_state_table_size = sizeof td_thr_state_table / sizeof (struct string_map);
 271   int i;
 272   static char buf[50];
 273
 274   for (i = 0; i < td_thr_state_table_size; i++)
 275     if (td_thr_state_table[i].num == statecode)
 276       return td_thr_state_table[i].str;
 277
 278   sprintf (buf, "Unknown thread_db state code: %d", statecode);
 279
 280   return buf;
 281 }
 282 \f
 283 /*
 284
 285    LOCAL FUNCTION
 286
 287    thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
 288
 289    SYNOPSIS
 290
 291    tpid_t thread_to_lwp (thread_id, default_lwp)
 292
 293    DESCRIPTION
 294
 295    This function converts a Posix or Solaris thread id to a lightweight
 296    process id.  If thread_id is non-existent, that's an error.  If it's
 297    an inactive thread, then we return default_lwp.
 298
 299    NOTES
 300
 301    This function probably shouldn't call error()...
 302
 303  */
 304
 305 static ptid_t
 306 thread_to_lwp (ptid_t thread_id, int default_lwp)
 307 {
 308   td_thrinfo_t ti;
 309   td_thrhandle_t th;
 310   td_err_e val;
 311
 312   if (is_lwp (thread_id))
 313     return thread_id;           /* It's already an LWP id */
 314
 315   /* It's a thread.  Convert to lwp */
 316
 317   val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th);
 318   if (val == TD_NOTHR)
 319     return pid_to_ptid (-1);            /* thread must have terminated */
 320   else if (val != TD_OK)
 321     error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val));
 322
 323   val = p_td_thr_get_info (&th, &ti);
 324   if (val == TD_NOTHR)
 325     return pid_to_ptid (-1);            /* thread must have terminated */
 326   else if (val != TD_OK)
 327     error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val));
 328
 329   if (ti.ti_state != TD_THR_ACTIVE)
 330     {
 331       if (default_lwp != -1)
 332         return pid_to_ptid (default_lwp);
 333       error ("thread_to_lwp: thread state not active: %s",
 334              td_state_string (ti.ti_state));
 335     }
 336
 337   return BUILD_LWP (ti.ti_lid, PIDGET (thread_id));
 338 }
 339 \f
 340 /*
 341
 342    LOCAL FUNCTION
 343
 344    lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
 345
 346    SYNOPSIS
 347
 348    int lwp_to_thread (lwp_id)
 349
 350    DESCRIPTION
 351
 352    This function converts a lightweight process id to a Posix or Solaris
 353    thread id.  If thread_id is non-existent, that's an error.
 354
 355    NOTES
 356
 357    This function probably shouldn't call error()...
 358
 359  */
 360
 361 static ptid_t
 362 lwp_to_thread (ptid_t lwp)
 363 {
 364   td_thrinfo_t ti;
 365   td_thrhandle_t th;
 366   td_err_e val;
 367
 368   if (is_thread (lwp))
 369     return lwp;                 /* It's already a thread id */
 370
 371   /* It's an lwp.  Convert it to a thread id.  */
 372
 373   if (!sol_thread_alive (lwp))
 374     return pid_to_ptid (-1);    /* defunct lwp */
 375
 376   val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);
 377   if (val == TD_NOTHR)
 378     return pid_to_ptid (-1);    /* thread must have terminated */
 379   else if (val != TD_OK)
 380     error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val));
 381
 382   val = p_td_thr_validate (&th);
 383   if (val == TD_NOTHR)
 384     return lwp;                 /* libthread doesn't know about it;
 385                                    just return lwp */
 386   else if (val != TD_OK)
 387     error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val));
 388
 389   val = p_td_thr_get_info (&th, &ti);
 390   if (val == TD_NOTHR)
 391     return pid_to_ptid (-1);    /* thread must have terminated */
 392   else if (val != TD_OK)
 393     error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val));
 394
 395   return BUILD_THREAD (ti.ti_tid, PIDGET (lwp));
 396 }
 397 \f
 398
 399 /* Most target vector functions from here on actually just pass through to
 400    procfs.c, as they don't need to do anything specific for threads.  */
 401
 402
 403 /* ARGSUSED */
 404 static void
 405 sol_thread_open (char *arg, int from_tty)
 406 {
 407   procfs_ops.to_open (arg, from_tty);
 408 }
 409
 410 /* Attach to process PID, then initialize for debugging it
 411    and wait for the trace-trap that results from attaching.  */
 412
 413 static void
 414 sol_thread_attach (char *args, int from_tty)
 415 {
 416   procfs_ops.to_attach (args, from_tty);
 417
 418   /* Must get symbols from solibs before libthread_db can run! */
 419   SOLIB_ADD ((char *) 0, from_tty, (struct target_ops *) 0, auto_solib_add);
 420
 421   if (sol_thread_active)
 422     {
 423       printf_filtered ("sol-thread active.\n");
 424       main_ph.ptid = inferior_ptid;             /* Save for xfer_memory */
 425       push_target (&sol_thread_ops);
 426       inferior_ptid = lwp_to_thread (inferior_ptid);
 427       if (PIDGET (inferior_ptid) == -1)
 428         inferior_ptid = main_ph.ptid;
 429       else
 430         add_thread (inferior_ptid);
 431     }
 432   /* XXX - might want to iterate over all the threads and register them. */
 433 }
 434
 435 /* Take a program previously attached to and detaches it.
 436    The program resumes execution and will no longer stop
 437    on signals, etc.  We'd better not have left any breakpoints
 438    in the program or it'll die when it hits one.  For this
 439    to work, it may be necessary for the process to have been
 440    previously attached.  It *might* work if the program was
 441    started via the normal ptrace (PTRACE_TRACEME).  */
 442
 443 static void
 444 sol_thread_detach (char *args, int from_tty)
 445 {
 446   inferior_ptid = pid_to_ptid (PIDGET (main_ph.ptid));
 447   unpush_target (&sol_thread_ops);
 448   procfs_ops.to_detach (args, from_tty);
 449 }
 450
 451 /* Resume execution of process PID.  If STEP is nozero, then
 452    just single step it.  If SIGNAL is nonzero, restart it with that
 453    signal activated.  We may have to convert pid from a thread-id to an LWP id
 454    for procfs.  */
 455
 456 static void
 457 sol_thread_resume (ptid_t ptid, int step, enum target_signal signo)
 458 {
 459   struct cleanup *old_chain;
 460
 461   old_chain = save_inferior_ptid ();
 462
 463   inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
 464   if (PIDGET (inferior_ptid) == -1)
 465     inferior_ptid = procfs_first_available ();
 466
 467   if (PIDGET (ptid) != -1)
 468     {
 469       ptid_t save_ptid = ptid;
 470
 471       ptid = thread_to_lwp (ptid, -2);
 472       if (PIDGET (ptid) == -2)          /* Inactive thread */
 473         error ("This version of Solaris can't start inactive threads.");
 474       if (info_verbose && PIDGET (ptid) == -1)
 475         warning ("Specified thread %ld seems to have terminated",
 476                  GET_THREAD (save_ptid));
 477     }
 478
 479   procfs_ops.to_resume (ptid, step, signo);
 480
 481   do_cleanups (old_chain);
 482 }
 483
 484 /* Wait for any threads to stop.  We may have to convert PID from a thread id
 485    to a LWP id, and vice versa on the way out.  */
 486
 487 static ptid_t
 488 sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 489 {
 490   ptid_t rtnval;
 491   ptid_t save_ptid;
 492   struct cleanup *old_chain;
 493
 494   save_ptid = inferior_ptid;
 495   old_chain = save_inferior_ptid ();
 496
 497   inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
 498   if (PIDGET (inferior_ptid) == -1)
 499     inferior_ptid = procfs_first_available ();
 500
 501   if (PIDGET (ptid) != -1)
 502     {
 503       ptid_t save_ptid = ptid;
 504
 505       ptid = thread_to_lwp (ptid, -2);
 506       if (PIDGET (ptid) == -2)          /* Inactive thread */
 507         error ("This version of Solaris can't start inactive threads.");
 508       if (info_verbose && PIDGET (ptid) == -1)
 509         warning ("Specified thread %ld seems to have terminated",
 510                  GET_THREAD (save_ptid));
 511     }
 512
 513   rtnval = procfs_ops.to_wait (ptid, ourstatus);
 514
 515   if (ourstatus->kind != TARGET_WAITKIND_EXITED)
 516     {
 517       /* Map the LWP of interest back to the appropriate thread ID */
 518       rtnval = lwp_to_thread (rtnval);
 519       if (PIDGET (rtnval) == -1)
 520         rtnval = save_ptid;
 521
 522       /* See if we have a new thread */
 523       if (is_thread (rtnval)
 524           && !ptid_equal (rtnval, save_ptid)
 525           && !in_thread_list (rtnval))
 526         {
 527           printf_filtered ("[New %s]\n", target_pid_to_str (rtnval));
 528           add_thread (rtnval);
 529         }
 530     }
 531
 532   /* During process initialization, we may get here without the thread package
 533      being initialized, since that can only happen after we've found the shared
 534      libs.  */
 535
 536   do_cleanups (old_chain);
 537
 538   return rtnval;
 539 }
 540
 541 static void
 542 sol_thread_fetch_registers (int regno)
 543 {
 544   thread_t thread;
 545   td_thrhandle_t thandle;
 546   td_err_e val;
 547   prgregset_t gregset;
 548   prfpregset_t fpregset;
 549 #if 0
 550   int xregsize;
 551   caddr_t xregset;
 552 #endif
 553
 554   if (!is_thread (inferior_ptid))
 555     {                           /* LWP: pass the request on to procfs.c */
 556       if (target_has_execution)
 557         procfs_ops.to_fetch_registers (regno);
 558       else
 559         orig_core_ops.to_fetch_registers (regno);
 560       return;
 561     }
 562
 563   /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
 564
 565   thread = GET_THREAD (inferior_ptid);
 566
 567   if (thread == 0)
 568     error ("sol_thread_fetch_registers:  thread == 0");
 569
 570   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
 571   if (val != TD_OK)
 572     error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
 573            td_err_string (val));
 574
 575   /* Get the integer regs */
 576
 577   val = p_td_thr_getgregs (&thandle, gregset);
 578   if (val != TD_OK
 579       && val != TD_PARTIALREG)
 580     error ("sol_thread_fetch_registers: td_thr_getgregs %s",
 581            td_err_string (val));
 582
 583   /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp
 584      are saved (by a thread context switch).  */
 585
 586   /* And, now the fp regs */
 587
 588   val = p_td_thr_getfpregs (&thandle, &fpregset);
 589   if (val != TD_OK
 590       && val != TD_NOFPREGS)
 591     error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
 592            td_err_string (val));
 593
 594 /* Note that we must call supply_{g fp}regset *after* calling the td routines
 595    because the td routines call ps_lget* which affect the values stored in the
 596    registers array.  */
 597
 598   supply_gregset  ((gdb_gregset_t *)  &gregset);
 599   supply_fpregset ((gdb_fpregset_t *) &fpregset);
 600
 601 #if 0
 602 /* thread_db doesn't seem to handle this right */
 603   val = td_thr_getxregsize (&thandle, &xregsize);
 604   if (val != TD_OK && val != TD_NOXREGS)
 605     error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
 606            td_err_string (val));
 607
 608   if (val == TD_OK)
 609     {
 610       xregset = alloca (xregsize);
 611       val = td_thr_getxregs (&thandle, xregset);
 612       if (val != TD_OK)
 613         error ("sol_thread_fetch_registers: td_thr_getxregs %s",
 614                td_err_string (val));
 615     }
 616 #endif
 617 }
 618
 619 static void
 620 sol_thread_store_registers (int regno)
 621 {
 622   thread_t thread;
 623   td_thrhandle_t thandle;
 624   td_err_e val;
 625   prgregset_t  gregset;
 626   prfpregset_t fpregset;
 627 #if 0
 628   int xregsize;
 629   caddr_t xregset;
 630 #endif
 631
 632   if (!is_thread (inferior_ptid))
 633     {                           /* LWP: pass the request on to procfs.c */
 634       procfs_ops.to_store_registers (regno);
 635       return;
 636     }
 637
 638   /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
 639
 640   thread = GET_THREAD (inferior_ptid);
 641
 642   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
 643   if (val != TD_OK)
 644     error ("sol_thread_store_registers: td_ta_map_id2thr %s",
 645            td_err_string (val));
 646
 647   if (regno != -1)
 648     {                           /* Not writing all the regs */
 649       /* save new register value */
 650       char* old_value = (char*) alloca (REGISTER_SIZE);
 651       memcpy (old_value, &deprecated_registers[REGISTER_BYTE (regno)],
 652               REGISTER_SIZE);
 653
 654       val = p_td_thr_getgregs (&thandle, gregset);
 655       if (val != TD_OK)
 656         error ("sol_thread_store_registers: td_thr_getgregs %s",
 657                td_err_string (val));
 658       val = p_td_thr_getfpregs (&thandle, &fpregset);
 659       if (val != TD_OK)
 660         error ("sol_thread_store_registers: td_thr_getfpregs %s",
 661                td_err_string (val));
 662
 663       /* restore new register value */
 664       memcpy (&deprecated_registers[REGISTER_BYTE (regno)], old_value,
 665               REGISTER_SIZE);
 666
 667 #if 0
 668 /* thread_db doesn't seem to handle this right */
 669       val = td_thr_getxregsize (&thandle, &xregsize);
 670       if (val != TD_OK && val != TD_NOXREGS)
 671         error ("sol_thread_store_registers: td_thr_getxregsize %s",
 672                td_err_string (val));
 673
 674       if (val == TD_OK)
 675         {
 676           xregset = alloca (xregsize);
 677           val = td_thr_getxregs (&thandle, xregset);
 678           if (val != TD_OK)
 679             error ("sol_thread_store_registers: td_thr_getxregs %s",
 680                    td_err_string (val));
 681         }
 682 #endif
 683     }
 684
 685   fill_gregset  ((gdb_gregset_t *)  &gregset,  regno);
 686   fill_fpregset ((gdb_fpregset_t *) &fpregset, regno);
 687
 688   val = p_td_thr_setgregs (&thandle, gregset);
 689   if (val != TD_OK)
 690     error ("sol_thread_store_registers: td_thr_setgregs %s",
 691            td_err_string (val));
 692   val = p_td_thr_setfpregs (&thandle, &fpregset);
 693   if (val != TD_OK)
 694     error ("sol_thread_store_registers: td_thr_setfpregs %s",
 695            td_err_string (val));
 696
 697 #if 0
 698 /* thread_db doesn't seem to handle this right */
 699   val = td_thr_getxregsize (&thandle, &xregsize);
 700   if (val != TD_OK && val != TD_NOXREGS)
 701     error ("sol_thread_store_registers: td_thr_getxregsize %s",
 702            td_err_string (val));
 703
 704   /* Should probably do something about writing the xregs here, but what are
 705      they? */
 706 #endif
 707 }
 708
 709 /* Get ready to modify the registers array.  On machines which store
 710    individual registers, this doesn't need to do anything.  On machines
 711    which store all the registers in one fell swoop, this makes sure
 712    that registers contains all the registers from the program being
 713    debugged.  */
 714
 715 static void
 716 sol_thread_prepare_to_store (void)
 717 {
 718   procfs_ops.to_prepare_to_store ();
 719 }
 720
 721 /* Transfer LEN bytes between GDB address MYADDR and target address
 722    MEMADDR.  If DOWRITE is non-zero, transfer them to the target,
 723    otherwise transfer them from the target.  TARGET is unused.
 724
 725    Returns the number of bytes transferred. */
 726
 727 static int
 728 sol_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite,
 729                         struct mem_attrib *attrib,
 730                         struct target_ops *target)
 731 {
 732   int retval;
 733   struct cleanup *old_chain;
 734
 735   old_chain = save_inferior_ptid ();
 736
 737   if (is_thread (inferior_ptid) ||      /* A thread */
 738       !target_thread_alive (inferior_ptid))     /* An lwp, but not alive */
 739     inferior_ptid = procfs_first_available ();  /* Find any live lwp.  */
 740   /* Note: don't need to call switch_to_thread; we're just reading memory.  */
 741
 742   if (target_has_execution)
 743     retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len,
 744                                         dowrite, attrib, target);
 745   else
 746     retval = orig_core_ops.to_xfer_memory (memaddr, myaddr, len,
 747                                            dowrite, attrib, target);
 748
 749   do_cleanups (old_chain);
 750
 751   return retval;
 752 }
 753
 754 /* Print status information about what we're accessing.  */
 755
 756 static void
 757 sol_thread_files_info (struct target_ops *ignore)
 758 {
 759   procfs_ops.to_files_info (ignore);
 760 }
 761
 762 static void
 763 sol_thread_kill_inferior (void)
 764 {
 765   procfs_ops.to_kill ();
 766 }
 767
 768 static void
 769 sol_thread_notice_signals (ptid_t ptid)
 770 {
 771   procfs_ops.to_notice_signals (pid_to_ptid (PIDGET (ptid)));
 772 }
 773
 774 /* Fork an inferior process, and start debugging it with /proc.  */
 775
 776 static void
 777 sol_thread_create_inferior (char *exec_file, char *allargs, char **env)
 778 {
 779   procfs_ops.to_create_inferior (exec_file, allargs, env);
 780
 781   if (sol_thread_active && !ptid_equal (inferior_ptid, null_ptid))
 782     {
 783       main_ph.ptid = inferior_ptid;     /* Save for xfer_memory */
 784
 785       push_target (&sol_thread_ops);
 786
 787       inferior_ptid = lwp_to_thread (inferior_ptid);
 788       if (PIDGET (inferior_ptid) == -1)
 789         inferior_ptid = main_ph.ptid;
 790
 791       if (!in_thread_list (inferior_ptid))
 792         add_thread (inferior_ptid);
 793     }
 794 }
 795
 796 /* This routine is called whenever a new symbol table is read in, or when all
 797    symbol tables are removed.  libthread_db can only be initialized when it
 798    finds the right variables in libthread.so.  Since it's a shared library,
 799    those variables don't show up until the library gets mapped and the symbol
 800    table is read in.  */
 801
 802 /* This new_objfile event is now managed by a chained function pointer.
 803  * It is the callee's responsability to call the next client on the chain.
 804  */
 805
 806 /* Saved pointer to previous owner of the new_objfile event. */
 807 static void (*target_new_objfile_chain) (struct objfile *);
 808
 809 void
 810 sol_thread_new_objfile (struct objfile *objfile)
 811 {
 812   td_err_e val;
 813
 814   if (!objfile)
 815     {
 816       sol_thread_active = 0;
 817       goto quit;
 818     }
 819
 820   /* don't do anything if init failed to resolve the libthread_db library */
 821   if (!procfs_suppress_run)
 822     goto quit;
 823
 824   /* Now, initialize the thread debugging library.  This needs to be done after
 825      the shared libraries are located because it needs information from the
 826      user's thread library.  */
 827
 828   val = p_td_init ();
 829   if (val != TD_OK)
 830     {
 831       warning ("sol_thread_new_objfile: td_init: %s", td_err_string (val));
 832       goto quit;
 833     }
 834
 835   val = p_td_ta_new (&main_ph, &main_ta);
 836   if (val == TD_NOLIBTHREAD)
 837     goto quit;
 838   else if (val != TD_OK)
 839     {
 840       warning ("sol_thread_new_objfile: td_ta_new: %s", td_err_string (val));
 841       goto quit;
 842     }
 843
 844   sol_thread_active = 1;
 845 quit:
 846   /* Call predecessor on chain, if any. */
 847   if (target_new_objfile_chain)
 848     target_new_objfile_chain (objfile);
 849 }
 850
 851 /* Clean up after the inferior dies.  */
 852
 853 static void
 854 sol_thread_mourn_inferior (void)
 855 {
 856   unpush_target (&sol_thread_ops);
 857   procfs_ops.to_mourn_inferior ();
 858 }
 859
 860 /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
 861
 862 static int
 863 sol_thread_can_run (void)
 864 {
 865   return procfs_suppress_run;
 866 }
 867
 868 /*
 869
 870    LOCAL FUNCTION
 871
 872    sol_thread_alive     - test thread for "aliveness"
 873
 874    SYNOPSIS
 875
 876    static bool sol_thread_alive (ptid_t ptid);
 877
 878    DESCRIPTION
 879
 880    returns true if thread still active in inferior.
 881
 882  */
 883
 884 static int
 885 sol_thread_alive (ptid_t ptid)
 886 {
 887   if (is_thread (ptid))         /* non-kernel thread */
 888     {
 889       td_err_e val;
 890       td_thrhandle_t th;
 891       int pid;
 892
 893       pid = GET_THREAD (ptid);
 894       if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
 895         return 0;               /* thread not found */
 896       if ((val = p_td_thr_validate (&th)) != TD_OK)
 897         return 0;               /* thread not valid */
 898       return 1;                 /* known thread: return true */
 899     }
 900   else
 901     /* kernel thread (LWP): let procfs test it */
 902     {
 903       if (target_has_execution)
 904         return procfs_ops.to_thread_alive (ptid);
 905       else
 906         return orig_core_ops.to_thread_alive (ptid);
 907     }
 908 }
 909
 910 static void
 911 sol_thread_stop (void)
 912 {
 913   procfs_ops.to_stop ();
 914 }
 915 \f
 916 /* These routines implement the lower half of the thread_db interface.  Ie: the
 917    ps_* routines.  */
 918
 919 /* Various versions of <proc_service.h> have slightly
 920    different function prototypes.  In particular, we have
 921
 922    NEWER                        OLDER
 923    struct ps_prochandle *       const struct ps_prochandle *
 924    void*                        char*
 925    const void*          char*
 926    int                  size_t
 927
 928    Which one you have depends on solaris version and what
 929    patches you've applied.  On the theory that there are
 930    only two major variants, we have configure check the
 931    prototype of ps_pdwrite (), and use that info to make
 932    appropriate typedefs here. */
 933
 934 #ifdef PROC_SERVICE_IS_OLD
 935 typedef const struct ps_prochandle *gdb_ps_prochandle_t;
 936 typedef char *gdb_ps_read_buf_t;
 937 typedef char *gdb_ps_write_buf_t;
 938 typedef int gdb_ps_size_t;
 939 typedef paddr_t gdb_ps_addr_t;
 940 #else
 941 typedef struct ps_prochandle *gdb_ps_prochandle_t;
 942 typedef void *gdb_ps_read_buf_t;
 943 typedef const void *gdb_ps_write_buf_t;
 944 typedef size_t gdb_ps_size_t;
 945 typedef psaddr_t gdb_ps_addr_t;
 946 #endif
 947
 948
 949 /* The next four routines are called by thread_db to tell us to stop and stop
 950    a particular process or lwp.  Since GDB ensures that these are all stopped
 951    by the time we call anything in thread_db, these routines need to do
 952    nothing.  */
 953
 954 /* Process stop */
 955
 956 ps_err_e
 957 ps_pstop (gdb_ps_prochandle_t ph)
 958 {
 959   return PS_OK;
 960 }
 961
 962 /* Process continue */
 963
 964 ps_err_e
 965 ps_pcontinue (gdb_ps_prochandle_t ph)
 966 {
 967   return PS_OK;
 968 }
 969
 970 /* LWP stop */
 971
 972 ps_err_e
 973 ps_lstop (gdb_ps_prochandle_t ph, lwpid_t lwpid)
 974 {
 975   return PS_OK;
 976 }
 977
 978 /* LWP continue */
 979
 980 ps_err_e
 981 ps_lcontinue (gdb_ps_prochandle_t ph, lwpid_t lwpid)
 982 {
 983   return PS_OK;
 984 }
 985
 986 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table.  */
 987
 988 ps_err_e
 989 ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *ld_object_name,
 990                    const char *ld_symbol_name, gdb_ps_addr_t * ld_symbol_addr)
 991 {
 992   struct minimal_symbol *ms;
 993
 994   ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
 995
 996   if (!ms)
 997     return PS_NOSYM;
 998
 999   *ld_symbol_addr = SYMBOL_VALUE_ADDRESS (ms);
1000
1001   return PS_OK;
1002 }
1003
1004 /* Common routine for reading and writing memory.  */
1005
1006 static ps_err_e
1007 rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr,
1008            char *buf, int size)
1009 {
1010   struct cleanup *old_chain;
1011
1012   old_chain = save_inferior_ptid ();
1013
1014   if (is_thread (inferior_ptid) ||      /* A thread */
1015       !target_thread_alive (inferior_ptid))     /* An lwp, but not alive */
1016     inferior_ptid = procfs_first_available ();  /* Find any live lwp.  */
1017   /* Note: don't need to call switch_to_thread; we're just reading memory.  */
1018
1019 #if defined (__sparcv9)
1020   /* For Sparc64 cross Sparc32, make sure the address has not been
1021      accidentally sign-extended (or whatever) to beyond 32 bits.  */
1022   if (bfd_get_arch_size (exec_bfd) == 32)
1023     addr &= 0xffffffff;
1024 #endif
1025
1026   while (size > 0)
1027     {
1028       int cc;
1029
1030       /* FIXME: passing 0 as attrib argument.  */
1031       if (target_has_execution)
1032         cc = procfs_ops.to_xfer_memory (addr, buf, size,
1033                                         dowrite, 0, &procfs_ops);
1034       else
1035         cc = orig_core_ops.to_xfer_memory (addr, buf, size,
1036                                            dowrite, 0, &core_ops);
1037
1038       if (cc < 0)
1039         {
1040           if (dowrite == 0)
1041             print_sys_errmsg ("rw_common (): read", errno);
1042           else
1043             print_sys_errmsg ("rw_common (): write", errno);
1044
1045           do_cleanups (old_chain);
1046
1047           return PS_ERR;
1048         }
1049       else if (cc == 0)
1050         {
1051           if (dowrite == 0)
1052             warning ("rw_common (): unable to read at addr 0x%lx",
1053                      (long) addr);
1054           else
1055             warning ("rw_common (): unable to write at addr 0x%lx",
1056                      (long) addr);
1057
1058           do_cleanups (old_chain);
1059
1060           return PS_ERR;
1061         }
1062
1063       size -= cc;
1064       buf += cc;
1065     }
1066
1067   do_cleanups (old_chain);
1068
1069   return PS_OK;
1070 }
1071
1072 /* Copies SIZE bytes from target process .data segment to debugger memory.  */
1073
1074 ps_err_e
1075 ps_pdread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1076            gdb_ps_read_buf_t buf, gdb_ps_size_t size)
1077 {
1078   return rw_common (0, ph, addr, buf, size);
1079 }
1080
1081 /* Copies SIZE bytes from debugger memory .data segment to target process.  */
1082
1083 ps_err_e
1084 ps_pdwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1085             gdb_ps_write_buf_t buf, gdb_ps_size_t size)
1086 {
1087   return rw_common (1, ph, addr, (char *) buf, size);
1088 }
1089
1090 /* Copies SIZE bytes from target process .text segment to debugger memory.  */
1091
1092 ps_err_e
1093 ps_ptread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1094            gdb_ps_read_buf_t buf, gdb_ps_size_t size)
1095 {
1096   return rw_common (0, ph, addr, buf, size);
1097 }
1098
1099 /* Copies SIZE bytes from debugger memory .text segment to target process.  */
1100
1101 ps_err_e
1102 ps_ptwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1103             gdb_ps_write_buf_t buf, gdb_ps_size_t size)
1104 {
1105   return rw_common (1, ph, addr, (char *) buf, size);
1106 }
1107
1108 /* Get integer regs for LWP */
1109
1110 ps_err_e
1111 ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1112              prgregset_t gregset)
1113 {
1114   struct cleanup *old_chain;
1115
1116   old_chain = save_inferior_ptid ();
1117
1118   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1119
1120   if (target_has_execution)
1121     procfs_ops.to_fetch_registers (-1);
1122   else
1123     orig_core_ops.to_fetch_registers (-1);
1124   fill_gregset ((gdb_gregset_t *) gregset, -1);
1125
1126   do_cleanups (old_chain);
1127
1128   return PS_OK;
1129 }
1130
1131 /* Set integer regs for LWP */
1132
1133 ps_err_e
1134 ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1135              const prgregset_t gregset)
1136 {
1137   struct cleanup *old_chain;
1138
1139   old_chain = save_inferior_ptid ();
1140
1141   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1142
1143   supply_gregset ((gdb_gregset_t *) gregset);
1144   if (target_has_execution)
1145     procfs_ops.to_store_registers (-1);
1146   else
1147     orig_core_ops.to_store_registers (-1);
1148
1149   do_cleanups (old_chain);
1150
1151   return PS_OK;
1152 }
1153
1154 /* Log a message (sends to gdb_stderr).  */
1155
1156 void
1157 ps_plog (const char *fmt,...)
1158 {
1159   va_list args;
1160
1161   va_start (args, fmt);
1162
1163   vfprintf_filtered (gdb_stderr, fmt, args);
1164 }
1165
1166 /* Get size of extra register set.  Currently a noop.  */
1167
1168 ps_err_e
1169 ps_lgetxregsize (gdb_ps_prochandle_t ph, lwpid_t lwpid, int *xregsize)
1170 {
1171 #if 0
1172   int lwp_fd;
1173   int regsize;
1174   ps_err_e val;
1175
1176   val = get_lwp_fd (ph, lwpid, &lwp_fd);
1177   if (val != PS_OK)
1178     return val;
1179
1180   if (ioctl (lwp_fd, PIOCGXREGSIZE, &regsize))
1181     {
1182       if (errno == EINVAL)
1183         return PS_NOFREGS;      /* XXX Wrong code, but this is the closest
1184                                    thing in proc_service.h  */
1185
1186       print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno);
1187       return PS_ERR;
1188     }
1189 #endif
1190
1191   return PS_OK;
1192 }
1193
1194 /* Get extra register set.  Currently a noop.  */
1195
1196 ps_err_e
1197 ps_lgetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
1198 {
1199 #if 0
1200   int lwp_fd;
1201   ps_err_e val;
1202
1203   val = get_lwp_fd (ph, lwpid, &lwp_fd);
1204   if (val != PS_OK)
1205     return val;
1206
1207   if (ioctl (lwp_fd, PIOCGXREG, xregset))
1208     {
1209       print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno);
1210       return PS_ERR;
1211     }
1212 #endif
1213
1214   return PS_OK;
1215 }
1216
1217 /* Set extra register set.  Currently a noop.  */
1218
1219 ps_err_e
1220 ps_lsetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
1221 {
1222 #if 0
1223   int lwp_fd;
1224   ps_err_e val;
1225
1226   val = get_lwp_fd (ph, lwpid, &lwp_fd);
1227   if (val != PS_OK)
1228     return val;
1229
1230   if (ioctl (lwp_fd, PIOCSXREG, xregset))
1231     {
1232       print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno);
1233       return PS_ERR;
1234     }
1235 #endif
1236
1237   return PS_OK;
1238 }
1239
1240 /* Get floating-point regs for LWP */
1241
1242 ps_err_e
1243 ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1244                prfpregset_t * fpregset)
1245 {
1246   struct cleanup *old_chain;
1247
1248   old_chain = save_inferior_ptid ();
1249
1250   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1251
1252   if (target_has_execution)
1253     procfs_ops.to_fetch_registers (-1);
1254   else
1255     orig_core_ops.to_fetch_registers (-1);
1256   fill_fpregset ((gdb_fpregset_t *) fpregset, -1);
1257
1258   do_cleanups (old_chain);
1259
1260   return PS_OK;
1261 }
1262
1263 /* Set floating-point regs for LWP */
1264
1265 ps_err_e
1266 ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1267                const prfpregset_t * fpregset)
1268 {
1269   struct cleanup *old_chain;
1270
1271   old_chain = save_inferior_ptid ();
1272
1273   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1274
1275   supply_fpregset ((gdb_fpregset_t *) fpregset);
1276   if (target_has_execution)
1277     procfs_ops.to_store_registers (-1);
1278   else
1279     orig_core_ops.to_store_registers (-1);
1280
1281   do_cleanups (old_chain);
1282
1283   return PS_OK;
1284 }
1285
1286 #ifdef PR_MODEL_LP64
1287 /* Identify process as 32-bit or 64-bit.
1288    At the moment I'm using bfd to do this.
1289    There might be a more solaris-specific (eg. procfs) method,
1290    but this ought to work.  */
1291
1292 ps_err_e
1293 ps_pdmodel (gdb_ps_prochandle_t ph, int *data_model)
1294 {
1295   if (exec_bfd == 0)
1296     *data_model = PR_MODEL_UNKNOWN;
1297   else if (bfd_get_arch_size (exec_bfd) == 32)
1298     *data_model = PR_MODEL_ILP32;
1299   else
1300     *data_model = PR_MODEL_LP64;
1301
1302   return PS_OK;
1303 }
1304 #endif /* PR_MODEL_LP64 */
1305
1306 #ifdef TM_I386SOL2_H
1307
1308 /* Reads the local descriptor table of a LWP.  */
1309
1310 ps_err_e
1311 ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1312             struct ssd *pldt)
1313 {
1314   /* NOTE: only used on Solaris, therefore OK to refer to procfs.c */
1315   extern struct ssd *procfs_find_LDT_entry (ptid_t);
1316   struct ssd *ret;
1317
1318   /* FIXME: can't I get the process ID from the prochandle or something?
1319    */
1320
1321   if (PIDGET (inferior_ptid) <= 0 || lwpid <= 0)
1322     return PS_BADLID;
1323
1324   ret = procfs_find_LDT_entry (BUILD_LWP (lwpid, PIDGET (inferior_ptid)));
1325   if (ret)
1326     {
1327       memcpy (pldt, ret, sizeof (struct ssd));
1328       return PS_OK;
1329     }
1330   else  /* LDT not found. */
1331     return PS_ERR;
1332 }
1333 #endif /* TM_I386SOL2_H */
1334 \f
1335 /* Convert a pid to printable form. */
1336
1337 char *
1338 solaris_pid_to_str (ptid_t ptid)
1339 {
1340   static char buf[100];
1341
1342   /* in case init failed to resolve the libthread_db library */
1343   if (!procfs_suppress_run)
1344     return procfs_pid_to_str (ptid);
1345
1346   if (is_thread (ptid))
1347     {
1348       ptid_t lwp;
1349
1350       lwp = thread_to_lwp (ptid, -2);
1351
1352       if (PIDGET (lwp) == -1)
1353         sprintf (buf, "Thread %ld (defunct)", GET_THREAD (ptid));
1354       else if (PIDGET (lwp) != -2)
1355         sprintf (buf, "Thread %ld (LWP %ld)", GET_THREAD (ptid), GET_LWP (lwp));
1356       else
1357         sprintf (buf, "Thread %ld        ", GET_THREAD (ptid));
1358     }
1359   else if (GET_LWP (ptid) != 0)
1360     sprintf (buf, "LWP    %ld        ", GET_LWP (ptid));
1361   else
1362     sprintf (buf, "process %d    ", PIDGET (ptid));
1363
1364   return buf;
1365 }
1366 \f
1367
1368 /* Worker bee for find_new_threads
1369    Callback function that gets called once per USER thread (i.e., not
1370    kernel) thread. */
1371
1372 static int
1373 sol_find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
1374 {
1375   td_err_e retval;
1376   td_thrinfo_t ti;
1377   ptid_t ptid;
1378
1379   if ((retval = p_td_thr_get_info (th, &ti)) != TD_OK)
1380     {
1381       return -1;
1382     }
1383   ptid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_ptid));
1384   if (!in_thread_list (ptid))
1385     add_thread (ptid);
1386
1387   return 0;
1388 }
1389
1390 static void
1391 sol_find_new_threads (void)
1392 {
1393   /* don't do anything if init failed to resolve the libthread_db library */
1394   if (!procfs_suppress_run)
1395     return;
1396
1397   if (PIDGET (inferior_ptid) == -1)
1398     {
1399       printf_filtered ("No process.\n");
1400       return;
1401     }
1402   procfs_ops.to_find_new_threads ();    /* first find new kernel threads */
1403   p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *) 0,
1404                     TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1405                     TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1406 }
1407
1408 static void
1409 sol_core_open (char *filename, int from_tty)
1410 {
1411   orig_core_ops.to_open (filename, from_tty);
1412 }
1413
1414 static void
1415 sol_core_close (int quitting)
1416 {
1417   orig_core_ops.to_close (quitting);
1418 }
1419
1420 static void
1421 sol_core_detach (char *args, int from_tty)
1422 {
1423   unpush_target (&core_ops);
1424   orig_core_ops.to_detach (args, from_tty);
1425 }
1426
1427 static void
1428 sol_core_files_info (struct target_ops *t)
1429 {
1430   orig_core_ops.to_files_info (t);
1431 }
1432
1433 /* Worker bee for info sol-thread command.  This is a callback function that
1434    gets called once for each Solaris thread (ie. not kernel thread) in the
1435    inferior.  Print anything interesting that we can think of.  */
1436
1437 static int
1438 info_cb (const td_thrhandle_t *th, void *s)
1439 {
1440   td_err_e ret;
1441   td_thrinfo_t ti;
1442
1443   if ((ret = p_td_thr_get_info (th, &ti)) == TD_OK)
1444     {
1445       printf_filtered ("%s thread #%d, lwp %d, ",
1446                        ti.ti_type == TD_THR_SYSTEM ? "system" : "user  ",
1447                        ti.ti_tid, ti.ti_lid);
1448       switch (ti.ti_state)
1449         {
1450         default:
1451         case TD_THR_UNKNOWN:
1452           printf_filtered ("<unknown state>");
1453           break;
1454         case TD_THR_STOPPED:
1455           printf_filtered ("(stopped)");
1456           break;
1457         case TD_THR_RUN:
1458           printf_filtered ("(run)    ");
1459           break;
1460         case TD_THR_ACTIVE:
1461           printf_filtered ("(active) ");
1462           break;
1463         case TD_THR_ZOMBIE:
1464           printf_filtered ("(zombie) ");
1465           break;
1466         case TD_THR_SLEEP:
1467           printf_filtered ("(asleep) ");
1468           break;
1469         case TD_THR_STOPPED_ASLEEP:
1470           printf_filtered ("(stopped asleep)");
1471           break;
1472         }
1473       /* Print thr_create start function: */
1474       if (ti.ti_startfunc != 0)
1475         {
1476           struct minimal_symbol *msym;
1477           msym = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
1478           if (msym)
1479             printf_filtered ("   startfunc: %s\n", SYMBOL_NAME (msym));
1480           else
1481             printf_filtered ("   startfunc: 0x%s\n", paddr (ti.ti_startfunc));
1482         }
1483
1484       /* If thread is asleep, print function that went to sleep: */
1485       if (ti.ti_state == TD_THR_SLEEP)
1486         {
1487           struct minimal_symbol *msym;
1488           msym = lookup_minimal_symbol_by_pc (ti.ti_pc);
1489           if (msym)
1490             printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym));
1491           else
1492             printf_filtered (" - Sleep func: 0x%s\n", paddr (ti.ti_startfunc));
1493         }
1494
1495       /* Wrap up line, if necessary */
1496       if (ti.ti_state != TD_THR_SLEEP && ti.ti_startfunc == 0)
1497         printf_filtered ("\n"); /* don't you hate counting newlines? */
1498     }
1499   else
1500     warning ("info sol-thread: failed to get info for thread.");
1501
1502   return 0;
1503 }
1504
1505 /* List some state about each Solaris user thread in the inferior.  */
1506
1507 static void
1508 info_solthreads (char *args, int from_tty)
1509 {
1510   p_td_ta_thr_iter (main_ta, info_cb, args,
1511                     TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1512                     TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1513 }
1514
1515 static int
1516 sol_find_memory_regions (int (*func) (CORE_ADDR,
1517                                       unsigned long,
1518                                       int, int, int,
1519                                       void *),
1520                          void *data)
1521 {
1522   return procfs_ops.to_find_memory_regions (func, data);
1523 }
1524
1525 static char *
1526 sol_make_note_section (bfd *obfd, int *note_size)
1527 {
1528   return procfs_ops.to_make_corefile_notes (obfd, note_size);
1529 }
1530
1531 static int
1532 ignore (CORE_ADDR addr, char *contents)
1533 {
1534   return 0;
1535 }
1536
1537
1538 static void
1539 init_sol_thread_ops (void)
1540 {
1541   sol_thread_ops.to_shortname = "solaris-threads";
1542   sol_thread_ops.to_longname = "Solaris threads and pthread.";
1543   sol_thread_ops.to_doc = "Solaris threads and pthread support.";
1544   sol_thread_ops.to_open = sol_thread_open;
1545   sol_thread_ops.to_attach = sol_thread_attach;
1546   sol_thread_ops.to_detach = sol_thread_detach;
1547   sol_thread_ops.to_resume = sol_thread_resume;
1548   sol_thread_ops.to_wait = sol_thread_wait;
1549   sol_thread_ops.to_fetch_registers = sol_thread_fetch_registers;
1550   sol_thread_ops.to_store_registers = sol_thread_store_registers;
1551   sol_thread_ops.to_prepare_to_store = sol_thread_prepare_to_store;
1552   sol_thread_ops.to_xfer_memory = sol_thread_xfer_memory;
1553   sol_thread_ops.to_files_info = sol_thread_files_info;
1554   sol_thread_ops.to_insert_breakpoint = memory_insert_breakpoint;
1555   sol_thread_ops.to_remove_breakpoint = memory_remove_breakpoint;
1556   sol_thread_ops.to_terminal_init = terminal_init_inferior;
1557   sol_thread_ops.to_terminal_inferior = terminal_inferior;
1558   sol_thread_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1559   sol_thread_ops.to_terminal_ours = terminal_ours;
1560   sol_thread_ops.to_terminal_save_ours = terminal_save_ours;
1561   sol_thread_ops.to_terminal_info = child_terminal_info;
1562   sol_thread_ops.to_kill = sol_thread_kill_inferior;
1563   sol_thread_ops.to_create_inferior = sol_thread_create_inferior;
1564   sol_thread_ops.to_mourn_inferior = sol_thread_mourn_inferior;
1565   sol_thread_ops.to_can_run = sol_thread_can_run;
1566   sol_thread_ops.to_notice_signals = sol_thread_notice_signals;
1567   sol_thread_ops.to_thread_alive = sol_thread_alive;
1568   sol_thread_ops.to_pid_to_str = solaris_pid_to_str;
1569   sol_thread_ops.to_find_new_threads = sol_find_new_threads;
1570   sol_thread_ops.to_stop = sol_thread_stop;
1571   sol_thread_ops.to_stratum = process_stratum;
1572   sol_thread_ops.to_has_all_memory = 1;
1573   sol_thread_ops.to_has_memory = 1;
1574   sol_thread_ops.to_has_stack = 1;
1575   sol_thread_ops.to_has_registers = 1;
1576   sol_thread_ops.to_has_execution = 1;
1577   sol_thread_ops.to_has_thread_control = tc_none;
1578   sol_thread_ops.to_find_memory_regions = sol_find_memory_regions;
1579   sol_thread_ops.to_make_corefile_notes = sol_make_note_section;
1580   sol_thread_ops.to_magic = OPS_MAGIC;
1581 }
1582
1583
1584 static void
1585 init_sol_core_ops (void)
1586 {
1587   sol_core_ops.to_shortname = "solaris-core";
1588   sol_core_ops.to_longname = "Solaris core threads and pthread.";
1589   sol_core_ops.to_doc = "Solaris threads and pthread support for core files.";
1590   sol_core_ops.to_open = sol_core_open;
1591   sol_core_ops.to_close = sol_core_close;
1592   sol_core_ops.to_attach = sol_thread_attach;
1593   sol_core_ops.to_detach = sol_core_detach;
1594   sol_core_ops.to_fetch_registers = sol_thread_fetch_registers;
1595   sol_core_ops.to_xfer_memory = sol_thread_xfer_memory;
1596   sol_core_ops.to_files_info = sol_core_files_info;
1597   sol_core_ops.to_insert_breakpoint = ignore;
1598   sol_core_ops.to_remove_breakpoint = ignore;
1599   sol_core_ops.to_create_inferior = sol_thread_create_inferior;
1600   sol_core_ops.to_stratum = core_stratum;
1601   sol_core_ops.to_has_memory = 1;
1602   sol_core_ops.to_has_stack = 1;
1603   sol_core_ops.to_has_registers = 1;
1604   sol_core_ops.to_has_thread_control = tc_none;
1605   sol_core_ops.to_thread_alive = sol_thread_alive;
1606   sol_core_ops.to_pid_to_str = solaris_pid_to_str;
1607   /* On Solaris/x86, when debugging a threaded core file from process <n>,
1608      the following causes "info threads" to produce "procfs: couldn't find pid
1609      <n> in procinfo list" where <n> is the pid of the process that produced
1610      the core file.  Disable it for now. */
1611   /* sol_core_ops.to_find_new_threads = sol_find_new_threads; */
1612   sol_core_ops.to_magic = OPS_MAGIC;
1613 }
1614
1615 /* we suppress the call to add_target of core_ops in corelow because
1616    if there are two targets in the stratum core_stratum, find_core_target
1617    won't know which one to return.  see corelow.c for an additonal
1618    comment on coreops_suppress_target. */
1619 int coreops_suppress_target = 1;
1620
1621 void
1622 _initialize_sol_thread (void)
1623 {
1624   void *dlhandle;
1625
1626   init_sol_thread_ops ();
1627   init_sol_core_ops ();
1628
1629   dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
1630   if (!dlhandle)
1631     goto die;
1632
1633 #define resolve(X) \
1634   if (!(p_##X = dlsym (dlhandle, #X))) \
1635     goto die;
1636
1637   resolve (td_log);
1638   resolve (td_ta_new);
1639   resolve (td_ta_delete);
1640   resolve (td_init);
1641   resolve (td_ta_get_ph);
1642   resolve (td_ta_get_nthreads);
1643   resolve (td_ta_tsd_iter);
1644   resolve (td_ta_thr_iter);
1645   resolve (td_thr_validate);
1646   resolve (td_thr_tsd);
1647   resolve (td_thr_get_info);
1648   resolve (td_thr_getfpregs);
1649   resolve (td_thr_getxregsize);
1650   resolve (td_thr_getxregs);
1651   resolve (td_thr_sigsetmask);
1652   resolve (td_thr_setprio);
1653   resolve (td_thr_setsigpending);
1654   resolve (td_thr_setfpregs);
1655   resolve (td_thr_setxregs);
1656   resolve (td_ta_map_id2thr);
1657   resolve (td_ta_map_lwp2thr);
1658   resolve (td_thr_getgregs);
1659   resolve (td_thr_setgregs);
1660
1661   add_target (&sol_thread_ops);
1662
1663   procfs_suppress_run = 1;
1664
1665   add_cmd ("sol-threads", class_maintenance, info_solthreads,
1666            "Show info on Solaris user threads.\n", &maintenanceinfolist);
1667
1668   memcpy (&orig_core_ops, &core_ops, sizeof (struct target_ops));
1669   memcpy (&core_ops, &sol_core_ops, sizeof (struct target_ops));
1670   add_target (&core_ops);
1671
1672   /* Hook into new_objfile notification. */
1673   target_new_objfile_chain = target_new_objfile_hook;
1674   target_new_objfile_hook  = sol_thread_new_objfile;
1675   return;
1676
1677 die:
1678
1679   fprintf_unfiltered (gdb_stderr, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1680
1681   if (dlhandle)
1682     dlclose (dlhandle);
1683
1684   /* allow the user to debug non-threaded core files */
1685   add_target (&core_ops);
1686
1687   return;
1688 }