Subversion Repositories or1k

/* Low level interface for debugging Solaris threads for GDB, the GNU debugger.

   Copyright 1996, 1997, 1998, 1999, 2000, 2001

   Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

/* This module implements a sort of half target that sits between the

   machine-independent parts of GDB and the /proc interface (procfs.c) to

   provide access to the Solaris user-mode thread implementation.

   Solaris threads are true user-mode threads, which are invoked via the thr_*

   and pthread_* (native and Posix respectivly) interfaces.  These are mostly

   implemented in user-space, with all thread context kept in various

   structures that live in the user's heap.  These should not be confused with

   lightweight processes (LWPs), which are implemented by the kernel, and

   scheduled without explicit intervention by the process.

   Just to confuse things a little, Solaris threads (both native and Posix) are

   actually implemented using LWPs.  In general, there are going to be more

   threads than LWPs.  There is no fixed correspondence between a thread and an

   LWP.  When a thread wants to run, it gets scheduled onto the first available

   LWP and can therefore migrate from one LWP to another as time goes on.  A

   sleeping thread may not be associated with an LWP at all!

   To make it possible to mess with threads, Sun provides a library called

   libthread_db.so.1 (not to be confused with libthread_db.so.0, which doesn't

   have a published interface).  This interface has an upper part, which it

   provides, and a lower part which I provide.  The upper part consists of the

   td_* routines, which allow me to find all the threads, query their state,

   etc...  The lower part consists of all of the ps_*, which are used by the

   td_* routines to read/write memory, manipulate LWPs, lookup symbols, etc...

   The ps_* routines actually do most of their work by calling functions in

   procfs.c.  */

#include "defs.h"

#include <thread.h>

#include <proc_service.h>

#include <thread_db.h>

#include "gdbthread.h"

#include "target.h"

#include "inferior.h"

#include <fcntl.h>

#include <sys/stat.h>

#include <dlfcn.h>

#include "gdbcmd.h"

#include "gdbcore.h"

#include "regcache.h"

extern struct target_ops sol_thread_ops;        /* Forward declaration */

extern struct target_ops sol_core_ops;  /* Forward declaration */

/* place to store core_ops before we overwrite it */

static struct target_ops orig_core_ops;

struct target_ops sol_thread_ops;

struct target_ops sol_core_ops;

extern int procfs_suppress_run;

extern struct target_ops procfs_ops;    /* target vector for procfs.c */

extern struct target_ops core_ops;      /* target vector for corelow.c */

extern char *procfs_pid_to_str (ptid_t ptid);

/* Prototypes for supply_gregset etc. */

#include "gregset.h"

/* This struct is defined by us, but mainly used for the proc_service interface.

   We don't have much use for it, except as a handy place to get a real pid

   for memory accesses.  */

struct ps_prochandle

  {

    ptid_t ptid;

  };

struct string_map

  {

    int num;

    char *str;

  };

static struct ps_prochandle main_ph;

static td_thragent_t *main_ta;

static int sol_thread_active = 0;

static char *td_err_string (td_err_e errcode);

static char *td_state_string (td_thr_state_e statecode);

static ptid_t thread_to_lwp (ptid_t thread_id, int default_lwp);

static void sol_thread_resume (ptid_t ptid, int step, enum target_signal signo);

static ptid_t lwp_to_thread (ptid_t lwp);

static int sol_thread_alive (ptid_t ptid);

static void sol_core_close (int quitting);

static void init_sol_thread_ops (void);

static void init_sol_core_ops (void);

/* Default definitions: These must be defined in tm.h

   if they are to be shared with a process module such as procfs.  */

#define GET_PID(ptid)           ptid_get_pid (ptid)

#define GET_LWP(ptid)           ptid_get_lwp (ptid)

#define GET_THREAD(ptid)        ptid_get_tid (ptid)

#define is_lwp(ptid)            (GET_LWP (ptid) != 0)

#define is_thread(ptid)         (GET_THREAD (ptid) != 0)

#define BUILD_LWP(lwp, pid)     ptid_build (pid, lwp, 0)

#define BUILD_THREAD(tid, pid)  ptid_build (pid, 0, tid)

/* Pointers to routines from lithread_db resolved by dlopen() */

static void     (*p_td_log)               (const int on_off);

static td_err_e (*p_td_ta_new)            (const struct ps_prochandle * ph_p,

                                           td_thragent_t ** ta_pp);

static td_err_e (*p_td_ta_delete)         (td_thragent_t * ta_p);

static td_err_e (*p_td_init)              (void);

static td_err_e (*p_td_ta_get_ph)         (const td_thragent_t * ta_p,

                                           struct ps_prochandle ** ph_pp);

