+++ /dev/null
-/* Multi-threaded debugging support for the thread_db interface,
- used on operating systems such as Solaris and Linux.
- Copyright 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 thread_stratum target that sits on top of
- a normal process_stratum target (such as procfs or ptrace). The
- process_stratum target must install this thread_stratum target when
- it detects the presence of the thread_db shared library.
-
- This module will then use the thread_db API to add thread-awareness
- to the functionality provided by the process_stratum target (or in
- some cases, to add user-level thread awareness on top of the
- kernel-level thread awareness that is already provided by the
- process_stratum target).
-
- Solaris threads (for instance) are a multi-level thread implementation;
- the kernel provides a Light Weight Process (LWP) which the procfs
- process_stratum module is aware of. This module must then mediate
- the relationship between kernel LWP threads and user (eg. posix)
- threads.
-
- Linux threads are likely to be different -- but the thread_db
- library API should make the difference largely transparent to GDB.
-
- */
-
-/* The thread_db API provides a number of functions that give the caller
- access to the inner workings of the child process's thread library.
- We will be using the following (others may be added):
-
- td_thr_validate Confirm valid "live" thread
- td_thr_get_info Get info about a thread
- td_thr_getgregs Get thread's general registers
- td_thr_getfpregs Get thread's floating point registers
- td_thr_setgregs Set thread's general registers
- td_thr_setfpregs Set thread's floating point registers
- td_ta_map_id2thr Get thread handle from thread id
- td_ta_map_lwp2thr Get thread handle from LWP id
- td_ta_thr_iter Iterate over all threads (with callback)
-
- In return, the debugger has to provide certain services to the
- thread_db library. Some of these aren't actually required to do
- anything in practice. For instance, the thread_db expects to be
- able to stop the child process and start it again: but in our
- context, the child process will always be stopped already when we
- invoke the thread_db library, so the functions that we provide for
- the library to stop and start the child process are no-ops.
-
- Here is the list of functions which we export to the thread_db
- library, divided into no-op functions vs. functions that actually
- have to do something:
-
- No-op functions:
-
- ps_pstop Stop the child process
- ps_pcontinue Continue the child process
- ps_lstop Stop a specific LWP (kernel thread)
- ps_lcontinue Continue an LWP
- ps_lgetxregsize Get size of LWP's xregs (sparc)
- ps_lgetxregs Get LWP's xregs (sparc)
- ps_lsetxregs Set LWP's xregs (sparc)
-
- Functions that have to do useful work:
-
- ps_pglobal_lookup Get the address of a global symbol
- ps_pdread Read memory, data segment
- ps_ptread Read memory, text segment
- ps_pdwrite Write memory, data segment
- ps_ptwrite Write memory, text segment
- ps_lgetregs Get LWP's general registers
- ps_lgetfpregs Get LWP's floating point registers
- ps_lsetregs Set LWP's general registers
- ps_lsetfpregs Set LWP's floating point registers
- ps_lgetLDT Get LWP's Local Descriptor Table (x86)
-
- Thus, if we ask the thread_db library to give us the general registers
- for user thread X, thread_db may figure out that user thread X is
- actually mapped onto kernel thread Y. Thread_db does not know how
- to obtain the registers for kernel thread Y, but GDB does, so thread_db
- turns the request right back to us via the ps_lgetregs callback. */
-
-#include "defs.h"
-#include "gdbthread.h"
-#include "target.h"
-#include "inferior.h"
-#include "gdbcmd.h"
-#include "regcache.h"
-
-#include "gdb_wait.h"
-
-#include <time.h>
-
-#if defined(USE_PROC_FS) || defined(HAVE_GREGSET_T)
-#include <sys/procfs.h>
-#endif
-
-#include "gdb_proc_service.h"
-
-#if defined HAVE_STDINT_H /* Pre-5.2 systems don't have this header */
-#if defined (HAVE_THREAD_DB_H)
-#include <thread_db.h> /* defines outgoing API (td_thr_* calls) */
-#else
-#include "gdb_thread_db.h"
-#endif
-
-#include <dlfcn.h> /* dynamic library interface */
-
-/* Prototypes for supply_gregset etc. */
-#include "gregset.h"
-
-/* Macros for superimposing PID and TID into inferior_ptid. */
-#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)
-
-/* From linux-thread.c. FIXME: These should go in a separate header
- file, but I'm told that the life expectancy of lin-thread.c and
- linux-thread.c isn't very long... */
-
-extern int linux_child_wait (int, int *, int *);
-extern void check_all_signal_numbers (void);
-extern void linuxthreads_discard_global_state (void);
-extern void attach_thread (int);
-
-/*
- * target_beneath is a pointer to the target_ops underlying this one.
- */
-
-static struct target_ops *target_beneath;
-
-
-/*
- * target vector defined in this module:
- */
-
-static struct target_ops thread_db_ops;
-
-/*
- * Typedefs required to resolve differences between the thread_db
- * and proc_service API defined on different versions of Solaris:
- */
-
-#if defined(PROC_SERVICE_IS_OLD)
-typedef const struct ps_prochandle *gdb_ps_prochandle_t;
-typedef char *gdb_ps_read_buf_t;
-typedef char *gdb_ps_write_buf_t;
-typedef int gdb_ps_size_t;
-#else
-typedef struct ps_prochandle *gdb_ps_prochandle_t;
-typedef void *gdb_ps_read_buf_t;
-typedef const void *gdb_ps_write_buf_t;
-typedef size_t gdb_ps_size_t;
-#endif
-
-/*
- * proc_service callback functions, called by thread_db.
- */
-
-ps_err_e
-ps_pstop (gdb_ps_prochandle_t ph) /* Process stop */
-{
- return PS_OK;
-}
-
-ps_err_e
-ps_pcontinue (gdb_ps_prochandle_t ph) /* Process continue */
-{
- return PS_OK;
-}
-
-ps_err_e
-ps_lstop (gdb_ps_prochandle_t ph, /* LWP stop */
- lwpid_t lwpid)
-{
- return PS_OK;
-}
-
-ps_err_e
-ps_lcontinue (gdb_ps_prochandle_t ph, /* LWP continue */
- lwpid_t lwpid)
-{
- return PS_OK;
-}
-
-ps_err_e
-ps_lgetxregsize (gdb_ps_prochandle_t ph, /* Get XREG size */
- lwpid_t lwpid,
- int *xregsize)
-{
- return PS_OK;
-}
-
-ps_err_e
-ps_lgetxregs (gdb_ps_prochandle_t ph, /* Get XREGS */
- lwpid_t lwpid,
- caddr_t xregset)
-{
- return PS_OK;
-}
-
-ps_err_e
-ps_lsetxregs (gdb_ps_prochandle_t ph, /* Set XREGS */
- lwpid_t lwpid,
- caddr_t xregset)
-{
- return PS_OK;
-}
-
-void
-ps_plog (const char *fmt, ...)
-{
- va_list args;
-
- va_start (args, fmt);
- vfprintf_filtered (gdb_stderr, fmt, args);
-}
-
-/* Look up a symbol in GDB's global symbol table.
- Return the symbol's address.
- FIXME: it would be more correct to look up the symbol in the context
- of the LD_OBJECT_NAME provided. However we're probably fairly safe
- as long as there aren't name conflicts with other libraries. */
-
-ps_err_e
-ps_pglobal_lookup (gdb_ps_prochandle_t ph,
- const char *ld_object_name, /* the library name */
- const char *ld_symbol_name, /* the symbol name */
- paddr_t *ld_symbol_addr) /* return the 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;
-}
-
-/* Worker function for all memory reads and writes: */
-static ps_err_e rw_common (const struct ps_prochandle *ph,
- paddr_t addr,
- char *buf,
- int size,
- int write_p);
-
-/* target_xfer_memory direction consts */
-enum {PS_READ = 0, PS_WRITE = 1};
-
-ps_err_e
-ps_pdread (gdb_ps_prochandle_t ph, /* read from data segment */
- paddr_t addr,
- gdb_ps_read_buf_t buf,
- gdb_ps_size_t size)
-{
- return rw_common (ph, addr, buf, size, PS_READ);
-}
-
-ps_err_e
-ps_pdwrite (gdb_ps_prochandle_t ph, /* write to data segment */
- paddr_t addr,
- gdb_ps_write_buf_t buf,
- gdb_ps_size_t size)
-{
- return rw_common (ph, addr, (char *) buf, size, PS_WRITE);
-}
-
-ps_err_e
-ps_ptread (gdb_ps_prochandle_t ph, /* read from text segment */
- paddr_t addr,
- gdb_ps_read_buf_t buf,
- gdb_ps_size_t size)
-{
- return rw_common (ph, addr, buf, size, PS_READ);
-}
-
-ps_err_e
-ps_ptwrite (gdb_ps_prochandle_t ph, /* write to text segment */
- paddr_t addr,
- gdb_ps_write_buf_t buf,
- gdb_ps_size_t size)
-{
- return rw_common (ph, addr, (char *) buf, size, PS_WRITE);
-}
-
-static char *thr_err_string (td_err_e);
-static char *thr_state_string (td_thr_state_e);
-
-struct ps_prochandle main_prochandle;
-td_thragent_t * main_threadagent;
-
-/*
- * Common proc_service routine for reading and writing memory.
- */
-
-/* FIXME: once we've munged the inferior_ptid, why can't we
- simply call target_read/write_memory and return? */
-
-static ps_err_e
-rw_common (const struct ps_prochandle *ph,
- paddr_t addr,
- char *buf,
- int size,
- int write_p)
-{
- struct cleanup *old_chain = save_inferior_ptid ();
- int to_do = size;
- int done = 0;
-
- inferior_ptid = pid_to_ptid (main_prochandle.pid);
-
- while (to_do > 0)
- {
- done = current_target.to_xfer_memory (addr, buf, size, write_p,
- ¤t_target);
- if (done <= 0)
- {
- if (write_p == PS_READ)
- print_sys_errmsg ("rw_common (): read", errno);
- else
- print_sys_errmsg ("rw_common (): write", errno);
-
- return PS_ERR;
- }
- to_do -= done;
- buf += done;
- }
- do_cleanups (old_chain);
- return PS_OK;
-}
-
-/* Cleanup functions used by the register callbacks
- (which have to manipulate the global inferior_ptid). */
-
-ps_err_e
-ps_lgetregs (gdb_ps_prochandle_t ph, /* Get LWP general regs */
- lwpid_t lwpid,
- prgregset_t gregset)
-{
- struct cleanup *old_chain = save_inferior_ptid ();
-
- inferior_ptid = BUILD_LWP (lwpid, main_prochandle.pid);
- current_target.to_fetch_registers (-1);
-
- fill_gregset ((gdb_gregset_t *) gregset, -1);
- do_cleanups (old_chain);
-
- return PS_OK;
-}
-
-ps_err_e
-ps_lsetregs (gdb_ps_prochandle_t ph, /* Set LWP general regs */
- lwpid_t lwpid,
- const prgregset_t gregset)
-{
- struct cleanup *old_chain = save_inferior_ptid ();
-
- inferior_ptid = BUILD_LWP (lwpid, main_prochandle.pid);
- supply_gregset ((gdb_gregset_t *) gregset);
- current_target.to_store_registers (-1);
- do_cleanups (old_chain);
- return PS_OK;
-}
-
-ps_err_e
-ps_lgetfpregs (gdb_ps_prochandle_t ph, /* Get LWP float regs */
- lwpid_t lwpid,
- gdb_prfpregset_t *fpregset)
-{
- struct cleanup *old_chain = save_inferior_ptid ();
-
- inferior_ptid = BUILD_LWP (lwpid, main_prochandle.pid);
- current_target.to_fetch_registers (-1);
- fill_fpregset (fpregset, -1);
- do_cleanups (old_chain);
- return PS_OK;
-}
-
-ps_err_e
-ps_lsetfpregs (gdb_ps_prochandle_t ph, /* Set LWP float regs */
- lwpid_t lwpid,
- const gdb_prfpregset_t *fpregset)
-{
- struct cleanup *old_chain = save_inferior_ptid ();
-
- inferior_ptid = BUILD_LWP (lwpid, main_prochandle.pid);
- supply_fpregset (fpregset);
- current_target.to_store_registers (-1);
- do_cleanups (old_chain);
- return PS_OK;
-}
-
-/*
- * ps_getpid
- *
- * return the main pid for the child process
- * (special for Linux -- not used on Solaris)
- */
-
-pid_t
-ps_getpid (gdb_ps_prochandle_t ph)
-{
- return ph->pid;
-}
-
-#ifdef TM_I386SOL2_H
-
-/* Reads the local descriptor table of a LWP. */
-
-ps_err_e
-ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
- struct ssd *pldt)
-{
- /* NOTE: only used on Solaris, therefore OK to refer to procfs.c */
- extern struct ssd *procfs_find_LDT_entry (int);
- struct ssd *ret;
-
- ret = procfs_find_LDT_entry (BUILD_LWP (lwpid,
- PIDGET (main_prochandle.pid)));
- if (ret)
- {
- memcpy (pldt, ret, sizeof (struct ssd));
- return PS_OK;
- }
- else /* LDT not found. */
- return PS_ERR;
-}
-#endif /* TM_I386SOL2_H */
-
-/*
- * Pointers to thread_db functions:
- *
- * These are a dynamic library mechanism.
- * The dlfcn.h interface will be used to initialize these
- * so that they point to the appropriate functions in the
- * thread_db dynamic library. This is done dynamically
- * so that GDB can still run on systems that lack thread_db.
- */
-
-static td_err_e (*p_td_init) (void);
-
-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_ta_get_nthreads) (const td_thragent_t *ta_p,
- int *nthread_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_ta_event_addr) (const td_thragent_t *ta_p,
- u_long event,
- td_notify_t *notify_p);
-
-static td_err_e (*p_td_ta_event_getmsg) (const td_thragent_t *ta_p,
- td_event_msg_t *msg);
-
-static td_err_e (*p_td_ta_set_event) (const td_thragent_t *ta_p,
- td_thr_events_t *events);
-
-static td_err_e (*p_td_thr_validate) (const td_thrhandle_t *th_p);
-
-static td_err_e (*p_td_thr_event_enable) (const td_thrhandle_t *th_p,
- int on_off);
-
-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_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);
-
-static td_err_e (*p_td_thr_getfpregs) (const td_thrhandle_t *th_p,
- gdb_prfpregset_t *fpregset);
-
-static td_err_e (*p_td_thr_setfpregs) (const td_thrhandle_t *th_p,
- const gdb_prfpregset_t *fpregset);
-
-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);
-
-/*
- * API and target vector initialization function: thread_db_initialize.
- *
- * NOTE: this function is deliberately NOT named with the GDB convention
- * of module initializer function names that begin with "_initialize".
- * This module is NOT intended to be auto-initialized at GDB startup.
- * Rather, it will only be initialized when a multi-threaded child
- * process is detected.
- *
- */
-
-/*
- * Initializer for thread_db library interface.
- * This function does the dynamic library stuff (dlopen, dlsym),
- * and then calls the thread_db library's one-time initializer
- * function (td_init). If everything succeeds, this function
- * returns true; otherwise it returns false, and this module
- * cannot be used.
- */
-
-static int
-init_thread_db_library (void)
-{
- void *dlhandle;
- td_err_e ret;
-
- /* Open a handle to the "thread_db" dynamic library. */
- if ((dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW)) == NULL)
- return 0; /* fail */
-
- /* Initialize pointers to the dynamic library functions we will use.
- * Note that we are not calling the functions here -- we are only
- * establishing pointers to them.
- */
-
- /* td_init: initialize thread_db library. */
- if ((p_td_init = dlsym (dlhandle, "td_init")) == NULL)
- return 0; /* fail */
- /* td_ta_new: register a target process with thread_db. */
- if ((p_td_ta_new = dlsym (dlhandle, "td_ta_new")) == NULL)
- return 0; /* fail */
- /* td_ta_delete: un-register a target process with thread_db. */
- if ((p_td_ta_delete = dlsym (dlhandle, "td_ta_delete")) == NULL)
- return 0; /* fail */
-
- /* td_ta_map_id2thr: get thread handle from thread id. */
- if ((p_td_ta_map_id2thr = dlsym (dlhandle, "td_ta_map_id2thr")) == NULL)
- return 0; /* fail */
- /* td_ta_map_lwp2thr: get thread handle from lwp id. */
- if ((p_td_ta_map_lwp2thr = dlsym (dlhandle, "td_ta_map_lwp2thr")) == NULL)
- return 0; /* fail */
- /* td_ta_get_nthreads: get number of threads in target process. */
- if ((p_td_ta_get_nthreads = dlsym (dlhandle, "td_ta_get_nthreads")) == NULL)
- return 0; /* fail */
- /* td_ta_thr_iter: iterate over all thread handles. */
- if ((p_td_ta_thr_iter = dlsym (dlhandle, "td_ta_thr_iter")) == NULL)
- return 0; /* fail */
-
- /* td_thr_validate: make sure a thread handle is real and alive. */
- if ((p_td_thr_validate = dlsym (dlhandle, "td_thr_validate")) == NULL)
- return 0; /* fail */
- /* td_thr_get_info: get a bunch of info about a thread. */
- if ((p_td_thr_get_info = dlsym (dlhandle, "td_thr_get_info")) == NULL)
- return 0; /* fail */
- /* td_thr_getgregs: get general registers for thread. */
- if ((p_td_thr_getgregs = dlsym (dlhandle, "td_thr_getgregs")) == NULL)
- return 0; /* fail */
- /* td_thr_setgregs: set general registers for thread. */
- if ((p_td_thr_setgregs = dlsym (dlhandle, "td_thr_setgregs")) == NULL)
- return 0; /* fail */
- /* td_thr_getfpregs: get floating point registers for thread. */
- if ((p_td_thr_getfpregs = dlsym (dlhandle, "td_thr_getfpregs")) == NULL)
- return 0; /* fail */
- /* td_thr_setfpregs: set floating point registers for thread. */
- if ((p_td_thr_setfpregs = dlsym (dlhandle, "td_thr_setfpregs")) == NULL)
- return 0; /* fail */
-
- ret = p_td_init ();
- if (ret != TD_OK)
- {
- warning ("init_thread_db: td_init: %s", thr_err_string (ret));
- return 0;
- }
-
- /* Optional functions:
- We can still debug even if the following functions are not found. */
-
- /* td_ta_event_addr: get the breakpoint address for specified event. */
- p_td_ta_event_addr = dlsym (dlhandle, "td_ta_event_addr");
-
- /* td_ta_event_getmsg: get the next event message for the process. */
- p_td_ta_event_getmsg = dlsym (dlhandle, "td_ta_event_getmsg");
-
- /* td_ta_set_event: request notification of an event. */
- p_td_ta_set_event = dlsym (dlhandle, "td_ta_set_event");
-
- /* td_thr_event_enable: enable event reporting in a thread. */
- p_td_thr_event_enable = dlsym (dlhandle, "td_thr_event_enable");
-
- return 1; /* success */
-}
-
-/*
- * Local utility functions:
- */
-
-/*
-
- LOCAL FUNCTION
-
- thr_err_string - Convert a thread_db error code to a string
-
- SYNOPSIS
-
- char * thr_err_string (errcode)
-
- DESCRIPTION
-
- Return a string description of the thread_db errcode. If errcode
- is unknown, then return an <unknown> message.
-
- */
-
-static char *
-thr_err_string (td_err_e errcode)
-{
- static char buf[50];
-
- switch (errcode) {
- case TD_OK: return "generic 'call succeeded'";
- case TD_ERR: return "generic error";
- case TD_NOTHR: return "no thread to satisfy query";
- case TD_NOSV: return "no sync handle to satisfy query";
- case TD_NOLWP: return "no lwp to satisfy query";
- case TD_BADPH: return "invalid process handle";
- case TD_BADTH: return "invalid thread handle";
- case TD_BADSH: return "invalid synchronization handle";
- case TD_BADTA: return "invalid thread agent";
- case TD_BADKEY: return "invalid key";
- case TD_NOMSG: return "no event message for getmsg";
- case TD_NOFPREGS: return "FPU register set not available";
- case TD_NOLIBTHREAD: return "application not linked with libthread";
- case TD_NOEVENT: return "requested event is not supported";
- case TD_NOCAPAB: return "capability not available";
- case TD_DBERR: return "debugger service failed";
- case TD_NOAPLIC: return "operation not applicable to";
- case TD_NOTSD: return "no thread-specific data for this thread";
- case TD_MALLOC: return "malloc failed";
- case TD_PARTIALREG: return "only part of register set was written/read";
- case TD_NOXREGS: return "X register set not available for this thread";
- default:
- sprintf (buf, "unknown thread_db error '%d'", errcode);
- return buf;
- }
-}
-
-/*
-
- LOCAL FUNCTION
-
- thr_state_string - Convert a thread_db state code to a string
-
- SYNOPSIS
-
- char *thr_state_string (statecode)
-
- DESCRIPTION
-
- Return the thread_db state string associated with statecode.
- If statecode is unknown, then return an <unknown> message.
-
- */
-
-static char *
-thr_state_string (td_thr_state_e statecode)
-{
- static char buf[50];
-
- switch (statecode) {
- case TD_THR_STOPPED: return "stopped by debugger";
- case TD_THR_RUN: return "runnable";
- case TD_THR_ACTIVE: return "active";
- case TD_THR_ZOMBIE: return "zombie";
- case TD_THR_SLEEP: return "sleeping";
- case TD_THR_STOPPED_ASLEEP: return "stopped by debugger AND blocked";
- default:
- sprintf (buf, "unknown thread_db state %d", statecode);
- return buf;
- }
-}
-
-/*
- * Local thread/event list.
- * This data structure will be used to hold a list of threads and
- * pending/deliverable events.
- */
-
-typedef struct THREADINFO {
- thread_t tid; /* thread ID */
- pid_t lid; /* process/lwp ID */
- td_thr_state_e state; /* thread state (a la thread_db) */
- td_thr_type_e type; /* thread type (a la thread_db) */
- int pending; /* true if holding a pending event */
- int status; /* wait status of any interesting event */
-} threadinfo;
-
-threadinfo * threadlist;
-int threadlist_max = 0; /* current size of table */
-int threadlist_top = 0; /* number of threads now in table */
-#define THREADLIST_ALLOC 100 /* chunk size by which to expand table */
-
-static threadinfo *
-insert_thread (int tid, int lid, td_thr_state_e state, td_thr_type_e type)
-{
- if (threadlist_top >= threadlist_max)
- {
- threadlist_max += THREADLIST_ALLOC;
- threadlist = xrealloc (threadlist,
- threadlist_max * sizeof (threadinfo));
- if (threadlist == NULL)
- return NULL;
- }
- threadlist[threadlist_top].tid = tid;
- threadlist[threadlist_top].lid = lid;
- threadlist[threadlist_top].state = state;
- threadlist[threadlist_top].type = type;
- threadlist[threadlist_top].pending = 0;
- threadlist[threadlist_top].status = 0;
-
- return &threadlist[threadlist_top++];
-}
-
-static void
-empty_threadlist (void)
-{
- threadlist_top = 0;
-}
-
-static threadinfo *
-next_pending_event (void)
-{
- int i;
-
- for (i = 0; i < threadlist_top; i++)
- if (threadlist[i].pending)
- return &threadlist[i];
-
- return NULL;
-}
-
-static void
-threadlist_iter (int (*func) (), void *data, td_thr_state_e state,
- td_thr_type_e type)
-{
- int i;
-
- for (i = 0; i < threadlist_top; i++)
- if ((state == TD_THR_ANY_STATE || state == threadlist[i].state) &&
- (type == TD_THR_ANY_TYPE || type == threadlist[i].type))
- if ((*func) (&threadlist[i], data) != 0)
- break;
-
- return;
-}
-
-/*
- * Global state
- *
- * Here we keep state information all collected in one place.
- */
-
-/* This flag is set when we activate, so that we don't do it twice.
- Defined in linux-thread.c and used for inter-target syncronization. */
-extern int using_thread_db;
-
-/* The process id for which we've stopped.
- * This is only set when we actually stop all threads.
- * Otherwise it's zero.
- */
-static int event_pid;
-
-/*
- * The process id for a new thread to which we've just attached.
- * This process needs special handling at resume time.
- */
-static int attach_pid;
-
-
-/*
- * thread_db event handling:
- *
- * The mechanism for event notification via the thread_db API.
- * These events are implemented as breakpoints. The thread_db
- * library gives us an address where we can set a breakpoint.
- * When the breakpoint is hit, it represents an event of interest
- * such as:
- * Thread creation
- * Thread death
- * Thread reap
- */
-
-/* Location of the thread creation event breakpoint. The code at this
- location in the child process will be called by the pthread library
- whenever a new thread is created. By setting a special breakpoint
- at this location, GDB can detect when a new thread is created. We
- obtain this location via the td_ta_event_addr call. */
-
-static CORE_ADDR thread_creation_bkpt_address;
-
-/* Location of the thread death event breakpoint. The code at this
- location in the child process will be called by the pthread library
- whenever a thread is destroyed. By setting a special breakpoint at
- this location, GDB can detect when a new thread is created. We
- obtain this location via the td_ta_event_addr call. */
-
-static CORE_ADDR thread_death_bkpt_address;
-
-/* This function handles the global parts of enabling thread events.
- The thread-specific enabling is handled per-thread elsewhere. */
-
-static void
-enable_thread_event_reporting (td_thragent_t *ta)
-{
- td_thr_events_t events;
- td_notify_t notify;
- CORE_ADDR addr;
-
- if (p_td_ta_set_event == NULL ||
- p_td_ta_event_addr == NULL ||
- p_td_ta_event_getmsg == NULL ||
- p_td_thr_event_enable == NULL)
- return; /* can't do thread event reporting without these funcs */
-
- /* set process wide mask saying which events we are interested in */
- td_event_emptyset (&events);
- td_event_addset (&events, TD_CREATE);
- td_event_addset (&events, TD_DEATH);
-
- if (p_td_ta_set_event (ta, &events) != TD_OK)
- {
- warning ("unable to set global thread event mask");
- return;
- }
-
- /* Delete previous thread event breakpoints, if any. */
- remove_thread_event_breakpoints ();
-
- /* create breakpoints -- thread creation and death */
- /* thread creation */
- /* get breakpoint location */
- if (p_td_ta_event_addr (ta, TD_CREATE, ¬ify) != TD_OK)
- {
- warning ("unable to get location for thread creation breakpoint");
- return;
- }
-
- /* Set up the breakpoint. */
- create_thread_event_breakpoint ((CORE_ADDR) notify.u.bptaddr);
-
- /* Save it's location. */
- thread_creation_bkpt_address = (CORE_ADDR) notify.u.bptaddr;
-
- /* thread death */
- /* get breakpoint location */
- if (p_td_ta_event_addr (ta, TD_DEATH, ¬ify) != TD_OK)
- {
- warning ("unable to get location for thread death breakpoint");
- return;
- }
- /* Set up the breakpoint. */
- create_thread_event_breakpoint ((CORE_ADDR) notify.u.bptaddr);
-
- /* Save it's location. */
- thread_death_bkpt_address = (CORE_ADDR) notify.u.bptaddr;
-}
-
-/* This function handles the global parts of disabling thread events.
- The thread-specific enabling is handled per-thread elsewhere. */
-
-static void
-disable_thread_event_reporting (td_thragent_t *ta)
-{
- td_thr_events_t events;
-
- /* set process wide mask saying we aren't interested in any events */
- td_event_emptyset (&events);
- p_td_ta_set_event (main_threadagent, &events);
-
- /* Delete thread event breakpoints, if any. */
- remove_thread_event_breakpoints ();
- thread_creation_bkpt_address = 0;
- thread_death_bkpt_address = 0;
-}
-
-/* check_for_thread_event
-
- if it's a thread event we recognize (currently
- we only recognize creation and destruction
- events), return 1; else return 0. */
-
-
-static int
-check_for_thread_event (struct target_waitstatus *tws, int event_pid)
-{
- /* FIXME: to be more efficient, we should keep a static
- list of threads, and update it only here (with td_ta_thr_iter). */
- return 0;
-}
-
-static void
-thread_db_push_target (void)
-{
- /* Called ONLY from thread_db_new_objfile after td_ta_new call succeeds. */
-
- /* Push this target vector */
- push_target (&thread_db_ops);
- /* Find the underlying process-layer target for calling later. */
- target_beneath = find_target_beneath (&thread_db_ops);
- using_thread_db = 1;
- /* Turn on thread_db event-reporting API. */
- enable_thread_event_reporting (main_threadagent);
-}
-
-static void
-thread_db_unpush_target (void)
-{
- /* Must be called whenever we remove ourself from the target stack! */
-
- using_thread_db = 0;
- target_beneath = NULL;
-
- /* delete local list of threads */
- empty_threadlist ();
- /* Turn off the thread_db API. */
- p_td_ta_delete (main_threadagent);
- /* Unpush this target vector */
- unpush_target (&thread_db_ops);
- /* Reset linuxthreads module. */
- linuxthreads_discard_global_state ();
-}
-
-/*
- * New objfile hook function:
- * Called for each new objfile (image, shared lib) in the target process.
- *
- * The purpose of this function is to detect that the target process
- * is linked with the (appropriate) thread library. So every time a
- * new target shared library is detected, we will call td_ta_new.
- * If it succeeds, we know we have a multi-threaded target process
- * that we can debug using the thread_db API.
- */
-
-/*
- * new_objfile function:
- *
- * connected to target_new_objfile_hook, this function gets called
- * every time a new binary image is loaded.
- *
- * At each call, we attempt to open the thread_db connection to the
- * child process. If it succeeds, we know we have a libthread process
- * and we can debug it with this target vector. Therefore we push
- * ourself onto the target stack.
- */
-
-static void (*target_new_objfile_chain) (struct objfile *objfile);
-static int stop_or_attach_thread_callback (const td_thrhandle_t *th,
- void *data);
-static int wait_thread_callback (const td_thrhandle_t *th,
- void *data);
-
-static void
-thread_db_new_objfile (struct objfile *objfile)
-{
- td_err_e ret;
-
- if (using_thread_db) /* libthread already detected, and */
- goto quit; /* thread target vector activated. */
-
- if (objfile == NULL)
- goto quit; /* un-interesting object file */
-
- /* Initialize our "main prochandle" with the main inferior pid. */
- main_prochandle.pid = PIDGET (inferior_ptid);
-
- /* Now attempt to open a thread_db connection to the
- thread library running in the child process. */
- ret = p_td_ta_new (&main_prochandle, &main_threadagent);
- switch (ret) {
- default:
- warning ("Unexpected error initializing thread_db: %s",
- thr_err_string (ret));
- break;
- case TD_NOLIBTHREAD: /* expected: no libthread in child process (yet) */
- break;
- case TD_OK: /* libthread detected in child: we go live now! */
- thread_db_push_target ();
- event_pid = PIDGET (inferior_ptid); /* for resume */
-
- /* Now stop everyone else, and attach any new threads you find. */
- p_td_ta_thr_iter (main_threadagent,
- stop_or_attach_thread_callback,
- (void *) 0,
- TD_THR_ANY_STATE,
- TD_THR_LOWEST_PRIORITY,
- TD_SIGNO_MASK,
- TD_THR_ANY_USER_FLAGS);
-
- /* Now go call wait on all the threads you've stopped:
- This allows us to absorb the SIGKILL event, and to make sure
- that the thread knows that it is stopped (Linux peculiarity). */
- p_td_ta_thr_iter (main_threadagent,
- wait_thread_callback,
- (void *) 0,
- TD_THR_ANY_STATE,
- TD_THR_LOWEST_PRIORITY,
- TD_SIGNO_MASK,
- TD_THR_ANY_USER_FLAGS);
-
- break;
- }
-quit:
- if (target_new_objfile_chain)
- target_new_objfile_chain (objfile);
-}
-
-
-/*
-
- LOCAL FUNCTION
-
- thread_db_alive - test thread for "aliveness"
-
- SYNOPSIS
-
- static bool thread_db_alive (int pid);
-
- DESCRIPTION
-
- returns true if thread still active in inferior.
-
- */
-
-static int
-thread_db_alive (ptid_t ptid)
-{
- if (is_thread (ptid)) /* user-space (non-kernel) thread */
- {
- td_thrhandle_t th;
- td_err_e ret;
- int pid = GET_THREAD (ptid);
-
- if ((ret = p_td_ta_map_id2thr (main_threadagent, pid, &th)) != TD_OK)
- return 0; /* thread not found */
- if ((ret = p_td_thr_validate (&th)) != TD_OK)
- return 0; /* thread not valid */
- return 1; /* known thread: return true */
- }
- else if (target_beneath->to_thread_alive)
- return target_beneath->to_thread_alive (ptid);
- else
- return 0; /* default to "not alive" (shouldn't happen anyway) */
-}
-
-/*
- * get_lwp_from_thread_handle
- */
-
-static int /* lwpid_t or pid_t */
-get_lwp_from_thread_handle (td_thrhandle_t *th)
-{
- td_thrinfo_t ti;
- td_err_e ret;
-
- if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
- error ("get_lwp_from_thread_handle: thr_get_info failed: %s",
- thr_err_string (ret));
-
- return ti.ti_lid;
-}
-
-/*
- * get_lwp_from_thread_id
- */
-
-static int /* lwpid_t or pid_t */
-get_lwp_from_thread_id (int tid /* thread_t? */)
-{
- td_thrhandle_t th;
- td_err_e ret;
-
- if ((ret = p_td_ta_map_id2thr (main_threadagent, tid, &th)) != TD_OK)
- error ("get_lwp_from_thread_id: map_id2thr failed: %s",
- thr_err_string (ret));
-
- return get_lwp_from_thread_handle (&th);
-}
-
-/*
- * pid_to_str has to handle user-space threads.
- * If not a user-space thread, then pass the request on to the
- * underlying stratum if it can handle it: else call normal_pid_to_str.
- */
-
-static char *
-thread_db_pid_to_str (ptid_t ptid)
-{
- static char buf[100];
- td_thrhandle_t th;
- td_thrinfo_t ti;
- td_err_e ret;
-
- if (is_thread (ptid))
- {
- if ((ret = p_td_ta_map_id2thr (main_threadagent,
- GET_THREAD (ptid),
- &th)) != TD_OK)
- error ("thread_db: map_id2thr failed: %s", thr_err_string (ret));
-
- if ((ret = p_td_thr_get_info (&th, &ti)) != TD_OK)
- error ("thread_db: thr_get_info failed: %s", thr_err_string (ret));
-
- if (ti.ti_state == TD_THR_ACTIVE &&
- ti.ti_lid != 0)
- sprintf (buf, "Thread %ld (LWP %d)", ti.ti_tid, ti.ti_lid);
- else
- sprintf (buf, "Thread %ld (%s)", ti.ti_tid,
- thr_state_string (ti.ti_state));
- }
- else if (GET_LWP (ptid))
- sprintf (buf, "LWP %ld", GET_LWP (ptid));
- else return normal_pid_to_str (ptid);
-
- return buf;
-}
-
-/*
- * thread_db target vector functions:
- */
-
-static void
-thread_db_files_info (struct target_ops *tgt_vector)
-{
- /* This function will be unnecessary in real life. */
- printf_filtered ("thread_db stratum:\n");
- target_beneath->to_files_info (tgt_vector);
-}
-
-/*
- * xfer_memory has to munge the inferior_ptid before passing the call
- * down to the target layer.
- */
-
-static int
-thread_db_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite,
- struct mem_attrib *attrib,
- struct target_ops *target)
-{
- struct cleanup *old_chain;
- int ret;
-
- old_chain = save_inferior_ptid ();
-
- if (is_thread (inferior_ptid) ||
- !target_thread_alive (inferior_ptid))
- {
- /* FIXME: use the LID/LWP, so that underlying process layer
- can read memory from specific threads? */
- inferior_ptid = pid_to_ptid (main_prochandle.pid);
- }
-
- ret = target_beneath->to_xfer_memory (memaddr, myaddr, len,
- dowrite, attrib, target);
- do_cleanups (old_chain);
- return ret;
-}
-
-/*
- * fetch_registers has to determine if inferior_ptid is a user-space thread.
- * If so, we use the thread_db API to get the registers.
- * And if not, we call the underlying process stratum.
- */
-
-static void
-thread_db_fetch_registers (int regno)
-{
- td_thrhandle_t thandle;
- gdb_prfpregset_t fpregset;
- prgregset_t gregset;
- thread_t thread;
- td_err_e ret;
-
- if (!is_thread (inferior_ptid)) /* kernel thread */
- { /* pass the request on to the target underneath. */
- target_beneath->to_fetch_registers (regno);
- return;
- }
-
- /* convert inferior_ptid into a td_thrhandle_t */
-
- if ((thread = GET_THREAD (inferior_ptid)) == 0)
- error ("fetch_registers: thread == 0");
-
- if ((ret = p_td_ta_map_id2thr (main_threadagent, thread, &thandle)) != TD_OK)
- error ("fetch_registers: td_ta_map_id2thr: %s", thr_err_string (ret));
-
- /* Get the integer regs:
- For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7,
- pc and sp are saved (by a thread context switch). */
- if ((ret = p_td_thr_getgregs (&thandle, gregset)) != TD_OK &&
- ret != TD_PARTIALREG)
- error ("fetch_registers: td_thr_getgregs %s", thr_err_string (ret));
-
- /* And, now the fp regs */
- if ((ret = p_td_thr_getfpregs (&thandle, &fpregset)) != TD_OK &&
- ret != TD_NOFPREGS)
- error ("fetch_registers: td_thr_getfpregs %s", thr_err_string (ret));
-
-/* 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 (&fpregset);
-
-}
-
-/*
- * store_registers has to determine if inferior_ptid is a user-space thread.
- * If so, we use the thread_db API to get the registers.
- * And if not, we call the underlying process stratum.
- */
-
-static void
-thread_db_store_registers (int regno)
-{
- td_thrhandle_t thandle;
- gdb_prfpregset_t fpregset;
- prgregset_t gregset;
- thread_t thread;
- td_err_e ret;
-
- if (!is_thread (inferior_ptid)) /* Kernel thread: */
- { /* pass the request on to the underlying target vector. */
- target_beneath->to_store_registers (regno);
- return;
- }
-
- /* convert inferior_ptid into a td_thrhandle_t */
-
- if ((thread = GET_THREAD (inferior_ptid)) == 0)
- error ("store_registers: thread == 0");
-
- if ((ret = p_td_ta_map_id2thr (main_threadagent, thread, &thandle)) != TD_OK)
- error ("store_registers: td_ta_map_id2thr %s", thr_err_string (ret));
-
- if (regno != -1)
- { /* Not writing all the regs */
- /* save new register value */
- /* MVS: I don't understand this... */
- char old_value[REGISTER_SIZE];
-
- memcpy (old_value, ®isters[REGISTER_BYTE (regno)], REGISTER_SIZE);
-
- if ((ret = p_td_thr_getgregs (&thandle, gregset)) != TD_OK)
- error ("store_registers: td_thr_getgregs %s", thr_err_string (ret));
- if ((ret = p_td_thr_getfpregs (&thandle, &fpregset)) != TD_OK)
- error ("store_registers: td_thr_getfpregs %s", thr_err_string (ret));
-
- /* restore new register value */
- memcpy (®isters[REGISTER_BYTE (regno)], old_value, REGISTER_SIZE);
-
- }
-
- fill_gregset ((gdb_gregset_t *) gregset, regno);
- fill_fpregset (&fpregset, regno);
-
- if ((ret = p_td_thr_setgregs (&thandle, gregset)) != TD_OK)
- error ("store_registers: td_thr_setgregs %s", thr_err_string (ret));
- if ((ret = p_td_thr_setfpregs (&thandle, &fpregset)) != TD_OK &&
- ret != TD_NOFPREGS)
- error ("store_registers: td_thr_setfpregs %s", thr_err_string (ret));
-}
-
-static void
-handle_new_thread (int tid, /* user thread id */
- int lid, /* kernel thread id */
- int verbose)
-{
- ptid_t gdb_ptid = BUILD_THREAD (tid, main_prochandle.pid);
- int wait_pid, wait_status;
-
- if (verbose)
- printf_filtered ("[New %s]\n", target_pid_to_str (gdb_ptid));
- add_thread (gdb_ptid);
-
- if (lid != main_prochandle.pid)
- {
- attach_thread (lid);
- /* According to the Eric Paire model, we now have to send
- the restart signal to the new thread -- however, empirically,
- I do not find that to be necessary. */
- attach_pid = lid;
- }
-}
-
-static void
-test_for_new_thread (int tid, int lid, int verbose)
-{
- if (!in_thread_list (BUILD_THREAD (tid, main_prochandle.pid)))
- handle_new_thread (tid, lid, verbose);
-}
-
-/*
- * Callback function that gets called once per USER thread
- * (i.e., not kernel) thread by td_ta_thr_iter.
- */
-
-static int
-find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
-{
- td_thrinfo_t ti;
- td_err_e ret;
-
- if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
- {
- warning ("find_new_threads_callback: %s", thr_err_string (ret));
- return -1; /* bail out, get_info failed. */
- }
-
- /* FIXME:
- As things now stand, this should never detect a new thread.
- But if it does, we could be in trouble because we aren't calling
- wait_thread_callback for it. */
- test_for_new_thread (ti.ti_tid, ti.ti_lid, 0);
- return 0;
-}
-
-/*
- * find_new_threads uses the thread_db iterator function to discover
- * user-space threads. Then if the underlying process stratum has a
- * find_new_threads method, we call that too.
- */
-
-static void
-thread_db_find_new_threads (void)
-{
- if (PIDGET (inferior_ptid) == -1) /* FIXME: still necessary? */
- {
- printf_filtered ("No process.\n");
- return;
- }
- p_td_ta_thr_iter (main_threadagent,
- find_new_threads_callback,
- (void *) 0,
- TD_THR_ANY_STATE,
- TD_THR_LOWEST_PRIORITY,
- TD_SIGNO_MASK,
- TD_THR_ANY_USER_FLAGS);
- if (target_beneath->to_find_new_threads)
- target_beneath->to_find_new_threads ();
-}
-
-/*
- * Resume all threads, or resume a single thread.
- * If step is true, then single-step the appropriate thread
- * (or single-step inferior_ptid, but continue everyone else).
- * If signo is true, then send that signal to at least one thread.
- */
-
-/*
- * This function is called once for each thread before resuming.
- * It sends continue (no step, and no signal) to each thread except
- * the main thread, and
- * the event thread (the one that stopped at a breakpoint etc.)
- *
- * The event thread is handled separately so that it can be sent
- * the stepping and signal args with which target_resume was called.
- *
- * The main thread is resumed last, so that the thread_db proc_service
- * callbacks will still work during the iterator function.
- */
-
-static int
-resume_thread_callback (const td_thrhandle_t *th, void *data)
-{
- td_thrinfo_t ti;
- td_err_e ret;
-
- if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
- {
- warning ("resume_thread_callback: %s", thr_err_string (ret));
- return -1; /* bail out, get_info failed. */
- }
- /* FIXME:
- As things now stand, this should never detect a new thread.
- But if it does, we could be in trouble because we aren't calling
- wait_thread_callback for it. */
- test_for_new_thread (ti.ti_tid, ti.ti_lid, 1);
-
- if (ti.ti_lid != main_prochandle.pid &&
- ti.ti_lid != event_pid)
- {
- /* Unconditionally continue the thread with no signal.
- Only the event thread will get a signal of any kind. */
-
- target_beneath->to_resume (pid_to_ptid (ti.ti_lid), 0, 0);
- }
- return 0;
-}
-
-static int
-new_resume_thread_callback (threadinfo *thread, void *data)
-{
- if (thread->lid != event_pid &&
- thread->lid != main_prochandle.pid)
- {
- /* Unconditionally continue the thread with no signal (for now). */
-
- target_beneath->to_resume (pid_to_ptid (thread->lid), 0, 0);
- }
- return 0;
-}
-
-static int last_resume_pid;
-static int last_resume_step;
-static int last_resume_signo;
-
-static void
-thread_db_resume (ptid_t ptid, int step, enum target_signal signo)
-{
- last_resume_pid = PIDGET (ptid);
- last_resume_step = step;
- last_resume_signo = signo;
-
- /* resuming a specific pid? */
- if (PIDGET (ptid) != -1)
- {
- if (is_thread (ptid))
- ptid = pid_to_ptid (get_lwp_from_thread_id (GET_THREAD (ptid)));
- else if (GET_LWP (ptid))
- ptid = pid_to_ptid (GET_LWP (ptid));
- }
-
- /* Apparently the interpretation of 'pid' is dependent on 'step':
- If step is true, then a specific pid means 'step only this pid'.
- But if step is not true, then pid means 'continue ALL pids, but
- give the signal only to this one'. */
- if (PIDGET (ptid) != -1 && step)
- {
- /* FIXME: is this gonna work in all circumstances? */
- target_beneath->to_resume (ptid, step, signo);
- }
- else
- {
- /* 1) Continue all threads except the event thread and the main thread.
- 2) resume the event thread with step and signo.
- 3) If event thread != main thread, continue the main thread.
-
- Note: order of 2 and 3 may need to be reversed. */
-
- threadlist_iter (new_resume_thread_callback,
- (void *) 0,
- TD_THR_ANY_STATE,
- TD_THR_ANY_TYPE);
- /* now resume event thread, and if necessary also main thread. */
- if (event_pid)
- {
- target_beneath->to_resume (pid_to_ptid (event_pid), step, signo);
- }
- if (event_pid != main_prochandle.pid)
- {
- target_beneath->to_resume (pid_to_ptid (main_prochandle.pid), 0, 0);
- }
- }
-}
-
-/* All new threads will be attached.
- All previously known threads will be stopped using kill (SIGKILL). */
-
-static int
-stop_or_attach_thread_callback (const td_thrhandle_t *th, void *data)
-{
- td_thrinfo_t ti;
- td_err_e ret;
- ptid_t gdb_ptid;
- int on_off = 1;
-
- if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
- {
- warning ("stop_or_attach_thread_callback: %s", thr_err_string (ret));
- return -1; /* bail out, get_info failed. */
- }
-
- /* First add it to our internal list.
- We build this list anew at every wait event. */
- insert_thread (ti.ti_tid, ti.ti_lid, ti.ti_state, ti.ti_type);
- /* Now: if we've already seen it, stop it, else add it and attach it. */
- gdb_ptid = BUILD_THREAD (ti.ti_tid, main_prochandle.pid);
- if (!in_thread_list (gdb_ptid)) /* new thread */
- {
- handle_new_thread (ti.ti_tid, ti.ti_lid, 1);
- /* Enable thread events */
- if (p_td_thr_event_enable)
- if ((ret = p_td_thr_event_enable (th, on_off)) != TD_OK)
- warning ("stop_or_attach_thread: %s", thr_err_string (ret));
- }
- else if (ti.ti_lid != event_pid &&
- ti.ti_lid != main_prochandle.pid)
- {
- ret = (td_err_e) kill (ti.ti_lid, SIGSTOP);
- }
-
- return 0;
-}
-
-/*
- * Wait for signal N from pid PID.
- * If wait returns any other signals, put them back before returning.
- */
-
-static void
-wait_for_stop (int pid)
-{
- int i;
- int retpid;
- int status;
-
- /* Array of wait/signal status */
- /* FIXME: wrong data structure, we need a queue.
- Realtime signals may be delivered more than once.
- And at that, we really can't handle them (see below). */
-#if defined (NSIG)
- static int wstatus [NSIG];
-#elif defined (_NSIG)
- static int wstatus [_NSIG];
-#else
-#error No definition for number of signals!
-#endif
-
- /* clear wait/status list */
- memset (&wstatus, 0, sizeof (wstatus));
-
- /* Now look for SIGSTOP event on all threads except event thread. */
- do {
- errno = 0;
- if (pid == main_prochandle.pid)
- retpid = waitpid (pid, &status, 0);
- else
- retpid = waitpid (pid, &status, __WCLONE);
-
- if (retpid > 0)
- if (WSTOPSIG (status) == SIGSTOP)
- {
- /* Got the SIGSTOP event we're looking for.
- Throw it away, and throw any other events back! */
- for (i = 0; i < sizeof(wstatus) / sizeof (wstatus[0]); i++)
- if (wstatus[i])
- if (i != SIGSTOP)
- {
- kill (retpid, i);
- }
- break; /* all done */
- }
- else
- {
- int signo;
- /* Oops, got an event other than SIGSTOP.
- Save it, and throw it back after we find the SIGSTOP event. */
-
- /* FIXME (how?) This method is going to fail for realtime
- signals, which cannot be put back simply by using kill. */
-
- if (WIFEXITED (status))
- error ("Ack! Thread Exited event. What do I do now???");
- else if (WIFSTOPPED (status))
- signo = WSTOPSIG (status);
- else
- signo = WTERMSIG (status);
-
- /* If a thread other than the event thread has hit a GDB
- breakpoint (as opposed to some random trap signal), then
- just arrange for it to hit it again later. Back up the
- PC if necessary. Don't forward the SIGTRAP signal to
- the thread. We will handle the current event, eventually
- we will resume all the threads, and this one will get
- it's breakpoint trap again.
-
- If we do not do this, then we run the risk that the user
- will delete or disable the breakpoint, but the thread will
- have already tripped on it. */
-
- if (retpid != event_pid &&
- signo == SIGTRAP &&
- breakpoint_inserted_here_p (read_pc_pid (pid_to_ptid (retpid)) -
- DECR_PC_AFTER_BREAK))
- {
- /* Set the pc to before the trap and DO NOT re-send the signal */
- if (DECR_PC_AFTER_BREAK)
- write_pc_pid (read_pc_pid (pid_to_ptid (retpid))
- - DECR_PC_AFTER_BREAK,
- pid_to_ptid (retpid));
- }
-
- /* Since SIGINT gets forwarded to the entire process group
- (in the case where ^C is typed at the tty / console),
- just ignore all SIGINTs from other than the event thread. */
- else if (retpid != event_pid && signo == SIGINT)
- { /* do nothing. Signal will disappear into oblivion! */
- ;
- }
-
- else /* This is some random signal other than a breakpoint. */
- {
- wstatus [signo] = 1;
- }
- child_resume (pid_to_ptid (retpid), 0, TARGET_SIGNAL_0);
- continue;
- }
-
- } while (errno == 0 || errno == EINTR);
-}
-
-/*
- * wait_thread_callback
- *
- * Calls waitpid for each thread, repeatedly if necessary, until
- * SIGSTOP is returned. Afterward, if any other signals were returned
- * by waitpid, return them to the thread's pending queue by calling kill.
- */
-
-static int
-wait_thread_callback (const td_thrhandle_t *th, void *data)
-{
- td_thrinfo_t ti;
- td_err_e ret;
-
- if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
- {
- warning ("wait_thread_callback: %s", thr_err_string (ret));
- return -1; /* bail out, get_info failed. */
- }
-
- /* This callback to act on all threads except the event thread: */
- if (ti.ti_lid == event_pid || /* no need to wait (no sigstop) */
- ti.ti_lid == main_prochandle.pid) /* no need to wait (already waited) */
- return 0; /* don't wait on the event thread. */
-
- wait_for_stop (ti.ti_lid);
- return 0; /* finished: next thread. */
-}
-
-static int
-new_wait_thread_callback (threadinfo *thread, void *data)
-{
- /* don't wait on the event thread -- it's already stopped and waited.
- Ditto the main thread. */
- if (thread->lid != event_pid &&
- thread->lid != main_prochandle.pid)
- {
- wait_for_stop (thread->lid);
- }
- return 0;
-}
-
-/*
- * Wait for any thread to stop, by calling the underlying wait method.
- * The PID returned by the underlying target may be a kernel thread,
- * in which case we will want to convert it to the corresponding
- * user-space thread.
- */
-
-static ptid_t
-thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
-{
- td_thrhandle_t thandle;
- td_thrinfo_t ti;
- td_err_e ret;
- lwpid_t lwp;
- int retpid;
- ptid_t retptid;
- int status;
- int save_errno;
-
- /* OK, we're about to wait for an event from the running inferior.
- Make sure we're ignoring the right signals. */
-
- check_all_signal_numbers (); /* see if magic signals changed. */
-
- event_pid = 0;
- attach_pid = 0;
-
- /* FIXME: should I do the wait right here inline? */
-#if 0
- if (PIDGET (ptid) == -1)
- lwp = -1;
- else
- lwp = get_lwp_from_thread_id (GET_THREAD (ptid));
-#endif
-
-
- save_errno = linux_child_wait (-1, &retpid, &status);
- store_waitstatus (ourstatus, status);
-
- /* Thread ID is irrelevant if the target process exited.
- FIXME: do I have any killing to do?
- Can I get this event mistakenly from a thread? */
- if (ourstatus->kind == TARGET_WAITKIND_EXITED)
- return pid_to_ptid (retpid);
-
- /* OK, we got an event of interest.
- Go stop all threads and look for new ones.
- FIXME: maybe don't do this for the restart signal? Optimization... */
- event_pid = retpid;
-
- /* If the last call to resume was for a specific thread, then we don't
- need to stop everyone else: they should already be stopped. */
- if (last_resume_step == 0 || last_resume_pid == -1)
- {
- /* Main thread must be stopped before calling the iterator. */
- if (retpid != main_prochandle.pid)
- {
- kill (main_prochandle.pid, SIGSTOP);
- wait_for_stop (main_prochandle.pid);
- }
-
- empty_threadlist ();
- /* Now stop everyone else, and attach any new threads you find. */
- p_td_ta_thr_iter (main_threadagent,
- stop_or_attach_thread_callback,
- (void *) 0,
- TD_THR_ANY_STATE,
- TD_THR_LOWEST_PRIORITY,
- TD_SIGNO_MASK,
- TD_THR_ANY_USER_FLAGS);
-
- /* Now go call wait on all the threads we've stopped:
- This allows us to absorb the SIGKILL event, and to make sure
- that the thread knows that it is stopped (Linux peculiarity). */
-
- threadlist_iter (new_wait_thread_callback,
- (void *) 0,
- TD_THR_ANY_STATE,
- TD_THR_ANY_TYPE);
- }
-
- /* Convert the kernel thread id to the corresponding thread id. */
-
- /* If the process layer does not furnish an lwp,
- then perhaps the returned pid IS the lwp... */
-#if 0 /* Always true (if it'd compile...) */
- if ((lwp = GET_LWP (pid_to_ptid (retpid))) == 0)
-#endif
- lwp = retpid;
-
- if ((ret = p_td_ta_map_lwp2thr (main_threadagent, lwp, &thandle)) != TD_OK)
- return pid_to_ptid (retpid); /* LWP is not mapped onto a user-space thread. */
-
- if ((ret = p_td_thr_validate (&thandle)) != TD_OK)
- return pid_to_ptid (retpid); /* LWP is not mapped onto a valid thread. */
-
- if ((ret = p_td_thr_get_info (&thandle, &ti)) != TD_OK)
- {
- warning ("thread_db: thr_get_info failed ('%s')", thr_err_string (ret));
- return pid_to_ptid (retpid);
- }
-
- retptid = BUILD_THREAD (ti.ti_tid, main_prochandle.pid);
- /* If this is a new user thread, notify GDB about it. */
- if (!in_thread_list (retptid))
- {
- printf_filtered ("[New %s]\n", target_pid_to_str (retptid));
- add_thread (retptid);
- }
-
-#if 0
- /* Now detect if this is a thread creation/deletion event: */
- check_for_thread_event (ourstatus, retpid);
-#endif
- return retptid;
-}
-
-/*
- * kill has to call the underlying kill.
- * FIXME: I'm not sure if it's necessary to check inferior_ptid any more,
- * but we might need to fix inferior_ptid up if it's a user thread.
- */
-
-static int
-kill_thread_callback (const td_thrhandle_t *th, void *data)
-{
- td_thrinfo_t ti;
- td_err_e ret;
-
- /* Fixme:
- For Linux, threads may need to be waited. */
- if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
- {
- warning ("kill_thread_callback: %s", thr_err_string (ret));
- return -1; /* bail out, get_info failed. */
- }
-
- if (ti.ti_lid != main_prochandle.pid)
- {
- kill (ti.ti_lid, SIGKILL);
- }
- return 0;
-}
-
-
-static void thread_db_kill (void)
-{
- int rpid;
- int status;
-
- /* Fixme:
- For Linux, threads may need to be waited. */
- if (! ptid_equal (inferior_ptid, null_ptid))
- {
- /* Go kill the children first. Save the main thread for last. */
- p_td_ta_thr_iter (main_threadagent,
- kill_thread_callback,
- (void *) 0,
- TD_THR_ANY_STATE,
- TD_THR_LOWEST_PRIORITY,
- TD_SIGNO_MASK,
- TD_THR_ANY_USER_FLAGS);
-
- /* Turn off thread_db event-reporting API *before* killing the
- main thread, since this operation requires child memory access.
- Can't move this into thread_db_unpush target because then
- detach would not work. */
- disable_thread_event_reporting (main_threadagent);
-
- inferior_ptid = pid_to_ptid (main_prochandle.pid);
-
- /*
- * Since both procfs_kill and ptrace_kill call target_mourn,
- * it should be sufficient for me to call one of them.
- * That will result in my mourn being called, which will both
- * unpush me and call the underlying mourn.
- */
- target_beneath->to_kill ();
- }
-
- /* Wait for all threads. */
- /* FIXME: need a universal wait_for_signal func? */
- do
- {
- rpid = waitpid (-1, &status, __WCLONE | WNOHANG);
- }
- while (rpid > 0 || errno == EINTR);
-
- do
- {
- rpid = waitpid (-1, &status, WNOHANG);
- }
- while (rpid > 0 || errno == EINTR);
-}
-
-/*
- * Mourn has to remove us from the target stack,
- * and then call the underlying mourn.
- */
-
-static void thread_db_mourn_inferior (void)
-{
- thread_db_unpush_target ();
- target_mourn_inferior (); /* call the underlying mourn */
-}
-
-/*
- * Detach has to remove us from the target stack,
- * and then call the underlying detach.
- *
- * But first, it has to detach all the cloned threads!
- */
-
-static int
-detach_thread_callback (const td_thrhandle_t *th, void *data)
-{
- /* Called once per thread. */
- td_thrinfo_t ti;
- td_err_e ret;
-
- if ((ret = p_td_thr_get_info (th, &ti)) != TD_OK)
- {
- warning ("detach_thread_callback: %s", thr_err_string (ret));
- return -1; /* bail out, get_info failed. */
- }
-
- if (!in_thread_list (BUILD_THREAD (ti.ti_tid, main_prochandle.pid)))
- return 0; /* apparently we don't know this one. */
-
- /* Save main thread for last, or the iterator will fail! */
- if (ti.ti_lid != main_prochandle.pid)
- {
- struct cleanup *old_chain;
- int off = 0;
-
- /* Time to detach this thread.
- First disable thread_db event reporting for the thread. */
- if (p_td_thr_event_enable &&
- (ret = p_td_thr_event_enable (th, off)) != TD_OK)
- {
- warning ("detach_thread_callback: %s\n", thr_err_string (ret));
- return 0;
- }
-
- /* Now cancel any pending SIGTRAPS. FIXME! */
-
- /* Call underlying detach method. FIXME just detach it. */
- old_chain = save_inferior_ptid ();
- inferior_ptid = pid_to_ptid (ti.ti_lid);
- detach (TARGET_SIGNAL_0);
- do_cleanups (old_chain);
- }
- return 0;
-}
-
-static void
-thread_db_detach (char *args, int from_tty)
-{
- td_err_e ret;
-
- if ((ret = p_td_ta_thr_iter (main_threadagent,
- detach_thread_callback,
- (void *) 0,
- TD_THR_ANY_STATE,
- TD_THR_LOWEST_PRIORITY,
- TD_SIGNO_MASK,
- TD_THR_ANY_USER_FLAGS))
- != TD_OK)
- warning ("detach (thr_iter): %s", thr_err_string (ret));
-
- /* Turn off thread_db event-reporting API
- (before detaching the main thread) */
- disable_thread_event_reporting (main_threadagent);
-
- thread_db_unpush_target ();
-
- /* above call nullifies target_beneath, so don't use that! */
- inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
- target_detach (args, from_tty);
-}
-
-
-/*
- * We never want to actually create the inferior!
- *
- * If this is ever called, it means we were on the target stack
- * when the user said "run". But we don't want to be on the new
- * inferior's target stack until the thread_db / libthread
- * connection is ready to be made.
- *
- * So, what shall we do?
- * Unpush ourselves from the stack, and then invoke
- * find_default_create_inferior, which will invoke the
- * appropriate process_stratum target to do the create.
- */
-
-static void
-thread_db_create_inferior (char *exec_file, char *allargs, char **env)
-{
- thread_db_unpush_target ();
- find_default_create_inferior (exec_file, allargs, env);
-}
-
-/*
- * Thread_db target vector initializer.
- */
-
-void
-init_thread_db_ops (void)
-{
- thread_db_ops.to_shortname = "multi-thread";
- thread_db_ops.to_longname = "multi-threaded child process.";
- thread_db_ops.to_doc = "Threads and pthreads support.";
- thread_db_ops.to_files_info = thread_db_files_info;
- thread_db_ops.to_create_inferior = thread_db_create_inferior;
- thread_db_ops.to_detach = thread_db_detach;
- thread_db_ops.to_wait = thread_db_wait;
- thread_db_ops.to_resume = thread_db_resume;
- thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
- thread_db_ops.to_kill = thread_db_kill;
- thread_db_ops.to_xfer_memory = thread_db_xfer_memory;
- thread_db_ops.to_fetch_registers = thread_db_fetch_registers;
- thread_db_ops.to_store_registers = thread_db_store_registers;
- thread_db_ops.to_thread_alive = thread_db_alive;
- thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
- thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
- thread_db_ops.to_stratum = thread_stratum;
- thread_db_ops.to_has_thread_control = tc_schedlock;
- thread_db_ops.to_magic = OPS_MAGIC;
-}
-#endif /* HAVE_STDINT_H */
-
-/*
- * Module constructor / initializer function.
- * If connection to thread_db dynamic library is successful,
- * then initialize this module's target vectors and the
- * new_objfile hook.
- */
-
-
-void
-_initialize_thread_db (void)
-{
-#ifdef HAVE_STDINT_H /* stub out entire module, leave initializer empty */
- if (init_thread_db_library ())
- {
- init_thread_db_ops ();
- add_target (&thread_db_ops);
- /*
- * Hook up to the new_objfile event.
- * If someone is already there, arrange for him to be called
- * after we are.
- */
- target_new_objfile_chain = target_new_objfile_hook;
- target_new_objfile_hook = thread_db_new_objfile;
- }
-#endif /* HAVE_STDINT_H */
-}
-
projects / deliverable / binutils-gdb.git / commitdiff
