Subversion Repositories openrisc_2011-10-31

/* Solaris threads debugging interface.

   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,

   2007, 2008, 2009, 2010 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 3 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, see <http://www.gnu.org/licenses/>.  */

/* 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 we provide.  The upper part consists of the td_* routines,

   which allow us 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 "gdb_stat.h"

#include <dlfcn.h>

#include "gdbcmd.h"

#include "gdbcore.h"

#include "regcache.h"

#include "solib.h"

#include "symfile.h"

#include "observer.h"

#include "gdb_string.h"

#include "procfs.h"

struct target_ops sol_thread_ops;

extern char *procfs_pid_to_str (struct target_ops *ops, 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 void init_sol_thread_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 libthread_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);

/* Return the libthread_db error string associated with ERRCODE.  If

   ERRCODE is unknown, return an appropriate 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 libthread_db error code: %d", errcode);

  return buf;

}

/* Return the the libthread_db state string assicoated with STATECODE.

   If STATECODE is unknown, return an appropriate 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 libthread_db state code: %d", statecode);

  return buf;

}

/* Convert a POSIX or Solaris thread ID into a LWP ID.  If THREAD_ID

   doesn't exist, that's an error.  If it's an inactive thread, return

   DEFAULT_LWP.

   NOTE: 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));

}

/* Convert an LWP ID into a POSIX or Solaris thread ID.  If LWP_ID

   doesn't exists, that's an error.

   NOTE: 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 (!target_thread_alive (lwp))

    return pid_to_ptid (-1);    /* Must be a defunct LPW.  */

  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;                 /* Unknown to libthread; just return LPW,  */

  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 the layer beneath, as they don't need to do anything

   specific for threads.  */

/* 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 (struct target_ops *ops, char *args, int from_tty)

{

  struct target_ops *beneath = find_target_beneath (ops);

  sol_thread_active = 0;

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

  unpush_target (ops);

  beneath->to_detach (beneath, args, from_tty);

}

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

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

   activated.  We may have to convert PTID from a thread ID to an LWP

   ID for procfs.  */

static void

sol_thread_resume (struct target_ops *ops,

                   ptid_t ptid, int step, enum target_signal signo)

{

  struct cleanup *old_chain;

  struct target_ops *beneath = find_target_beneath (ops);

  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));

    }

  beneath->to_resume (beneath, ptid, step, signo);

  do_cleanups (old_chain);

}

/* Wait for any threads to stop.  We may have to convert PTID from a

   thread ID to an LWP ID, and vice versa on the way out.  */

static ptid_t

sol_thread_wait (struct target_ops *ops,

                 ptid_t ptid, struct target_waitstatus *ourstatus, int options)

{

  ptid_t rtnval;

  ptid_t save_ptid;

  struct target_ops *beneath = find_target_beneath (ops);

  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 = beneath->to_wait (beneath, ptid, ourstatus, options);

  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)

              || is_exited (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 (struct target_ops *ops,

                            struct regcache *regcache, int regnum)

{

  thread_t thread;

  td_thrhandle_t thandle;

  td_err_e val;

  prgregset_t gregset;

  prfpregset_t fpregset;

  gdb_gregset_t *gregset_p = &gregset;

  gdb_fpregset_t *fpregset_p = &fpregset;

  struct target_ops *beneath = find_target_beneath (ops);

#if 0

  int xregsize;

  caddr_t xregset;

#endif

  if (!is_thread (inferior_ptid))

    {

      /* It's an LWP; pass the request on to the layer beneath.  */

      beneath->to_fetch_registers (beneath, regcache, regnum);

      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 general-purpose registers.  */

  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 SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc

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

  /* And, now the floating-point registers.  */

  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_gregset and supply_fpregset *after*

     calling the td routines because the td routines call ps_lget*

     which affect the values stored in the registers array.  */

  supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);

  supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);

#if 0

  /* FIXME: libthread_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 (struct target_ops *ops,

                            struct regcache *regcache, int regnum)

{

  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))

    {

      struct target_ops *beneath = find_target_beneath (ops);

      /* It's an LWP; pass the request on to the layer beneath.  */

      beneath->to_store_registers (beneath, regcache, regnum);

      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 (regnum != -1)

    {

      /* Not writing all the registers.  */

      char old_value[MAX_REGISTER_SIZE];

      /* Save new register value.  */

      regcache_raw_collect (regcache, regnum, old_value);

      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.  */

      regcache_raw_supply (regcache, regnum, old_value);

#if 0

      /* FIXME: libthread_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 (regcache, (gdb_gregset_t *) &gregset, regnum);

  fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);

  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

  /* FIXME: libthread_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));

  /* ??? Should probably do something about writing the xregs here,

     but what are they?  */

#endif

}

/* Perform partial transfers on OBJECT.  See target_read_partial and

   target_write_partial for details of each variant.  One, and only

   one, of readbuf or writebuf must be non-NULL.  */

static LONGEST

sol_thread_xfer_partial (struct target_ops *ops, enum target_object object,

                          const char *annex, gdb_byte *readbuf,

                          const gdb_byte *writebuf,

                         ULONGEST offset, LONGEST len)

{

  int retval;

  struct cleanup *old_chain;

  struct target_ops *beneath = find_target_beneath (ops);

  old_chain = save_inferior_ptid ();

  if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))

    {

      /* It's either a thread or an LWP that isn't alive.  Any live

         LWP will do so use the first available.

         NOTE: We don't need to call switch_to_thread; we're just

         reading memory.  */

      inferior_ptid = procfs_first_available ();

    }

  retval = beneath->to_xfer_partial (beneath, object, annex,

                                     readbuf, writebuf, offset, len);

  do_cleanups (old_chain);

  return retval;

}

static void

check_for_thread_db (void)

{

  td_err_e err;

  ptid_t ptid;

  /* Do nothing if we couldn't load libthread_db.so.1.  */

  if (p_td_ta_new == NULL)

    return;

  if (sol_thread_active)

    /* Nothing to do.  The thread library was already detected and the

       target vector was already activated.  */

    return;

  /* Now, initialize libthread_db.  This needs to be done after the

     shared libraries are located because it needs information from

     the user's thread library.  */

  err = p_td_init ();

  if (err != TD_OK)

    {

      warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err));

      return;

    }

  /* Now attempt to open a connection to the thread library.  */

  err = p_td_ta_new (&main_ph, &main_ta);

  switch (err)

    {

    case TD_NOLIBTHREAD:

      /* No thread library was detected.  */

      break;

    case TD_OK:

      printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));

      /* The thread library was detected.  Activate the sol_thread target.  */

      push_target (&sol_thread_ops);

      sol_thread_active = 1;

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