static td_err_e (*p_td_ta_get_nthreads)   (const td_thragent_t * ta_p,

                                           int *nthread_p);

static td_err_e (*p_td_ta_tsd_iter)       (const td_thragent_t * ta_p,

                                           td_key_iter_f * cb,

                                           void *cbdata_p);

static td_err_e (*p_td_ta_thr_iter)       (const td_thragent_t * ta_p,

                                           td_thr_iter_f * cb,

                                           void *cbdata_p,

                                           td_thr_state_e state,

                                           int ti_pri,

                                           sigset_t * ti_sigmask_p,

                                           unsigned ti_user_flags);

static td_err_e (*p_td_thr_validate)      (const td_thrhandle_t * th_p);

static td_err_e (*p_td_thr_tsd)           (const td_thrhandle_t * th_p,

                                           const thread_key_t key,

                                           void **data_pp);

static td_err_e (*p_td_thr_get_info)      (const td_thrhandle_t * th_p,

                                           td_thrinfo_t * ti_p);

static td_err_e (*p_td_thr_getfpregs)     (const td_thrhandle_t * th_p,

                                           prfpregset_t * fpregset);

static td_err_e (*p_td_thr_getxregsize)   (const td_thrhandle_t * th_p,

                                           int *xregsize);

static td_err_e (*p_td_thr_getxregs)      (const td_thrhandle_t * th_p,

                                           const caddr_t xregset);

static td_err_e (*p_td_thr_sigsetmask)    (const td_thrhandle_t * th_p,

                                           const sigset_t ti_sigmask);

static td_err_e (*p_td_thr_setprio)       (const td_thrhandle_t * th_p,

                                           const int ti_pri);

static td_err_e (*p_td_thr_setsigpending) (const td_thrhandle_t * th_p,

                                           const uchar_t ti_pending_flag,

                                           const sigset_t ti_pending);

static td_err_e (*p_td_thr_setfpregs)     (const td_thrhandle_t * th_p,

                                           const prfpregset_t * fpregset);

static td_err_e (*p_td_thr_setxregs)      (const td_thrhandle_t * th_p,

                                           const caddr_t xregset);

static td_err_e (*p_td_ta_map_id2thr)     (const td_thragent_t * ta_p,

                                           thread_t tid,

                                           td_thrhandle_t * th_p);

static td_err_e (*p_td_ta_map_lwp2thr)    (const td_thragent_t * ta_p,

                                           lwpid_t lwpid,

                                           td_thrhandle_t * th_p);

static td_err_e (*p_td_thr_getgregs)      (const td_thrhandle_t * th_p,

                                           prgregset_t regset);

static td_err_e (*p_td_thr_setgregs)      (const td_thrhandle_t * th_p,

                                           const prgregset_t regset);

/*

   LOCAL FUNCTION

   td_err_string - Convert a thread_db error code to a string

   SYNOPSIS

   char * td_err_string (errcode)

   DESCRIPTION

   Return the thread_db error string associated with errcode.  If errcode

   is unknown, then return a message.

 */

static char *

td_err_string (td_err_e errcode)

{

  static struct string_map

    td_err_table[] =

  {

    {TD_OK, "generic \"call succeeded\""},

    {TD_ERR, "generic error."},

    {TD_NOTHR, "no thread can be found to satisfy query"},

    {TD_NOSV, "no synch. variable can be found to satisfy query"},

    {TD_NOLWP, "no lwp can be found to satisfy query"},

    {TD_BADPH, "invalid process handle"},

    {TD_BADTH, "invalid thread handle"},

    {TD_BADSH, "invalid synchronization handle"},

    {TD_BADTA, "invalid thread agent"},

    {TD_BADKEY, "invalid key"},

    {TD_NOMSG, "td_thr_event_getmsg() called when there was no message"},

    {TD_NOFPREGS, "FPU register set not available for given thread"},

    {TD_NOLIBTHREAD, "application not linked with libthread"},

    {TD_NOEVENT, "requested event is not supported"},

    {TD_NOCAPAB, "capability not available"},

    {TD_DBERR, "Debugger service failed"},

    {TD_NOAPLIC, "Operation not applicable to"},

    {TD_NOTSD, "No thread specific data for this thread"},

    {TD_MALLOC, "Malloc failed"},

    {TD_PARTIALREG, "Only part of register set was written/read"},

    {TD_NOXREGS, "X register set not available for given thread"}

  };

  const int td_err_size = sizeof td_err_table / sizeof (struct string_map);

  int i;

  static char buf[50];

  for (i = 0; i < td_err_size; i++)

    if (td_err_table[i].num == errcode)

      return td_err_table[i].str;

  sprintf (buf, "Unknown thread_db error code: %d", errcode);

  return buf;

}

