mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-09 04:21:49 +08:00
1643 lines
43 KiB
C
1643 lines
43 KiB
C
/* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
|
||
Copyright 1996, 1997, 1998 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"
|
||
|
||
/* Undefine gregset_t and fpregset_t to avoid conflict with defs in xm file. */
|
||
|
||
#ifdef gregset_t
|
||
#undef gregset_t
|
||
#endif
|
||
|
||
#ifdef fpregset_t
|
||
#undef fpregset_t
|
||
#endif
|
||
|
||
#include <thread.h>
|
||
#include <proc_service.h>
|
||
#include <thread_db.h>
|
||
#include "gdbthread.h"
|
||
#include "target.h"
|
||
#include "inferior.h"
|
||
#include <fcntl.h>
|
||
#include <unistd.h>
|
||
#include <sys/stat.h>
|
||
#include <dlfcn.h>
|
||
#include "gdbcmd.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;
|
||
|
||
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 PARAMS ((int pid));
|
||
|
||
/* Note that these prototypes differ slightly from those used in procfs.c
|
||
for of two reasons. One, we can't use gregset_t, as that's got a whole
|
||
different meaning under Solaris (also, see above). Two, we can't use the
|
||
pointer form here as these are actually arrays of ints (for Sparc's at
|
||
least), and are automatically coerced into pointers to ints when used as
|
||
parameters. That makes it impossible to avoid a compiler warning when
|
||
passing pr{g fp}regset_t's from a parameter to an argument of one of
|
||
these functions. */
|
||
|
||
extern void supply_gregset PARAMS ((const prgregset_t));
|
||
extern void fill_gregset PARAMS ((prgregset_t, int));
|
||
extern void supply_fpregset PARAMS ((const prfpregset_t *));
|
||
extern void fill_fpregset PARAMS ((prfpregset_t *, int));
|
||
|
||
/* 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
|
||
{
|
||
pid_t pid;
|
||
};
|
||
|
||
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 struct cleanup * save_inferior_pid PARAMS ((void));
|
||
static void restore_inferior_pid PARAMS ((int pid));
|
||
static char *td_err_string PARAMS ((td_err_e errcode));
|
||
static char *td_state_string PARAMS ((td_thr_state_e statecode));
|
||
static int thread_to_lwp PARAMS ((int thread_id, int default_lwp));
|
||
static void sol_thread_resume PARAMS ((int pid, int step,
|
||
enum target_signal signo));
|
||
static int lwp_to_thread PARAMS ((int lwp));
|
||
static int sol_thread_alive PARAMS ((int pid));
|
||
static void sol_core_close PARAMS ((int quitting));
|
||
|
||
#define THREAD_FLAG 0x80000000
|
||
#define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
|
||
#define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
|
||
#define GET_LWP(LWP_ID) (TIDGET(LWP_ID))
|
||
#define GET_THREAD(THREAD_ID) (((THREAD_ID) >> 16) & 0x7fff)
|
||
#define BUILD_LWP(LWP_ID, PID) ((LWP_ID) << 16 | (PID))
|
||
#define BUILD_THREAD(THREAD_ID, PID) (THREAD_FLAG | BUILD_LWP (THREAD_ID, PID))
|
||
|
||
/* 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 (errcode)
|
||
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 writen/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 (statecode)
|
||
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
|
||
|
||
int 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 int
|
||
thread_to_lwp (thread_id, default_lwp)
|
||
int 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 -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 -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 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 int
|
||
lwp_to_thread (lwp)
|
||
int 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 -1; /* defunct lwp */
|
||
|
||
val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);
|
||
if (val == TD_NOTHR)
|
||
return -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 -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));
|
||
}
|
||
|
||
/*
|
||
|
||
LOCAL FUNCTION
|
||
|
||
save_inferior_pid - Save inferior_pid on the cleanup list
|
||
restore_inferior_pid - Restore inferior_pid from the cleanup list
|
||
|
||
SYNOPSIS
|
||
|
||
struct cleanup *save_inferior_pid ()
|
||
void restore_inferior_pid (int pid)
|
||
|
||
DESCRIPTION
|
||
|
||
These two functions act in unison to restore inferior_pid in
|
||
case of an error.
|
||
|
||
NOTES
|
||
|
||
inferior_pid is a global variable that needs to be changed by many of
|
||
these routines before calling functions in procfs.c. In order to
|
||
guarantee that inferior_pid gets restored (in case of errors), you
|
||
need to call save_inferior_pid before changing it. At the end of the
|
||
function, you should invoke do_cleanups to restore it.
|
||
|
||
*/
|
||
|
||
|
||
static struct cleanup *
|
||
save_inferior_pid ()
|
||
{
|
||
return make_cleanup (restore_inferior_pid, inferior_pid);
|
||
}
|
||
|
||
static void
|
||
restore_inferior_pid (pid)
|
||
int pid;
|
||
{
|
||
inferior_pid = pid;
|
||
}
|
||
|
||
|
||
/* 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 (arg, from_tty)
|
||
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 (args, from_tty)
|
||
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.pid = inferior_pid; /* Save for xfer_memory */
|
||
push_target (&sol_thread_ops);
|
||
inferior_pid = lwp_to_thread (inferior_pid);
|
||
if (inferior_pid == -1)
|
||
inferior_pid = main_ph.pid;
|
||
else
|
||
add_thread (inferior_pid);
|
||
}
|
||
/* 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 (args, from_tty)
|
||
char *args;
|
||
int from_tty;
|
||
{
|
||
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 (pid, step, signo)
|
||
int pid;
|
||
int step;
|
||
enum target_signal signo;
|
||
{
|
||
struct cleanup *old_chain;
|
||
|
||
old_chain = save_inferior_pid ();
|
||
|
||
inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid);
|
||
if (inferior_pid == -1)
|
||
inferior_pid = procfs_first_available ();
|
||
|
||
if (pid != -1)
|
||
{
|
||
int save_pid = pid;
|
||
|
||
pid = thread_to_lwp (pid, -2);
|
||
if (pid == -2) /* Inactive thread */
|
||
error ("This version of Solaris can't start inactive threads.");
|
||
if (info_verbose && pid == -1)
|
||
warning ("Specified thread %d seems to have terminated",
|
||
GET_THREAD (save_pid));
|
||
}
|
||
|
||
procfs_ops.to_resume (pid, 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 int
|
||
sol_thread_wait (pid, ourstatus)
|
||
int pid;
|
||
struct target_waitstatus *ourstatus;
|
||
{
|
||
int rtnval;
|
||
int save_pid;
|
||
struct cleanup *old_chain;
|
||
|
||
save_pid = inferior_pid;
|
||
old_chain = save_inferior_pid ();
|
||
|
||
inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid);
|
||
if (inferior_pid == -1)
|
||
inferior_pid = procfs_first_available ();
|
||
|
||
if (pid != -1)
|
||
{
|
||
int save_pid = pid;
|
||
|
||
pid = thread_to_lwp (pid, -2);
|
||
if (pid == -2) /* Inactive thread */
|
||
error ("This version of Solaris can't start inactive threads.");
|
||
if (info_verbose && pid == -1)
|
||
warning ("Specified thread %d seems to have terminated",
|
||
GET_THREAD (save_pid));
|
||
}
|
||
|
||
rtnval = procfs_ops.to_wait (pid, ourstatus);
|
||
|
||
if (ourstatus->kind != TARGET_WAITKIND_EXITED)
|
||
{
|
||
/* Map the LWP of interest back to the appropriate thread ID */
|
||
rtnval = lwp_to_thread (rtnval);
|
||
if (rtnval == -1)
|
||
rtnval = save_pid;
|
||
|
||
/* See if we have a new thread */
|
||
if (is_thread (rtnval)
|
||
&& rtnval != save_pid
|
||
&& !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 (regno)
|
||
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_pid))
|
||
{ /* 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_pid into a td_thrhandle_t */
|
||
|
||
thread = GET_THREAD (inferior_pid);
|
||
|
||
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 (gregset);
|
||
supply_fpregset (&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 (regno)
|
||
int regno;
|
||
{
|
||
thread_t thread;
|
||
td_thrhandle_t thandle;
|
||
td_err_e val;
|
||
prgregset_t regset;
|
||
prfpregset_t fpregset;
|
||
#if 0
|
||
int xregsize;
|
||
caddr_t xregset;
|
||
#endif
|
||
|
||
if (!is_thread (inferior_pid))
|
||
{ /* LWP: pass the request on to procfs.c */
|
||
procfs_ops.to_store_registers (regno);
|
||
return;
|
||
}
|
||
|
||
/* Solaris thread: convert inferior_pid into a td_thrhandle_t */
|
||
|
||
thread = GET_THREAD (inferior_pid);
|
||
|
||
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[REGISTER_SIZE];
|
||
memcpy(old_value, & registers[REGISTER_BYTE(regno)], REGISTER_SIZE);
|
||
|
||
val = p_td_thr_getgregs (&thandle, regset);
|
||
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 (regset, regno);
|
||
fill_fpregset (&fpregset, regno);
|
||
|
||
val = p_td_thr_setgregs (&thandle, regset);
|
||
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)
|
||
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
|
||
}
|
||
|
||
/* Get ready to modify the registers array. On machines which store
|
||
individual registers, this doesn't need to do anything. On machines
|
||
which store all the registers in one fell swoop, this makes sure
|
||
that registers contains all the registers from the program being
|
||
debugged. */
|
||
|
||
static void
|
||
sol_thread_prepare_to_store ()
|
||
{
|
||
procfs_ops.to_prepare_to_store ();
|
||
}
|
||
|
||
static int
|
||
sol_thread_xfer_memory (memaddr, myaddr, len, dowrite, target)
|
||
CORE_ADDR memaddr;
|
||
char *myaddr;
|
||
int len;
|
||
int dowrite;
|
||
struct target_ops *target; /* ignored */
|
||
{
|
||
int retval;
|
||
struct cleanup *old_chain;
|
||
|
||
old_chain = save_inferior_pid ();
|
||
|
||
if (is_thread (inferior_pid) || /* A thread */
|
||
!target_thread_alive (inferior_pid)) /* An lwp, but not alive */
|
||
inferior_pid = procfs_first_available (); /* Find any live lwp. */
|
||
/* Note: don't need to call switch_to_thread; we're just reading memory. */
|
||
|
||
if (target_has_execution)
|
||
retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len, dowrite, target);
|
||
else
|
||
retval = orig_core_ops.to_xfer_memory (memaddr, myaddr, len,
|
||
dowrite, target);
|
||
|
||
do_cleanups (old_chain);
|
||
|
||
return retval;
|
||
}
|
||
|
||
/* Print status information about what we're accessing. */
|
||
|
||
static void
|
||
sol_thread_files_info (ignore)
|
||
struct target_ops *ignore;
|
||
{
|
||
procfs_ops.to_files_info (ignore);
|
||
}
|
||
|
||
static void
|
||
sol_thread_kill_inferior ()
|
||
{
|
||
procfs_ops.to_kill ();
|
||
}
|
||
|
||
static void
|
||
sol_thread_notice_signals (pid)
|
||
int pid;
|
||
{
|
||
procfs_ops.to_notice_signals (PIDGET (pid));
|
||
}
|
||
|
||
/* Fork an inferior process, and start debugging it with /proc. */
|
||
|
||
static void
|
||
sol_thread_create_inferior (exec_file, allargs, env)
|
||
char *exec_file;
|
||
char *allargs;
|
||
char **env;
|
||
{
|
||
procfs_ops.to_create_inferior (exec_file, allargs, env);
|
||
|
||
if (sol_thread_active && inferior_pid != 0)
|
||
{
|
||
main_ph.pid = inferior_pid; /* Save for xfer_memory */
|
||
|
||
push_target (&sol_thread_ops);
|
||
|
||
inferior_pid = lwp_to_thread (inferior_pid);
|
||
if (inferior_pid == -1)
|
||
inferior_pid = main_ph.pid;
|
||
|
||
add_thread (inferior_pid);
|
||
}
|
||
}
|
||
|
||
/* This routine is called whenever a new symbol table is read in, or when all
|
||
symbol tables are removed. libthread_db can only be initialized when it
|
||
finds the right variables in libthread.so. Since it's a shared library,
|
||
those variables don't show up until the library gets mapped and the symbol
|
||
table is read in. */
|
||
|
||
void
|
||
sol_thread_new_objfile (objfile)
|
||
struct objfile *objfile;
|
||
{
|
||
td_err_e val;
|
||
|
||
if (!objfile)
|
||
{
|
||
sol_thread_active = 0;
|
||
|
||
return;
|
||
}
|
||
|
||
/* don't do anything if init failed to resolve the libthread_db library */
|
||
if (!procfs_suppress_run)
|
||
return;
|
||
|
||
/* Now, initialize the thread debugging library. This needs to be done after
|
||
the shared libraries are located because it needs information from the
|
||
user's thread library. */
|
||
|
||
val = p_td_init ();
|
||
if (val != TD_OK)
|
||
error ("target_new_objfile: td_init: %s", td_err_string (val));
|
||
|
||
val = p_td_ta_new (&main_ph, &main_ta);
|
||
if (val == TD_NOLIBTHREAD)
|
||
return;
|
||
else if (val != TD_OK)
|
||
error ("target_new_objfile: td_ta_new: %s", td_err_string (val));
|
||
|
||
sol_thread_active = 1;
|
||
}
|
||
|
||
/* Clean up after the inferior dies. */
|
||
|
||
static void
|
||
sol_thread_mourn_inferior ()
|
||
{
|
||
unpush_target (&sol_thread_ops);
|
||
procfs_ops.to_mourn_inferior ();
|
||
}
|
||
|
||
/* Mark our target-struct as eligible for stray "run" and "attach" commands. */
|
||
|
||
static int
|
||
sol_thread_can_run ()
|
||
{
|
||
return procfs_suppress_run;
|
||
}
|
||
|
||
/*
|
||
|
||
LOCAL FUNCTION
|
||
|
||
sol_thread_alive - test thread for "aliveness"
|
||
|
||
SYNOPSIS
|
||
|
||
static bool sol_thread_alive (int pid);
|
||
|
||
DESCRIPTION
|
||
|
||
returns true if thread still active in inferior.
|
||
|
||
*/
|
||
|
||
static int
|
||
sol_thread_alive (pid)
|
||
int pid;
|
||
{
|
||
if (is_thread (pid)) /* non-kernel thread */
|
||
{
|
||
td_err_e val;
|
||
td_thrhandle_t th;
|
||
|
||
pid = GET_THREAD (pid);
|
||
if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
|
||
return 0; /* thread not found */
|
||
if ((val = p_td_thr_validate (&th)) != TD_OK)
|
||
return 0; /* thread not valid */
|
||
return 1; /* known thread: return true */
|
||
}
|
||
else /* kernel thread (LWP): let procfs test it */
|
||
{
|
||
if (target_has_execution)
|
||
return procfs_ops.to_thread_alive (pid);
|
||
else
|
||
return orig_core_ops.to_thread_alive (pid);
|
||
}
|
||
}
|
||
|
||
static void
|
||
sol_thread_stop ()
|
||
{
|
||
procfs_ops.to_stop ();
|
||
}
|
||
|
||
/* These routines implement the lower half of the thread_db interface. Ie: the
|
||
ps_* routines. */
|
||
|
||
/* The next four routines are called by thread_db to tell us to stop and stop
|
||
a particular process or lwp. Since GDB ensures that these are all stopped
|
||
by the time we call anything in thread_db, these routines need to do
|
||
nothing. */
|
||
|
||
ps_err_e
|
||
ps_pstop (const struct ps_prochandle *ph)
|
||
{
|
||
return PS_OK;
|
||
}
|
||
|
||
ps_err_e
|
||
ps_pcontinue (const struct ps_prochandle *ph)
|
||
{
|
||
return PS_OK;
|
||
}
|
||
|
||
ps_err_e
|
||
ps_lstop (const struct ps_prochandle *ph, lwpid_t lwpid)
|
||
{
|
||
return PS_OK;
|
||
}
|
||
|
||
ps_err_e
|
||
ps_lcontinue (const struct ps_prochandle *ph, lwpid_t lwpid)
|
||
{
|
||
return PS_OK;
|
||
}
|
||
|
||
ps_err_e
|
||
ps_pglobal_lookup (const struct ps_prochandle *ph, const char *ld_object_name,
|
||
const char *ld_symbol_name, paddr_t *ld_symbol_addr)
|
||
{
|
||
struct minimal_symbol *ms;
|
||
|
||
ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
|
||
|
||
if (!ms)
|
||
return PS_NOSYM;
|
||
|
||
*ld_symbol_addr = SYMBOL_VALUE_ADDRESS (ms);
|
||
|
||
return PS_OK;
|
||
}
|
||
|
||
/* Common routine for reading and writing memory. */
|
||
|
||
static ps_err_e
|
||
rw_common (int dowrite, const struct ps_prochandle *ph, paddr_t addr,
|
||
char *buf, int size)
|
||
{
|
||
struct cleanup *old_chain;
|
||
|
||
old_chain = save_inferior_pid ();
|
||
|
||
if (is_thread (inferior_pid) || /* A thread */
|
||
!target_thread_alive (inferior_pid)) /* An lwp, but not alive */
|
||
inferior_pid = procfs_first_available (); /* Find any live lwp. */
|
||
/* Note: don't need to call switch_to_thread; we're just reading memory. */
|
||
|
||
while (size > 0)
|
||
{
|
||
int cc;
|
||
|
||
if (target_has_execution)
|
||
cc = procfs_ops.to_xfer_memory (addr, buf, size, dowrite, &procfs_ops);
|
||
else
|
||
cc = orig_core_ops.to_xfer_memory (addr, buf, size, dowrite, &core_ops);
|
||
|
||
if (cc < 0)
|
||
{
|
||
if (dowrite == 0)
|
||
print_sys_errmsg ("rw_common (): read", errno);
|
||
else
|
||
print_sys_errmsg ("rw_common (): write", errno);
|
||
|
||
do_cleanups (old_chain);
|
||
|
||
return PS_ERR;
|
||
}
|
||
size -= cc;
|
||
buf += cc;
|
||
}
|
||
|
||
do_cleanups (old_chain);
|
||
|
||
return PS_OK;
|
||
}
|
||
|
||
ps_err_e
|
||
ps_pdread (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
|
||
{
|
||
return rw_common (0, ph, addr, buf, size);
|
||
}
|
||
|
||
ps_err_e
|
||
ps_pdwrite (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
|
||
{
|
||
return rw_common (1, ph, addr, buf, size);
|
||
}
|
||
|
||
ps_err_e
|
||
ps_ptread (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
|
||
{
|
||
return rw_common (0, ph, addr, buf, size);
|
||
}
|
||
|
||
ps_err_e
|
||
ps_ptwrite (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
|
||
{
|
||
return rw_common (1, ph, addr, buf, size);
|
||
}
|
||
|
||
/* Get integer regs */
|
||
|
||
ps_err_e
|
||
ps_lgetregs (const struct ps_prochandle *ph, lwpid_t lwpid,
|
||
prgregset_t gregset)
|
||
{
|
||
struct cleanup *old_chain;
|
||
|
||
old_chain = save_inferior_pid ();
|
||
|
||
inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
|
||
|
||
if (target_has_execution)
|
||
procfs_ops.to_fetch_registers (-1);
|
||
else
|
||
orig_core_ops.to_fetch_registers (-1);
|
||
fill_gregset (gregset, -1);
|
||
|
||
do_cleanups (old_chain);
|
||
|
||
return PS_OK;
|
||
}
|
||
|
||
/* Set integer regs */
|
||
|
||
ps_err_e
|
||
ps_lsetregs (const struct ps_prochandle *ph, lwpid_t lwpid,
|
||
const prgregset_t gregset)
|
||
{
|
||
struct cleanup *old_chain;
|
||
|
||
old_chain = save_inferior_pid ();
|
||
|
||
inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
|
||
|
||
supply_gregset (gregset);
|
||
if (target_has_execution)
|
||
procfs_ops.to_store_registers (-1);
|
||
else
|
||
orig_core_ops.to_store_registers (-1);
|
||
|
||
do_cleanups (old_chain);
|
||
|
||
return PS_OK;
|
||
}
|
||
|
||
void
|
||
ps_plog (const char *fmt, ...)
|
||
{
|
||
va_list args;
|
||
|
||
va_start (args, fmt);
|
||
|
||
vfprintf_filtered (gdb_stderr, fmt, args);
|
||
}
|
||
|
||
/* Get size of extra register set. Currently a noop. */
|
||
|
||
ps_err_e
|
||
ps_lgetxregsize (const struct ps_prochandle *ph, lwpid_t lwpid, int *xregsize)
|
||
{
|
||
#if 0
|
||
int lwp_fd;
|
||
int regsize;
|
||
ps_err_e val;
|
||
|
||
val = get_lwp_fd (ph, lwpid, &lwp_fd);
|
||
if (val != PS_OK)
|
||
return val;
|
||
|
||
if (ioctl (lwp_fd, PIOCGXREGSIZE, ®size))
|
||
{
|
||
if (errno == EINVAL)
|
||
return PS_NOFREGS; /* XXX Wrong code, but this is the closest
|
||
thing in proc_service.h */
|
||
|
||
print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno);
|
||
return PS_ERR;
|
||
}
|
||
#endif
|
||
|
||
return PS_OK;
|
||
}
|
||
|
||
/* Get extra register set. Currently a noop. */
|
||
|
||
ps_err_e
|
||
ps_lgetxregs (const struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
|
||
{
|
||
#if 0
|
||
int lwp_fd;
|
||
ps_err_e val;
|
||
|
||
val = get_lwp_fd (ph, lwpid, &lwp_fd);
|
||
if (val != PS_OK)
|
||
return val;
|
||
|
||
if (ioctl (lwp_fd, PIOCGXREG, xregset))
|
||
{
|
||
print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno);
|
||
return PS_ERR;
|
||
}
|
||
#endif
|
||
|
||
return PS_OK;
|
||
}
|
||
|
||
/* Set extra register set. Currently a noop. */
|
||
|
||
ps_err_e
|
||
ps_lsetxregs (const struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
|
||
{
|
||
#if 0
|
||
int lwp_fd;
|
||
ps_err_e val;
|
||
|
||
val = get_lwp_fd (ph, lwpid, &lwp_fd);
|
||
if (val != PS_OK)
|
||
return val;
|
||
|
||
if (ioctl (lwp_fd, PIOCSXREG, xregset))
|
||
{
|
||
print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno);
|
||
return PS_ERR;
|
||
}
|
||
#endif
|
||
|
||
return PS_OK;
|
||
}
|
||
|
||
/* Get floating-point regs. */
|
||
|
||
ps_err_e
|
||
ps_lgetfpregs (const struct ps_prochandle *ph, lwpid_t lwpid,
|
||
prfpregset_t *fpregset)
|
||
{
|
||
struct cleanup *old_chain;
|
||
|
||
old_chain = save_inferior_pid ();
|
||
|
||
inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
|
||
|
||
if (target_has_execution)
|
||
procfs_ops.to_fetch_registers (-1);
|
||
else
|
||
orig_core_ops.to_fetch_registers (-1);
|
||
fill_fpregset (fpregset, -1);
|
||
|
||
do_cleanups (old_chain);
|
||
|
||
return PS_OK;
|
||
}
|
||
|
||
/* Set floating-point regs. */
|
||
|
||
ps_err_e
|
||
ps_lsetfpregs (const struct ps_prochandle *ph, lwpid_t lwpid,
|
||
const prfpregset_t *fpregset)
|
||
{
|
||
struct cleanup *old_chain;
|
||
|
||
old_chain = save_inferior_pid ();
|
||
|
||
inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
|
||
|
||
supply_fpregset (fpregset);
|
||
if (target_has_execution)
|
||
procfs_ops.to_store_registers (-1);
|
||
else
|
||
orig_core_ops.to_store_registers (-1);
|
||
|
||
do_cleanups (old_chain);
|
||
|
||
return PS_OK;
|
||
}
|
||
|
||
#ifdef TM_I386SOL2_H
|
||
|
||
/* Get local descriptor table. */
|
||
|
||
#include <sys/procfs.h>
|
||
#include <sys/reg.h>
|
||
#include <sys/sysi86.h>
|
||
|
||
static int nldt_allocated = 0;
|
||
static struct ssd *ldt_bufp = NULL;
|
||
|
||
ps_err_e
|
||
ps_lgetLDT (const struct ps_prochandle *ph, lwpid_t lwpid,
|
||
struct ssd *pldt)
|
||
{
|
||
gregset_t gregset;
|
||
int lwp_fd;
|
||
ps_err_e val;
|
||
int nldt;
|
||
int i;
|
||
|
||
/* Get procfs file descriptor for the LWP. */
|
||
lwp_fd = procfs_get_pid_fd (BUILD_LWP (lwpid, PIDGET (inferior_pid)));
|
||
if (lwp_fd < 0)
|
||
return PS_BADLID;
|
||
|
||
/* Fetch registers und LDT descriptors. */
|
||
if (ioctl (lwp_fd, PIOCGREG, &gregset) == -1)
|
||
return PS_ERR;
|
||
|
||
if (ioctl (lwp_fd, PIOCNLDT, &nldt) == -1)
|
||
return PS_ERR;
|
||
|
||
if (nldt_allocated < nldt)
|
||
{
|
||
ldt_bufp
|
||
= (struct ssd *) xrealloc (ldt_bufp, (nldt + 1) * sizeof (struct ssd));
|
||
nldt_allocated = nldt;
|
||
}
|
||
|
||
if (ioctl (lwp_fd, PIOCLDT, ldt_bufp) == -1)
|
||
return PS_ERR;
|
||
|
||
/* Search LDT for the LWP via register GS. */
|
||
for (i = 0; i < nldt; i++)
|
||
{
|
||
if (ldt_bufp[i].sel == (gregset[GS] & 0xffff))
|
||
{
|
||
*pldt = ldt_bufp[i];
|
||
return PS_OK;
|
||
}
|
||
}
|
||
|
||
/* LDT not found. */
|
||
return PS_ERR;
|
||
}
|
||
#endif /* TM_I386SOL2_H */
|
||
|
||
/* Convert a pid to printable form. */
|
||
|
||
char *
|
||
solaris_pid_to_str (pid)
|
||
int pid;
|
||
{
|
||
static char buf[100];
|
||
|
||
/* in case init failed to resolve the libthread_db library */
|
||
if (!procfs_suppress_run)
|
||
return procfs_pid_to_str (pid);
|
||
|
||
if (is_thread (pid))
|
||
{
|
||
int lwp;
|
||
|
||
lwp = thread_to_lwp (pid, -2);
|
||
|
||
if (lwp == -1)
|
||
sprintf (buf, "Thread %d (defunct)", GET_THREAD (pid));
|
||
else if (lwp != -2)
|
||
sprintf (buf, "Thread %d (LWP %d)", GET_THREAD (pid), GET_LWP (lwp));
|
||
else
|
||
sprintf (buf, "Thread %d ", GET_THREAD (pid));
|
||
}
|
||
else if (GET_LWP (pid) != 0)
|
||
sprintf (buf, "LWP %d ", GET_LWP (pid));
|
||
else
|
||
sprintf (buf, "process %d ", PIDGET (pid));
|
||
|
||
return buf;
|
||
}
|
||
|
||
|
||
/* Worker bee for find_new_threads
|
||
Callback function that gets called once per USER thread (i.e., not
|
||
kernel) thread. */
|
||
|
||
static int
|
||
sol_find_new_threads_callback(th, ignored)
|
||
const td_thrhandle_t *th;
|
||
void *ignored;
|
||
{
|
||
td_err_e retval;
|
||
td_thrinfo_t ti;
|
||
int pid;
|
||
|
||
if ((retval = p_td_thr_get_info(th, &ti)) != TD_OK)
|
||
{
|
||
return -1;
|
||
}
|
||
pid = BUILD_THREAD(ti.ti_tid, PIDGET(inferior_pid));
|
||
if (!in_thread_list(pid))
|
||
add_thread(pid);
|
||
|
||
return 0;
|
||
}
|
||
|
||
void
|
||
sol_find_new_threads()
|
||
{
|
||
/* don't do anything if init failed to resolve the libthread_db library */
|
||
if (!procfs_suppress_run)
|
||
return;
|
||
|
||
if (inferior_pid == -1)
|
||
{
|
||
printf_filtered("No process.\n");
|
||
return;
|
||
}
|
||
p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *)0,
|
||
TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
|
||
TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
|
||
}
|
||
|
||
static void
|
||
sol_core_open (filename, from_tty)
|
||
char *filename;
|
||
int from_tty;
|
||
{
|
||
orig_core_ops.to_open (filename, from_tty);
|
||
}
|
||
|
||
static void
|
||
sol_core_close (quitting)
|
||
int quitting;
|
||
{
|
||
orig_core_ops.to_close (quitting);
|
||
}
|
||
|
||
static void
|
||
sol_core_detach (args, from_tty)
|
||
char *args;
|
||
int from_tty;
|
||
{
|
||
unpush_target (&core_ops);
|
||
orig_core_ops.to_detach (args, from_tty);
|
||
}
|
||
|
||
static void
|
||
sol_core_files_info (t)
|
||
struct target_ops *t;
|
||
{
|
||
orig_core_ops.to_files_info (t);
|
||
}
|
||
|
||
#ifdef MAINTENANCE_CMDS
|
||
/* Worker bee for info sol-thread command. This is a callback function that
|
||
gets called once for each Solaris thread (ie. not kernel thread) in the
|
||
inferior. Print anything interesting that we can think of. */
|
||
|
||
static int
|
||
info_cb (th, s)
|
||
const td_thrhandle_t *th;
|
||
void *s;
|
||
{
|
||
td_err_e ret;
|
||
td_thrinfo_t ti;
|
||
struct minimal_symbol *msym;
|
||
|
||
if ((ret = p_td_thr_get_info (th, &ti)) == TD_OK)
|
||
{
|
||
printf_filtered ("%s thread #%d, lwp %d, ",
|
||
ti.ti_type == TD_THR_SYSTEM ? "system" : "user ",
|
||
ti.ti_tid, ti.ti_lid);
|
||
switch (ti.ti_state) {
|
||
default:
|
||
case TD_THR_UNKNOWN: printf_filtered ("<unknown state>"); break;
|
||
case TD_THR_STOPPED: printf_filtered ("(stopped)"); break;
|
||
case TD_THR_RUN: printf_filtered ("(run) "); break;
|
||
case TD_THR_ACTIVE: printf_filtered ("(active) "); break;
|
||
case TD_THR_ZOMBIE: printf_filtered ("(zombie) "); break;
|
||
case TD_THR_SLEEP: printf_filtered ("(asleep) "); break;
|
||
case TD_THR_STOPPED_ASLEEP:
|
||
printf_filtered ("(stopped asleep)"); break;
|
||
}
|
||
/* Print thr_create start function: */
|
||
if (ti.ti_startfunc != 0)
|
||
if (msym = lookup_minimal_symbol_by_pc (ti.ti_startfunc))
|
||
printf_filtered (" startfunc: %s\n", SYMBOL_NAME (msym));
|
||
else
|
||
printf_filtered (" startfunc: 0x%08x\n", ti.ti_startfunc);
|
||
|
||
/* If thread is asleep, print function that went to sleep: */
|
||
if (ti.ti_state == TD_THR_SLEEP)
|
||
if (msym = lookup_minimal_symbol_by_pc (ti.ti_pc))
|
||
printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym));
|
||
else
|
||
printf_filtered (" - Sleep func: 0x%08x\n", ti.ti_startfunc);
|
||
|
||
/* Wrap up line, if necessary */
|
||
if (ti.ti_state != TD_THR_SLEEP && ti.ti_startfunc == 0)
|
||
printf_filtered ("\n"); /* don't you hate counting newlines? */
|
||
}
|
||
else
|
||
warning ("info sol-thread: failed to get info for thread.");
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* List some state about each Solaris user thread in the inferior. */
|
||
|
||
static void
|
||
info_solthreads (args, from_tty)
|
||
char *args;
|
||
int from_tty;
|
||
{
|
||
p_td_ta_thr_iter (main_ta, info_cb, args,
|
||
TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
|
||
TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
|
||
}
|
||
#endif /* MAINTENANCE_CMDS */
|
||
|
||
static int
|
||
ignore (addr, contents)
|
||
CORE_ADDR addr;
|
||
char *contents;
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
struct target_ops sol_thread_ops = {
|
||
"solaris-threads", /* to_shortname */
|
||
"Solaris threads and pthread.", /* to_longname */
|
||
"Solaris threads and pthread support.", /* to_doc */
|
||
sol_thread_open, /* to_open */
|
||
0, /* to_close */
|
||
sol_thread_attach, /* to_attach */
|
||
sol_thread_detach, /* to_detach */
|
||
sol_thread_resume, /* to_resume */
|
||
sol_thread_wait, /* to_wait */
|
||
sol_thread_fetch_registers, /* to_fetch_registers */
|
||
sol_thread_store_registers, /* to_store_registers */
|
||
sol_thread_prepare_to_store, /* to_prepare_to_store */
|
||
sol_thread_xfer_memory, /* to_xfer_memory */
|
||
sol_thread_files_info, /* to_files_info */
|
||
memory_insert_breakpoint, /* to_insert_breakpoint */
|
||
memory_remove_breakpoint, /* to_remove_breakpoint */
|
||
terminal_init_inferior, /* to_terminal_init */
|
||
terminal_inferior, /* to_terminal_inferior */
|
||
terminal_ours_for_output, /* to_terminal_ours_for_output */
|
||
terminal_ours, /* to_terminal_ours */
|
||
child_terminal_info, /* to_terminal_info */
|
||
sol_thread_kill_inferior, /* to_kill */
|
||
0, /* to_load */
|
||
0, /* to_lookup_symbol */
|
||
sol_thread_create_inferior, /* to_create_inferior */
|
||
sol_thread_mourn_inferior, /* to_mourn_inferior */
|
||
sol_thread_can_run, /* to_can_run */
|
||
sol_thread_notice_signals, /* to_notice_signals */
|
||
sol_thread_alive, /* to_thread_alive */
|
||
sol_thread_stop, /* to_stop */
|
||
process_stratum, /* to_stratum */
|
||
0, /* to_next */
|
||
1, /* to_has_all_memory */
|
||
1, /* to_has_memory */
|
||
1, /* to_has_stack */
|
||
1, /* to_has_registers */
|
||
1, /* to_has_execution */
|
||
0, /* sections */
|
||
0, /* sections_end */
|
||
OPS_MAGIC /* to_magic */
|
||
};
|
||
|
||
struct target_ops sol_core_ops = {
|
||
"solaris-core", /* to_shortname */
|
||
"Solaris core threads and pthread.", /* to_longname */
|
||
"Solaris threads and pthread support for core files.", /* to_doc */
|
||
sol_core_open, /* to_open */
|
||
sol_core_close, /* to_close */
|
||
sol_thread_attach, /* XXX to_attach */
|
||
sol_core_detach, /* to_detach */
|
||
0, /* to_resume */
|
||
0, /* to_wait */
|
||
sol_thread_fetch_registers, /* to_fetch_registers */
|
||
0, /* to_store_registers */
|
||
0, /* to_prepare_to_store */
|
||
sol_thread_xfer_memory, /* XXX to_xfer_memory */
|
||
sol_core_files_info, /* to_files_info */
|
||
ignore, /* to_insert_breakpoint */
|
||
ignore, /* to_remove_breakpoint */
|
||
0, /* to_terminal_init */
|
||
0, /* to_terminal_inferior */
|
||
0, /* to_terminal_ours_for_output */
|
||
0, /* to_terminal_ours */
|
||
0, /* to_terminal_info */
|
||
0, /* to_kill */
|
||
0, /* to_load */
|
||
0, /* to_lookup_symbol */
|
||
sol_thread_create_inferior, /* XXX to_create_inferior */
|
||
0, /* to_mourn_inferior */
|
||
0, /* to_can_run */
|
||
0, /* to_notice_signals */
|
||
0, /* to_thread_alive */
|
||
0, /* to_stop */
|
||
core_stratum, /* to_stratum */
|
||
0, /* to_next */
|
||
0, /* to_has_all_memory */
|
||
1, /* to_has_memory */
|
||
1, /* to_has_stack */
|
||
1, /* to_has_registers */
|
||
0, /* to_has_execution */
|
||
0, /* sections */
|
||
0, /* sections_end */
|
||
OPS_MAGIC /* to_magic */
|
||
};
|
||
|
||
/* we suppress the call to add_target of core_ops in corelow because
|
||
if there are two targets in the stratum core_stratum, find_core_target
|
||
won't know which one to return. see corelow.c for an additonal
|
||
comment on coreops_suppress_target. */
|
||
int coreops_suppress_target = 1;
|
||
|
||
void
|
||
_initialize_sol_thread ()
|
||
{
|
||
void *dlhandle;
|
||
|
||
dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
|
||
if (!dlhandle)
|
||
goto die;
|
||
|
||
#define resolve(X) \
|
||
if (!(p_##X = dlsym (dlhandle, #X))) \
|
||
goto die;
|
||
|
||
resolve (td_log);
|
||
resolve (td_ta_new);
|
||
resolve (td_ta_delete);
|
||
resolve (td_init);
|
||
resolve (td_ta_get_ph);
|
||
resolve (td_ta_get_nthreads);
|
||
resolve (td_ta_tsd_iter);
|
||
resolve (td_ta_thr_iter);
|
||
resolve (td_thr_validate);
|
||
resolve (td_thr_tsd);
|
||
resolve (td_thr_get_info);
|
||
resolve (td_thr_getfpregs);
|
||
resolve (td_thr_getxregsize);
|
||
resolve (td_thr_getxregs);
|
||
resolve (td_thr_sigsetmask);
|
||
resolve (td_thr_setprio);
|
||
resolve (td_thr_setsigpending);
|
||
resolve (td_thr_setfpregs);
|
||
resolve (td_thr_setxregs);
|
||
resolve (td_ta_map_id2thr);
|
||
resolve (td_ta_map_lwp2thr);
|
||
resolve (td_thr_getgregs);
|
||
resolve (td_thr_setgregs);
|
||
|
||
add_target (&sol_thread_ops);
|
||
|
||
procfs_suppress_run = 1;
|
||
|
||
#ifdef MAINTENANCE_CMDS
|
||
add_cmd ("sol-threads", class_maintenance, info_solthreads,
|
||
"Show info on Solaris user threads.\n", &maintenanceinfolist);
|
||
#endif /* MAINTENANCE_CMDS */
|
||
|
||
memcpy(&orig_core_ops, &core_ops, sizeof (struct target_ops));
|
||
memcpy(&core_ops, &sol_core_ops, sizeof (struct target_ops));
|
||
add_target (&core_ops);
|
||
|
||
return;
|
||
|
||
die:
|
||
|
||
fprintf_unfiltered (gdb_stderr, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
|
||
|
||
if (dlhandle)
|
||
dlclose (dlhandle);
|
||
|
||
/* allow the user to debug non-threaded core files */
|
||
add_target(&core_ops);
|
||
|
||
return;
|
||
}
|