gdb/sol-thread.c

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