/*

   LOCAL FUNCTION

   td_state_string - Convert a thread_db state code to a string

   SYNOPSIS

   char * td_state_string (statecode)

   DESCRIPTION

   Return the thread_db state string associated with statecode.  If

   statecode is unknown, then return a message.

 */

static char *

td_state_string (td_thr_state_e statecode)

{

  static struct string_map

    td_thr_state_table[] =

  {

    {TD_THR_ANY_STATE, "any state"},

    {TD_THR_UNKNOWN, "unknown"},

    {TD_THR_STOPPED, "stopped"},

    {TD_THR_RUN, "run"},

    {TD_THR_ACTIVE, "active"},

    {TD_THR_ZOMBIE, "zombie"},

    {TD_THR_SLEEP, "sleep"},

    {TD_THR_STOPPED_ASLEEP, "stopped asleep"}

  };

  const int td_thr_state_table_size = sizeof td_thr_state_table / sizeof (struct string_map);

  int i;

  static char buf[50];

  for (i = 0; i < td_thr_state_table_size; i++)

    if (td_thr_state_table[i].num == statecode)

      return td_thr_state_table[i].str;

  sprintf (buf, "Unknown thread_db state code: %d", statecode);

  return buf;

}

/*

   LOCAL FUNCTION

   thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.

   SYNOPSIS

   tpid_t thread_to_lwp (thread_id, default_lwp)

   DESCRIPTION

   This function converts a Posix or Solaris thread id to a lightweight

   process id.  If thread_id is non-existent, that's an error.  If it's

   an inactive thread, then we return default_lwp.

   NOTES

   This function probably shouldn't call error()...

 */

static ptid_t

thread_to_lwp (ptid_t thread_id, int default_lwp)

{

  td_thrinfo_t ti;

  td_thrhandle_t th;

  td_err_e val;

  if (is_lwp (thread_id))

    return thread_id;           /* It's already an LWP id */

  /* It's a thread.  Convert to lwp */

  val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th);

  if (val == TD_NOTHR)

    return pid_to_ptid (-1);            /* thread must have terminated */

  else if (val != TD_OK)

    error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val));

  val = p_td_thr_get_info (&th, &ti);

  if (val == TD_NOTHR)

    return pid_to_ptid (-1);            /* thread must have terminated */

  else if (val != TD_OK)

    error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val));

  if (ti.ti_state != TD_THR_ACTIVE)

    {

      if (default_lwp != -1)

        return pid_to_ptid (default_lwp);

      error ("thread_to_lwp: thread state not active: %s",

             td_state_string (ti.ti_state));

    }

  return BUILD_LWP (ti.ti_lid, PIDGET (thread_id));

}

/*

   LOCAL FUNCTION

   lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.

   SYNOPSIS

   int lwp_to_thread (lwp_id)

   DESCRIPTION

   This function converts a lightweight process id to a Posix or Solaris

   thread id.  If thread_id is non-existent, that's an error.

   NOTES

   This function probably shouldn't call error()...

 */

static ptid_t

lwp_to_thread (ptid_t lwp)

{

  td_thrinfo_t ti;

  td_thrhandle_t th;

  td_err_e val;

  if (is_thread (lwp))

    return lwp;                 /* It's already a thread id */

  /* It's an lwp.  Convert it to a thread id.  */

  if (!sol_thread_alive (lwp))

    return pid_to_ptid (-1);    /* defunct lwp */

  val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);

  if (val == TD_NOTHR)

    return pid_to_ptid (-1);    /* thread must have terminated */

  else if (val != TD_OK)

    error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val));

  val = p_td_thr_validate (&th);

  if (val == TD_NOTHR)

    return lwp;                 /* libthread doesn't know about it;

                                   just return lwp */

  else if (val != TD_OK)

    error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val));

  val = p_td_thr_get_info (&th, &ti);

  if (val == TD_NOTHR)

    return pid_to_ptid (-1);    /* thread must have terminated */

  else if (val != TD_OK)

    error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val));

  return BUILD_THREAD (ti.ti_tid, PIDGET (lwp));

}

/* Most target vector functions from here on actually just pass through to

   procfs.c, as they don't need to do anything specific for threads.  */

/* ARGSUSED */

static void

sol_thread_open (char *arg, int from_tty)

{

  procfs_ops.to_open (arg, from_tty);

}

/* Attach to process PID, then initialize for debugging it

   and wait for the trace-trap that results from attaching.  */

static void

sol_thread_attach (char *args, int from_tty)

{

  procfs_ops.to_attach (args, from_tty);

  /* Must get symbols from solibs before libthread_db can run! */

  SOLIB_ADD ((char *) 0, from_tty, (struct target_ops *) 0);

  if (sol_thread_active)

    {

      printf_filtered ("sol-thread active.\n");

      main_ph.ptid = inferior_ptid;             /* Save for xfer_memory */

      push_target (&sol_thread_ops);

      inferior_ptid = lwp_to_thread (inferior_ptid);

      if (PIDGET (inferior_ptid) == -1)

        inferior_ptid = main_ph.ptid;

      else

        add_thread (inferior_ptid);

    }

  /* XXX - might want to iterate over all the threads and register them. */

}

/* Take a program previously attached to and detaches it.

   The program resumes execution and will no longer stop

   on signals, etc.  We'd better not have left any breakpoints

   in the program or it'll die when it hits one.  For this

   to work, it may be necessary for the process to have been

   previously attached.  It *might* work if the program was

   started via the normal ptrace (PTRACE_TRACEME).  */

static void

sol_thread_detach (char *args, int from_tty)

{

  inferior_ptid = pid_to_ptid (PIDGET (main_ph.ptid));

  unpush_target (&sol_thread_ops);

  procfs_ops.to_detach (args, from_tty);

}

/* Resume execution of process PID.  If STEP is nozero, then

   just single step it.  If SIGNAL is nonzero, restart it with that

   signal activated.  We may have to convert pid from a thread-id to an LWP id

   for procfs.  */

static void

sol_thread_resume (ptid_t ptid, int step, enum target_signal signo)

{

  struct cleanup *old_chain;

  old_chain = save_inferior_ptid ();

  inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));

  if (PIDGET (inferior_ptid) == -1)

    inferior_ptid = procfs_first_available ();

  if (PIDGET (ptid) != -1)

    {

      ptid_t save_ptid = ptid;

      ptid = thread_to_lwp (ptid, -2);

      if (PIDGET (ptid) == -2)          /* Inactive thread */

        error ("This version of Solaris can't start inactive threads.");

      if (info_verbose && PIDGET (ptid) == -1)

        warning ("Specified thread %ld seems to have terminated",

                 GET_THREAD (save_ptid));

    }

  procfs_ops.to_resume (ptid, step, signo);

  do_cleanups (old_chain);

}

/* Wait for any threads to stop.  We may have to convert PID from a thread id

   to a LWP id, and vice versa on the way out.  */

static ptid_t

sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)

{

  ptid_t rtnval;

  ptid_t save_ptid;

  struct cleanup *old_chain;

  save_ptid = inferior_ptid;

  old_chain = save_inferior_ptid ();

  inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));

  if (PIDGET (inferior_ptid) == -1)

    inferior_ptid = procfs_first_available ();

  if (PIDGET (ptid) != -1)

    {

      ptid_t save_ptid = ptid;

      ptid = thread_to_lwp (ptid, -2);

      if (PIDGET (ptid) == -2)          /* Inactive thread */

        error ("This version of Solaris can't start inactive threads.");

      if (info_verbose && PIDGET (ptid) == -1)

        warning ("Specified thread %ld seems to have terminated",

                 GET_THREAD (save_ptid));

    }

  rtnval = procfs_ops.to_wait (ptid, ourstatus);

  if (ourstatus->kind != TARGET_WAITKIND_EXITED)

    {

      /* Map the LWP of interest back to the appropriate thread ID */

      rtnval = lwp_to_thread (rtnval);

      if (PIDGET (rtnval) == -1)

        rtnval = save_ptid;

      /* See if we have a new thread */

      if (is_thread (rtnval)

          && !ptid_equal (rtnval, save_ptid)

          && !in_thread_list (rtnval))

        {

          printf_filtered ("[New %s]\n", target_pid_to_str (rtnval));

          add_thread (rtnval);

        }

    }

  /* During process initialization, we may get here without the thread package

     being initialized, since that can only happen after we've found the shared

     libs.  */

  do_cleanups (old_chain);

  return rtnval;

}

static void

sol_thread_fetch_registers (int regno)

{

  thread_t thread;

  td_thrhandle_t thandle;

  td_err_e val;

  prgregset_t gregset;

  prfpregset_t fpregset;

#if 0

  int xregsize;

  caddr_t xregset;

#endif

  if (!is_thread (inferior_ptid))

    {                           /* LWP: pass the request on to procfs.c */

      if (target_has_execution)

        procfs_ops.to_fetch_registers (regno);

      else

        orig_core_ops.to_fetch_registers (regno);

      return;

    }

  /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */

  thread = GET_THREAD (inferior_ptid);

  if (thread == 0)

    error ("sol_thread_fetch_registers:  thread == 0");

  val = p_td_ta_map_id2thr (main_ta, thread, &thandle);

  if (val != TD_OK)

    error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",

           td_err_string (val));

  /* Get the integer regs */

  val = p_td_thr_getgregs (&thandle, gregset);

  if (val != TD_OK

      && val != TD_PARTIALREG)

    error ("sol_thread_fetch_registers: td_thr_getgregs %s",

           td_err_string (val));

  /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp

     are saved (by a thread context switch).  */

  /* And, now the fp regs */

  val = p_td_thr_getfpregs (&thandle, &fpregset);

  if (val != TD_OK

      && val != TD_NOFPREGS)

    error ("sol_thread_fetch_registers: td_thr_getfpregs %s",

           td_err_string (val));

/* Note that we must call supply_{g fp}regset *after* calling the td routines

   because the td routines call ps_lget* which affect the values stored in the

   registers array.  */

  supply_gregset  ((gdb_gregset_t *)  &gregset);

  supply_fpregset ((gdb_fpregset_t *) &fpregset);

#if 0

/* thread_db doesn't seem to handle this right */

  val = td_thr_getxregsize (&thandle, &xregsize);

  if (val != TD_OK && val != TD_NOXREGS)

    error ("sol_thread_fetch_registers: td_thr_getxregsize %s",

           td_err_string (val));

  if (val == TD_OK)

    {

      xregset = alloca (xregsize);

      val = td_thr_getxregs (&thandle, xregset);

      if (val != TD_OK)

        error ("sol_thread_fetch_registers: td_thr_getxregs %s",

               td_err_string (val));

    }

#endif

}

static void

sol_thread_store_registers (int regno)

{

  thread_t thread;

  td_thrhandle_t thandle;

  td_err_e val;

  prgregset_t  gregset;

  prfpregset_t fpregset;

#if 0

  int xregsize;

  caddr_t xregset;

#endif

  if (!is_thread (inferior_ptid))

    {                           /* LWP: pass the request on to procfs.c */

      procfs_ops.to_store_registers (regno);

      return;

    }

  /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */

  thread = GET_THREAD (inferior_ptid);

  val = p_td_ta_map_id2thr (main_ta, thread, &thandle);

  if (val != TD_OK)

    error ("sol_thread_store_registers: td_ta_map_id2thr %s",

           td_err_string (val));

  if (regno != -1)

    {                           /* Not writing all the regs */

      /* save new register value */

      char* old_value = (char*) alloca (REGISTER_SIZE);

      memcpy (old_value, &registers[REGISTER_BYTE (regno)], REGISTER_SIZE);

      val = p_td_thr_getgregs (&thandle, gregset);

      if (val != TD_OK)

        error ("sol_thread_store_registers: td_thr_getgregs %s",

               td_err_string (val));

      val = p_td_thr_getfpregs (&thandle, &fpregset);

      if (val != TD_OK)

        error ("sol_thread_store_registers: td_thr_getfpregs %s",

               td_err_string (val));

      /* restore new register value */

      memcpy (&registers[REGISTER_BYTE (regno)], old_value, REGISTER_SIZE);

#if 0

/* thread_db doesn't seem to handle this right */

      val = td_thr_getxregsize (&thandle, &xregsize);

      if (val != TD_OK && val != TD_NOXREGS)

        error ("sol_thread_store_registers: td_thr_getxregsize %s",

               td_err_string (val));

      if (val == TD_OK)

        {

          xregset = alloca (xregsize);

          val = td_thr_getxregs (&thandle, xregset);

          if (val != TD_OK)

            error ("sol_thread_store_registers: td_thr_getxregs %s",

                   td_err_string (val));

        }

#endif

    }

  fill_gregset  ((gdb_gregset_t *)  &gregset,  regno);

  fill_fpregset ((gdb_fpregset_t *) &fpregset, regno);

  val = p_td_thr_setgregs (&thandle, gregset);

  if (val != TD_OK)

    error ("sol_thread_store_registers: td_thr_setgregs %s",

           td_err_string (val));

  val = p_td_thr_setfpregs (&thandle, &fpregset);

  if (val != TD_OK)

    error ("sol_thread_store_registers: td_thr_setfpregs %s",

           td_err_string (val));

#if 0

/* thread_db doesn't seem to handle this right */

  val = td_thr_getxregsize (&thandle, &xregsize);

  if (val != TD_OK && val != TD_NOXREGS)