aboutsummaryrefslogtreecommitdiff
path: root/gdb/infttrace.c
diff options
context:
space:
mode:
Diffstat (limited to 'gdb/infttrace.c')
-rw-r--r--gdb/infttrace.c5711
1 files changed, 0 insertions, 5711 deletions
diff --git a/gdb/infttrace.c b/gdb/infttrace.c
deleted file mode 100644
index 04d9a5c..0000000
--- a/gdb/infttrace.c
+++ /dev/null
@@ -1,5711 +0,0 @@
-/* Low level Unix child interface to ttrace, for GDB when running under HP-UX.
- Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
- 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. */
-
-#include "defs.h"
-#include "frame.h"
-#include "inferior.h"
-#include "target.h"
-#include "gdb_string.h"
-#include "wait.h"
-#include "command.h"
-
-/* Some hackery to work around a use of the #define name NO_FLAGS
- * in both gdb and HPUX (bfd.h and /usr/include/machine/vmparam.h).
- */
-#ifdef NO_FLAGS
-#define INFTTRACE_TEMP_HACK NO_FLAGS
-#undef NO_FLAGS
-#endif
-
-#ifdef USG
-#include <sys/types.h>
-#endif
-
-#include <sys/param.h>
-#include <sys/dir.h>
-#include <signal.h>
-#include <sys/ioctl.h>
-
-#include <sys/ttrace.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <sys/mman.h>
-
-#ifndef NO_PTRACE_H
-#ifdef PTRACE_IN_WRONG_PLACE
-#include <ptrace.h>
-#else
-#include <sys/ptrace.h>
-#endif
-#endif /* NO_PTRACE_H */
-
-/* Second half of the hackery above. Non-ANSI C, so
- * we can't use "#error", alas.
- */
-#ifdef NO_FLAGS
-#if (NO_FLAGS != INFTTRACE_TEMP_HACK )
- /* #error "Hackery to remove warning didn't work right" */
-#else
- /* Ok, new def'n of NO_FLAGS is same as old one; no action needed. */
-#endif
-#else
- /* #error "Didn't get expected re-definition of NO_FLAGS" */
-#define NO_FLAGS INFTTRACE_TEMP_HACK
-#endif
-
-#if !defined (PT_SETTRC)
-#define PT_SETTRC 0 /* Make process traceable by parent */
-#endif
-#if !defined (PT_READ_I)
-#define PT_READ_I 1 /* Read word from text space */
-#endif
-#if !defined (PT_READ_D)
-#define PT_READ_D 2 /* Read word from data space */
-#endif
-#if !defined (PT_READ_U)
-#define PT_READ_U 3 /* Read word from kernel user struct */
-#endif
-#if !defined (PT_WRITE_I)
-#define PT_WRITE_I 4 /* Write word to text space */
-#endif
-#if !defined (PT_WRITE_D)
-#define PT_WRITE_D 5 /* Write word to data space */
-#endif
-#if !defined (PT_WRITE_U)
-#define PT_WRITE_U 6 /* Write word to kernel user struct */
-#endif
-#if !defined (PT_CONTINUE)
-#define PT_CONTINUE 7 /* Continue after signal */
-#endif
-#if !defined (PT_STEP)
-#define PT_STEP 9 /* Set flag for single stepping */
-#endif
-#if !defined (PT_KILL)
-#define PT_KILL 8 /* Send child a SIGKILL signal */
-#endif
-
-#ifndef PT_ATTACH
-#define PT_ATTACH PTRACE_ATTACH
-#endif
-#ifndef PT_DETACH
-#define PT_DETACH PTRACE_DETACH
-#endif
-
-#include "gdbcore.h"
-#ifndef NO_SYS_FILE
-#include <sys/file.h>
-#endif
-
-/* This semaphore is used to coordinate the child and parent processes
- after a fork(), and before an exec() by the child. See parent_attach_all
- for details.
- */
-typedef struct {
- int parent_channel[2]; /* Parent "talks" to [1], child "listens" to [0] */
- int child_channel[2]; /* Child "talks" to [1], parent "listens" to [0] */
-} startup_semaphore_t;
-
-#define SEM_TALK (1)
-#define SEM_LISTEN (0)
-
-static startup_semaphore_t startup_semaphore;
-
-/* See can_touch_threads_of_process for details. */
-static int vforking_child_pid = 0;
-static int vfork_in_flight = 0;
-
-/* To support PREPARE_TO_PROCEED (hppa_prepare_to_proceed).
- */
-static pid_t old_gdb_pid = 0;
-static pid_t reported_pid = 0;
-static int reported_bpt = 0;
-
-/* 1 if ok as results of a ttrace or ttrace_wait call, 0 otherwise.
- */
-#define TT_OK( _status, _errno ) \
- (((_status) == 1) && ((_errno) == 0))
-
-#define TTRACE_ARG_TYPE uint64_t
-
-/* When supplied as the "addr" operand, ttrace interprets this
- to mean, "from the current address".
- */
-#define TT_USE_CURRENT_PC ((TTRACE_ARG_TYPE) TT_NOPC)
-
-/* When supplied as the "addr", "data" or "addr2" operand for most
- requests, ttrace interprets this to mean, "pay no heed to this
- argument".
- */
-#define TT_NIL ((TTRACE_ARG_TYPE) TT_NULLARG)
-
-/* This is capable of holding the value of a 32-bit register. The
- value is always left-aligned in the buffer; i.e., [0] contains
- the most-significant byte of the register's value, and [sizeof(reg)]
- contains the least-significant value.
-
- ??rehrauer: Yes, this assumes that an int is 32-bits on HP-UX, and
- that registers are 32-bits on HP-UX. The latter assumption changes
- with PA2.0.
- */
-typedef int register_value_t;
-
-/********************************************************************
-
- How this works:
-
- 1. Thread numbers
-
- The rest of GDB sees threads as being things with different
- "pid" (process id) values. See "thread.c" for details. The
- separate threads will be seen and reacted to if infttrace passes
- back different pid values (for _events_). See wait_for_inferior
- in inftarg.c.
-
- So infttrace is going to use thread ids externally, pretending
- they are process ids, and keep track internally so that it can
- use the real process id (and thread id) when calling ttrace.
-
- The data structure that supports this is a linked list of the
- current threads. Since at some date infttrace will have to
- deal with multiple processes, each list element records its
- corresponding pid, rather than having a single global.
-
- Note that the list is only approximately current; that's ok, as
- it's up to date when we need it (we hope!). Also, it can contain
- dead threads, as there's no harm if it does.
-
- The approach taken here is to bury the translation from external
- to internal inside "call_ttrace" and a few other places.
-
- There are some wrinkles:
-
- o When GDB forks itself to create the debug target process,
- there's only a pid of 0 around in the child, so the
- TT_PROC_SETTRC operation uses a more direct call to ttrace;
- Similiarly, the initial setting of the event mask happens
- early as well, and so is also special-cased, and an attach
- uses a real pid;
-
- o We define an unthreaded application as having a "pseudo"
- thread;
-
- o To keep from confusing the rest of GDB, we don't switch
- the PID for the pseudo thread to a TID. A table will help:
-
- Rest of GDB sees these PIDs: pid tid1 tid2 tid3 ...
-
- Our thread list stores: pid pid pid pid ...
- tid0 tid1 tid2 tid3
-
- Ttrace sees these TIDS: tid0 tid1 tid2 tid3 ...
-
- Both pid and tid0 will map to tid0, as there are infttrace.c-internal
- calls to ttrace using tid0.
-
- 2. Step and Continue
-
- Since we're implementing the "stop the world" model, sub-model
- "other threads run during step", we have some stuff to do:
-
- o User steps require continuing all threads other than the
- one the user is stepping;
-
- o Internal debugger steps (such as over a breakpoint or watchpoint,
- but not out of a library load thunk) require stepping only
- the selected thread; this means that we have to report the
- step finish on that thread, which can lead to complications;
-
- o When a thread is created, it is created running, rather
- than stopped--so we have to stop it.
-
- The OS doesn't guarantee the stopped thread list will be stable,
- no does it guarantee where on the stopped thread list a thread
- that is single-stepped will wind up: it's possible that it will
- be off the list for a while, it's possible the step will complete
- and it will be re-posted to the end...
-
- This means we have to scan the stopped thread list, build up
- a work-list, and then run down the work list; we can't do the
- step/continue during the scan.
-
- 3. Buffering events
-
- Then there's the issue of waiting for an event. We do this by
- noticing how many events are reported at the end of each wait.
- From then on, we "fake" all resumes and steps, returning instantly,
- and don't do another wait. Once all pending events are reported,
- we can really resume again.
-
- To keep this hidden, all the routines which know about tids and
- pids or real events and simulated ones are static (file-local).
-
- This code can make lots of calls to ttrace, in particular it
- can spin down the list of thread states more than once. If this
- becomes a performance hit, the spin could be done once and the
- various "tsp" blocks saved, keeping all later spins in this
- process.
-
- The O/S doesn't promise to keep the list straight, and so we must
- re-scan a lot. By observation, it looks like a single-step/wait
- puts the stepped thread at the end of the list but doesn't change
- it otherwise.
-
-****************************************************************
-*/
-
-/* Uncomment these to turn on various debugging output */
-/* #define THREAD_DEBUG */
-/* #define WAIT_BUFFER_DEBUG */
-/* #define PARANOIA */
-
-
-#define INFTTRACE_ALL_THREADS (-1)
-#define INFTTRACE_STEP (1)
-#define INFTTRACE_CONTINUE (0)
-
-/* FIX: this is used in inftarg.c/child_wait, in a hack.
- */
-extern int not_same_real_pid;
-
-/* This is used to count buffered events.
- */
-static unsigned int more_events_left = 0;
-
-/* Process state.
- */
-typedef enum process_state_enum {
- STOPPED,
- FAKE_STEPPING,
- FAKE_CONTINUE, /* For later use */
- RUNNING,
- FORKING,
- VFORKING
-} process_state_t;
-
-static process_state_t process_state = STOPPED;
-
-/* User-specified stepping modality.
- */
-typedef enum stepping_mode_enum {
- DO_DEFAULT, /* ...which is a continue! */
- DO_STEP,
- DO_CONTINUE
-} stepping_mode_t;
-
-/* Action to take on an attach, depends on
- * what kind (user command, fork, vfork).
- *
- * At the moment, this is either:
- *
- * o continue with a SIGTRAP signal, or
- *
- * o leave stopped.
- */
-typedef enum attach_continue_enum {
- DO_ATTACH_CONTINUE,
- DONT_ATTACH_CONTINUE
-} attach_continue_t;
-
-/* This flag is true if we are doing a step-over-bpt
- * with buffered events. We will have to be sure to
- * report the right thread, as otherwise the spaghetti
- * code in "infrun.c/wait_for_inferior" will get
- * confused.
- */
-static int doing_fake_step = 0;
-static lwpid_t fake_step_tid = 0;
-
-
-/****************************************************
- * Thread information structure routines and types. *
- ****************************************************
- */
-typedef
-struct thread_info_struct
-{
- int am_pseudo; /* This is a pseudo-thread for the process. */
- int pid; /* Process ID */
- lwpid_t tid; /* Thread ID */
- int handled; /* 1 if a buffered event was handled. */
- int seen; /* 1 if this thread was seen on a traverse. */
- int terminated; /* 1 if thread has terminated. */
- int have_signal; /* 1 if signal to be sent */
- enum target_signal signal_value; /* Signal to send */
- int have_start; /* 1 if alternate starting address */
- stepping_mode_t stepping_mode; /* Whether to step or continue */
- CORE_ADDR start; /* Where to start */
- int have_state; /* 1 if the event state has been set */
- ttstate_t last_stop_state;/* The most recently-waited event for this thread. */
- struct thread_info_struct
- *next; /* All threads are linked via this field. */
- struct thread_info_struct
- *next_pseudo; /* All pseudo-threads are linked via this field. */
-} thread_info;
-
-typedef
-struct thread_info_header_struct
-{
- int count;
- thread_info *head;
- thread_info *head_pseudo;
-
-} thread_info_header;
-
-static thread_info_header thread_head = { 0, NULL, NULL };
-static thread_info_header deleted_threads = { 0, NULL, NULL };
-
-static saved_real_pid = 0;
-
-
-/*************************************************
- * Debugging support functions *
- *************************************************
- */
-CORE_ADDR
-get_raw_pc( ttid )
- lwpid_t ttid;
-{
- unsigned long pc_val;
- int offset;
- int res;
-
- offset = register_addr( PC_REGNUM, U_REGS_OFFSET );
- res = read_from_register_save_state(
- ttid,
- (TTRACE_ARG_TYPE) offset,
- (char *) &pc_val,
- sizeof( pc_val ));
- if( res <= 0 ) {
- return (CORE_ADDR) pc_val;
- }
- else {
- return (CORE_ADDR) 0;
- }
-}
-
-static char *
-get_printable_name_of_stepping_mode( mode )
- stepping_mode_t mode;
-{
- switch( mode ) {
- case DO_DEFAULT: return "DO_DEFAULT";
- case DO_STEP: return "DO_STEP";
- case DO_CONTINUE: return "DO_CONTINUE";
- default: return "?unknown mode?";
- }
-}
-
-/* This function returns a pointer to a string describing the
- * ttrace event being reported.
- */
-char *
-get_printable_name_of_ttrace_event (event)
- ttevents_t event;
-{
- /* This enumeration is "gappy", so don't use a table. */
- switch (event) {
-
- case TTEVT_NONE:
- return "TTEVT_NONE";
- case TTEVT_SIGNAL:
- return "TTEVT_SIGNAL";
- case TTEVT_FORK:
- return "TTEVT_FORK";
- case TTEVT_EXEC:
- return "TTEVT_EXEC";
- case TTEVT_EXIT:
- return "TTEVT_EXIT";
- case TTEVT_VFORK:
- return "TTEVT_VFORK";
- case TTEVT_SYSCALL_RETURN:
- return "TTEVT_SYSCALL_RETURN";
- case TTEVT_LWP_CREATE:
- return "TTEVT_LWP_CREATE";
- case TTEVT_LWP_TERMINATE:
- return "TTEVT_LWP_TERMINATE";
- case TTEVT_LWP_EXIT:
- return "TTEVT_LWP_EXIT";
- case TTEVT_LWP_ABORT_SYSCALL:
- return "TTEVT_LWP_ABORT_SYSCALL";
- case TTEVT_SYSCALL_ENTRY:
- return "TTEVT_SYSCALL_ENTRY";
- case TTEVT_SYSCALL_RESTART:
- return "TTEVT_SYSCALL_RESTART";
- default :
- return "?new event?";
- }
-}
-
-
-/* This function translates the ttrace request enumeration into
- * a character string that is its printable (aka "human readable")
- * name.
- */
-char *
-get_printable_name_of_ttrace_request (request)
- ttreq_t request;
-{
- if (!IS_TTRACE_REQ (request))
- return "?bad req?";
-
- /* This enumeration is "gappy", so don't use a table. */
- switch (request) {
- case TT_PROC_SETTRC :
- return "TT_PROC_SETTRC";
- case TT_PROC_ATTACH :
- return "TT_PROC_ATTACH";
- case TT_PROC_DETACH :
- return "TT_PROC_DETACH";
- case TT_PROC_RDTEXT :
- return "TT_PROC_RDTEXT";
- case TT_PROC_WRTEXT :
- return "TT_PROC_WRTEXT";
- case TT_PROC_RDDATA :
- return "TT_PROC_RDDATA";
- case TT_PROC_WRDATA :
- return "TT_PROC_WRDATA";
- case TT_PROC_STOP :
- return "TT_PROC_STOP";
- case TT_PROC_CONTINUE :
- return "TT_PROC_CONTINUE";
- case TT_PROC_GET_PATHNAME :
- return "TT_PROC_GET_PATHNAME";
- case TT_PROC_GET_EVENT_MASK :
- return "TT_PROC_GET_EVENT_MASK";
- case TT_PROC_SET_EVENT_MASK :
- return "TT_PROC_SET_EVENT_MASK";
- case TT_PROC_GET_FIRST_LWP_STATE :
- return "TT_PROC_GET_FIRST_LWP_STATE";
- case TT_PROC_GET_NEXT_LWP_STATE :
- return "TT_PROC_GET_NEXT_LWP_STATE";
- case TT_PROC_EXIT :
- return "TT_PROC_EXIT";
- case TT_PROC_GET_MPROTECT :
- return "TT_PROC_GET_MPROTECT";
- case TT_PROC_SET_MPROTECT :
- return "TT_PROC_SET_MPROTECT";
- case TT_PROC_SET_SCBM :
- return "TT_PROC_SET_SCBM";
- case TT_LWP_STOP :
- return "TT_LWP_STOP";
- case TT_LWP_CONTINUE :
- return "TT_LWP_CONTINUE";
- case TT_LWP_SINGLE :
- return "TT_LWP_SINGLE";
- case TT_LWP_RUREGS :
- return "TT_LWP_RUREGS";
- case TT_LWP_WUREGS :
- return "TT_LWP_WUREGS";
- case TT_LWP_GET_EVENT_MASK :
- return "TT_LWP_GET_EVENT_MASK";
- case TT_LWP_SET_EVENT_MASK :
- return "TT_LWP_SET_EVENT_MASK";
- case TT_LWP_GET_STATE :
- return "TT_LWP_GET_STATE";
- default :
- return "?new req?";
- }
-}
-
-
-/* This function translates the process state enumeration into
- * a character string that is its printable (aka "human readable")
- * name.
- */
-static char *
-get_printable_name_of_process_state (process_state)
- process_state_t process_state;
-{
- switch (process_state) {
- case STOPPED:
- return "STOPPED";
- case FAKE_STEPPING:
- return "FAKE_STEPPING";
- case RUNNING:
- return "RUNNING";
- case FORKING:
- return "FORKING";
- case VFORKING:
- return "VFORKING";
- default:
- return "?some unknown state?";
- }
-}
-
-/* Set a ttrace thread state to a safe, initial state.
- */
-static void
-clear_ttstate_t (tts)
- ttstate_t * tts;
-{
- tts->tts_pid = 0;
- tts->tts_lwpid = 0;
- tts->tts_user_tid = 0;
- tts->tts_event = TTEVT_NONE;
-}
-
-/* Copy ttrace thread state TTS_FROM into TTS_TO.
- */
-static void
-copy_ttstate_t (tts_to, tts_from)
- ttstate_t * tts_to;
- ttstate_t * tts_from;
-{
- memcpy ((char *) tts_to, (char *) tts_from, sizeof (*tts_to));
-}
-
-/* Are there any live threads we know about?
- */
-static int
-any_thread_records()
-{
- return( thread_head.count > 0 );
-}
-
-/* Create, fill in and link in a thread descriptor.
- */
-static thread_info *
-create_thread_info (pid, tid)
- int pid;
- lwpid_t tid;
-{
- thread_info * new_p;
- thread_info * p;
- int thread_count_of_pid;
-
- new_p = malloc( sizeof( thread_info ));
- new_p->pid = pid;
- new_p->tid = tid;
- new_p->have_signal = 0;
- new_p->have_start = 0;
- new_p->have_state = 0;
- clear_ttstate_t( &new_p->last_stop_state );
- new_p->am_pseudo = 0;
- new_p->handled = 0;
- new_p->seen = 0;
- new_p->terminated = 0;
- new_p->next = NULL;
- new_p->next_pseudo = NULL;
- new_p->stepping_mode = DO_DEFAULT;
-
- if( 0 == thread_head.count ) {
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "First thread, pid %d tid %d!\n", pid, tid );
-#endif
- saved_real_pid = inferior_pid;
- }
- else {
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Subsequent thread, pid %d tid %d\n", pid, tid );
-#endif
- }
-
- /* Another day, another thread...
- */
- thread_head.count++;
-
- /* The new thread always goes at the head of the list.
- */
- new_p->next = thread_head.head;
- thread_head.head = new_p;
-
- /* Is this the "pseudo" thread of a process? It is if there's
- * no other thread for this process on the list. (Note that this
- * accomodates multiple processes, such as we see even for simple
- * cases like forking "non-threaded" programs.)
- */
- p = thread_head.head;
- thread_count_of_pid = 0;
- while (p)
- {
- if (p->pid == new_p->pid)
- thread_count_of_pid++;
- p = p->next;
- }
-
- /* Did we see any other threads for this pid? (Recall that we just
- * added this thread to the list...)
- */
- if (thread_count_of_pid == 1)
- {
- new_p->am_pseudo = 1;
- new_p->next_pseudo = thread_head.head_pseudo;
- thread_head.head_pseudo = new_p;
- }
-
- return new_p;
-}
-
-/* Get rid of our thread info.
- */
-static void
-clear_thread_info ()
-{
- thread_info *p;
- thread_info *q;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Clearing all thread info\n" );
-#endif
-
- p = thread_head.head;
- while( p ) {
- q = p;
- p = p->next;
- free( q );
- }
-
- thread_head.head = NULL;
- thread_head.head_pseudo = NULL;
- thread_head.count = 0;
-
- p = deleted_threads.head;
- while( p ) {
- q = p;
- p = p->next;
- free( q );
- }
-
- deleted_threads.head = NULL;
- deleted_threads.head_pseudo = NULL;
- deleted_threads.count = 0;
-
- /* No threads, so can't have pending events.
- */
- more_events_left = 0;
-}
-
-/* Given a tid, find the thread block for it.
- */
-static thread_info *
-find_thread_info (tid)
- lwpid_t tid;
-{
- thread_info *p;
-
- for( p = thread_head.head; p; p = p->next ) {
- if( p->tid == tid ) {
- return p;
- }
- }
-
- for( p = deleted_threads.head; p; p = p->next ) {
- if( p->tid == tid ) {
- return p;
- }
- }
-
- return NULL;
-}
-
-/* For any but the pseudo thread, this maps to the
- * thread ID. For the pseudo thread, if you pass either
- * the thread id or the PID, you get the pseudo thread ID.
- *
- * We have to be prepared for core gdb to ask about
- * deleted threads. We do the map, but we don't like it.
- */
-static lwpid_t
-map_from_gdb_tid( gdb_tid )
- lwpid_t gdb_tid;
-{
- thread_info *p;
-
- /* First assume gdb_tid really is a tid, and try to find a
- * matching entry on the threads list.
- */
- for( p = thread_head.head; p; p = p->next ) {
- if( p->tid == gdb_tid )
- return gdb_tid;
- }
-
- /* It doesn't appear to be a tid; perhaps it's really a pid?
- * Try to find a "pseudo" thread entry on the threads list.
- */
- for (p = thread_head.head_pseudo; p != NULL; p = p->next_pseudo)
- {
- if (p->pid == gdb_tid)
- return p->tid;
- }
-
- /* Perhaps it's the tid of a deleted thread we may still
- * have some knowledge of?
- */
- for( p = deleted_threads.head; p; p = p-> next ) {
- if( p->tid == gdb_tid )
- return gdb_tid;
- }
-
- /* Or perhaps it's the pid of a deleted process we may still
- * have knowledge of?
- */
- for (p = deleted_threads.head_pseudo; p != NULL; p = p->next_pseudo)
- {
- if (p->pid == gdb_tid)
- return p->tid;
- }
-
- return 0; /* Error? */
-}
-
-/* Map the other way: from a real tid to the
- * "pid" known by core gdb. This tid may be
- * for a thread that just got deleted, so we
- * also need to consider deleted threads.
- */
-static lwpid_t
-map_to_gdb_tid( real_tid )
- lwpid_t real_tid;
-{
- thread_info *p;
-
- for( p = thread_head.head; p; p = p->next ) {
- if( p->tid == real_tid ) {
- if( p->am_pseudo )
- return p->pid;
- else
- return real_tid;
- }
- }
-
- for( p = deleted_threads.head; p; p = p-> next ) {
- if( p->tid == real_tid )
- if( p->am_pseudo )
- return p->pid; /* Error? */
- else
- return real_tid;
- }
-
- return 0; /* Error? Never heard of this thread! */
-}
-
-/* Do any threads have saved signals?
- */
-static int
-saved_signals_exist ()
-{
- thread_info *p;
-
- for( p = thread_head.head; p; p = p->next ) {
- if( p->have_signal ) {
- return 1;
- }
- }
-
- return 0;
-}
-
-/* Is this the tid for the zero-th thread?
- */
-static int
-is_pseudo_thread (tid)
- lwpid_t tid;
-{
- thread_info *p = find_thread_info( tid );
- if( NULL == p || p->terminated )
- return 0;
- else
- return p->am_pseudo;
-}
-
-/* Is this thread terminated?
- */
-static int
-is_terminated (tid)
- lwpid_t tid;
-{
- thread_info *p = find_thread_info( tid );
-
- if( NULL != p )
- return p->terminated;
-
- return 0;
-}
-
-/* Is this pid a real PID or a TID?
- */
-static int
-is_process_id (pid)
- int pid;
-{
- lwpid_t tid;
- thread_info * tinfo;
- pid_t this_pid;
- int this_pid_count;
-
- /* What does PID really represent?
- */
- tid = map_from_gdb_tid (pid);
- if (tid <= 0)
- return 0; /* Actually, is probably an error... */
-
- tinfo = find_thread_info (tid);
-
- /* Does it appear to be a true thread?
- */
- if (! tinfo->am_pseudo)
- return 0;
-
- /* Else, it looks like it may be a process. See if there's any other
- * threads with the same process ID, though. If there are, then TID
- * just happens to be the first thread of several for this process.
- */
- this_pid = tinfo->pid;
- this_pid_count = 0;
- for (tinfo = thread_head.head; tinfo; tinfo = tinfo->next)
- {
- if (tinfo->pid == this_pid)
- this_pid_count++;
- }
-
- return (this_pid_count == 1);
-}
-
-
-/* Add a thread to our info. Prevent duplicate entries.
- */
-static thread_info *
-add_tthread (pid, tid)
- int pid;
- lwpid_t tid;
-{
- thread_info *p;
-
- p = find_thread_info( tid );
- if( NULL == p )
- p = create_thread_info( pid, tid );
-
- return p;
-}
-
-/* Notice that a thread was deleted.
- */
-static void
-del_tthread (tid)
- lwpid_t tid;
-{
- thread_info *p;
- thread_info *chase;
-
- if( thread_head.count <= 0 ) {
- error( "Internal error in thread database." );
- return;
- }
-
- chase = NULL;
- for( p = thread_head.head; p; p = p->next ) {
- if( p->tid == tid ) {
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Delete here: %d \n", tid );
-#endif
-
- if( p->am_pseudo ) {
- /*
- * Deleting a main thread is ok if we're doing
- * a parent-follow on a child; this is odd but
- * not wrong. It apparently _doesn't_ happen
- * on the child-follow, as we don't just delete
- * the pseudo while keeping the rest of the
- * threads around--instead, we clear out the whole
- * thread list at once.
- */
- thread_info *q;
- thread_info *q_chase;
-
- q_chase = NULL;
- for( q = thread_head.head_pseudo; q; q = q -> next ) {
- if( q == p ) {
- /* Remove from pseudo list.
- */
- if( q_chase == NULL )
- thread_head.head_pseudo = p->next_pseudo;
- else
- q_chase-> next = p->next_pseudo;
- }
- else
- q_chase = q;
- }
- }
-
- /* Remove from live list.
- */
- thread_head.count--;
-
- if( NULL == chase )
- thread_head.head = p->next;
- else
- chase->next = p->next;
-
- /* Add to deleted thread list.
- */
- p->next = deleted_threads.head;
- deleted_threads.head = p;
- deleted_threads.count++;
- if( p->am_pseudo ) {
- p->next_pseudo = deleted_threads.head_pseudo;
- deleted_threads.head_pseudo = p;
- }
- p->terminated = 1;
-
- return;
- }
-
- else
- chase = p;
- }
-}
-
-/* Get the pid for this tid. (Has to be a real TID!).
- */
-static int
-get_pid_for (tid)
- lwpid_t tid;
-{
- thread_info *p;
-
- for( p = thread_head.head; p; p = p->next ) {
- if( p->tid == tid ) {
- return p->pid;
- }
- }
-
- for( p = deleted_threads.head; p; p = p->next ) {
- if( p->tid == tid ) {
- return p->pid;
- }
- }
-
- return 0;
-}
-
-/* Note that this thread's current event has been handled.
- */
-static void
-set_handled( pid, tid )
- int pid;
- lwpid_t tid;
-{
- thread_info *p;
-
- p = find_thread_info( tid );
- if( NULL == p )
- p = add_tthread( pid, tid );
-
- p->handled = 1;
-}
-
-/* Was this thread's current event handled?
- */
-static int
-was_handled( tid )
- lwpid_t tid;
-{
- thread_info *p;
-
- p = find_thread_info( tid );
- if( NULL != p )
- return p->handled;
-
- return 0; /* New threads have not been handled */
-}
-
-/* Set this thread to unhandled.
- */
-static void
-clear_handled( tid )
- lwpid_t tid;
-{
- thread_info * p;
-
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "clear_handled %d\n", (int) tid );
-#endif
-
- p = find_thread_info (tid);
- if (p == NULL)
- error ("Internal error: No thread state to clear?");
-
- p->handled = 0;
-}
-
-/* Set all threads to unhandled.
- */
-static void
-clear_all_handled ()
-{
- thread_info *p;
-
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "clear_all_handled\n" );
-#endif
-
- for( p = thread_head.head; p; p = p->next ) {
- p->handled = 0;
- }
-
- for( p = deleted_threads.head; p; p = p->next ) {
- p->handled = 0;
- }
-}
-
-/* Set this thread to default stepping mode.
- */
-static void
-clear_stepping_mode( tid )
- lwpid_t tid;
-{
- thread_info * p;
-
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "clear_stepping_mode %d\n", (int) tid );
-#endif
-
- p = find_thread_info (tid);
- if (p == NULL)
- error ("Internal error: No thread state to clear?");
-
- p->stepping_mode = DO_DEFAULT;
-}
-
-/* Set all threads to do default continue on resume.
- */
-static void
-clear_all_stepping_mode ()
-{
- thread_info *p;
-
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "clear_all_stepping_mode\n" );
-#endif
-
- for( p = thread_head.head; p; p = p->next ) {
- p->stepping_mode = DO_DEFAULT;
- }
-
- for( p = deleted_threads.head; p; p = p->next ) {
- p->stepping_mode = DO_DEFAULT;
- }
-}
-
-/* Set all threads to unseen on this pass.
- */
-static void
-set_all_unseen ()
-{
- thread_info *p;
-
- for( p = thread_head.head; p; p = p->next ) {
- p->seen = 0;
- }
-}
-
-#if (defined( THREAD_DEBUG ) || defined( PARANOIA ))
-/* debugging routine.
- */
-static void
-print_tthread (p)
- thread_info * p;
-{
- printf( " Thread pid %d, tid %d", p->pid, p->tid );
- if( p->have_state )
- printf( ", event is %s",
- get_printable_name_of_ttrace_event( p->last_stop_state.tts_event ));
-
- if( p->am_pseudo )
- printf( ", pseudo thread" );
-
- if( p->have_signal )
- printf( ", have signal 0x%x", p->signal_value );
-
- if( p->have_start )
- printf( ", have start at 0x%x", p->start );
-
- printf( ", step is %s", get_printable_name_of_stepping_mode( p->stepping_mode ));
-
- if( p->handled )
- printf( ", handled" );
- else
- printf( ", not handled" );
-
- if( p->seen )
- printf( ", seen" );
- else
- printf( ", not seen" );
-
- printf( "\n" );
-}
-
-static void
-print_tthreads ()
-{
- thread_info *p;
-
- if( thread_head.count == 0 )
- printf( "Thread list is empty\n" );
- else {
- printf( "Thread list has " );
- if( thread_head.count == 1 )
- printf( "1 entry:\n" );
- else
- printf( "%d entries:\n", thread_head.count );
- for( p = thread_head.head; p; p = p->next ) {
- print_tthread (p);
- }
- }
-
- if( deleted_threads.count == 0 )
- printf( "Deleted thread list is empty\n" );
- else {
- printf( "Deleted thread list has " );
- if( deleted_threads.count == 1 )
- printf( "1 entry:\n" );
- else
- printf( "%d entries:\n", deleted_threads.count );
-
- for( p = deleted_threads.head; p; p = p->next ) {
- print_tthread (p);
- }
- }
-}
-#endif
-
-/* Update the thread list based on the "seen" bits.
- */
-static void
-update_thread_list ()
-{
- thread_info *p;
- thread_info *chase;
-
- chase = NULL;
- for( p = thread_head.head; p; p = p->next ) {
- /* Is this an "unseen" thread which really happens to be a process?
- If so, is it inferior_pid and is a vfork in flight? If yes to
- all, then DON'T REMOVE IT! We're in the midst of moving a vfork
- operation, which is a multiple step thing, to the point where we
- can touch the parent again. We've most likely stopped to examine
- the child at a late stage in the vfork, and if we're not following
- the child, we'd best not treat the parent as a dead "thread"...
- */
- if( (!p->seen) && p->am_pseudo && vfork_in_flight
- && (p->pid != vforking_child_pid))
- p->seen = 1;
-
- if( !p->seen ) {
- /* Remove this one
- */
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Delete unseen thread: %d \n", p->tid );
-#endif
- del_tthread( p->tid );
- }
- }
-}
-
-
-
-/************************************************
- * O/S call wrappers *
- ************************************************
- */
-
-/* This function simply calls ttrace with the given arguments.
- * It exists so that all calls to ttrace are isolated. All
- * parameters should be as specified by "man 2 ttrace".
- *
- * No other "raw" calls to ttrace should exist in this module.
- */
-static int
-call_real_ttrace( request, pid, tid, addr, data, addr2 )
- ttreq_t request;
- pid_t pid;
- lwpid_t tid;
- TTRACE_ARG_TYPE addr, data, addr2;
-{
- int tt_status;
-
- errno = 0;
- tt_status = ttrace( request, pid, tid, addr, data, addr2 );
-
-#ifdef THREAD_DEBUG
- if (errno) {
- /* Don't bother for a known benign error: if you ask for the
- * first thread state, but there is only one thread and it's
- * not stopped, ttrace complains.
- *
- * We have this inside the #ifdef because our caller will do
- * this check for real.
- */
- if( request != TT_PROC_GET_FIRST_LWP_STATE
- || errno != EPROTO ) {
- if( debug_on )
- printf( "TT fail for %s, with pid %d, tid %d, status %d \n",
- get_printable_name_of_ttrace_request (request),
- pid, tid, tt_status );
- }
- }
-#endif
-
-#if 0
- /* ??rehrauer: It would probably be most robust to catch and report
- * failed requests here. However, some clients of this interface
- * seem to expect to catch & deal with them, so we'd best not.
- */
- if (errno) {
- strcpy (reason_for_failure, "ttrace (");
- strcat (reason_for_failure, get_printable_name_of_ttrace_request (request));
- strcat (reason_for_failure, ")");
- printf( "ttrace error, errno = %d\n", errno );
- perror_with_name (reason_for_failure);
- }
-#endif
-
- return tt_status;
-}
-
-
-/* This function simply calls ttrace_wait with the given arguments.
- * It exists so that all calls to ttrace_wait are isolated.
- *
- * No "raw" calls to ttrace_wait should exist elsewhere.
- */
-static int
-call_real_ttrace_wait( pid, tid, option, tsp, tsp_size )
- int pid;
- lwpid_t tid;
- ttwopt_t option;
- ttstate_t *tsp;
- size_t tsp_size;
-{
- int ttw_status;
- thread_info * tinfo = NULL;
-
- errno = 0;
- ttw_status = ttrace_wait (pid, tid, option, tsp, tsp_size);
-
- if (errno) {
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "TW fail with pid %d, tid %d \n", pid, tid );
-#endif
-
- perror_with_name ("ttrace wait");
- }
-
- return ttw_status;
-}
-
-
-/* A process may have one or more kernel threads, of which all or
- none may be stopped. This function returns the ID of the first
- kernel thread in a stopped state, or 0 if none are stopped.
-
- This function can be used with get_process_next_stopped_thread_id
- to iterate over the IDs of all stopped threads of this process.
- */
-static lwpid_t
-get_process_first_stopped_thread_id (pid, thread_state)
- int pid;
- ttstate_t * thread_state;
-{
- int tt_status;
-
- tt_status = call_real_ttrace (
- TT_PROC_GET_FIRST_LWP_STATE,
- (pid_t) pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) thread_state,
- (TTRACE_ARG_TYPE) sizeof (*thread_state),
- TT_NIL);
-
- if (errno) {
- if( errno == EPROTO) {
- /* This is an error we can handle: there isn't any stopped
- * thread. This happens when we're re-starting the application
- * and it has only one thread. GET_NEXT handles the case of
- * no more stopped threads well; GET_FIRST doesn't. (A ttrace
- * "feature".)
- */
- tt_status = 1;
- errno = 0;
- return 0;
- }
- else
- perror_with_name ("ttrace");
- }
-
- if( tt_status < 0 )
- /* Failed somehow.
- */
- return 0;
-
- return thread_state->tts_lwpid;
-}
-
-
-/* This function returns the ID of the "next" kernel thread in a
- stopped state, or 0 if there are none. "Next" refers to the
- thread following that of the last successful call to this
- function or to get_process_first_stopped_thread_id, using
- the value of thread_state returned by that call.
-
- This function can be used with get_process_first_stopped_thread_id
- to iterate over the IDs of all stopped threads of this process.
- */
-static lwpid_t
-get_process_next_stopped_thread_id (pid, thread_state)
- int pid;
- ttstate_t * thread_state;
-{
- int tt_status;
-
- tt_status = call_real_ttrace (
- TT_PROC_GET_NEXT_LWP_STATE,
- (pid_t) pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) thread_state,
- (TTRACE_ARG_TYPE) sizeof (*thread_state),
- TT_NIL);
- if (errno)
- perror_with_name ("ttrace");
-
- if (tt_status < 0)
- /* Failed
- */
- return 0;
-
- else if( tt_status == 0 ) {
- /* End of list, no next state. Don't return the
- * tts_lwpid, as it's a meaningless "240".
- *
- * This is an HPUX "feature".
- */
- return 0;
- }
-
- return thread_state->tts_lwpid;
-}
-
-/* ??rehrauer: Eventually this function perhaps should be calling
- pid_to_thread_id. However, that function currently does nothing
- for HP-UX. Even then, I'm not clear whether that function
- will return a "kernel" thread ID, or a "user" thread ID. If
- the former, we can just call it here. If the latter, we must
- map from the "user" tid to a "kernel" tid.
-
- NOTE: currently not called.
- */
-static lwpid_t
-get_active_tid_of_pid (pid)
- int pid;
-{
- ttstate_t thread_state;
-
- return get_process_first_stopped_thread_id (pid, &thread_state);
-}
-
-/* This function returns 1 if tt_request is a ttrace request that
- * operates upon all threads of a (i.e., the entire) process.
- */
-int
-is_process_ttrace_request (tt_request)
- ttreq_t tt_request;
-{
- return IS_TTRACE_PROCREQ (tt_request);
-}
-
-
-/* This function translates a thread ttrace request into
- * the equivalent process request for a one-thread process.
- */
-static ttreq_t
-make_process_version( request )
- ttreq_t request;
-{
- if (!IS_TTRACE_REQ (request)) {
- error( "Internal error, bad ttrace request made\n" );
- return -1;
- }
-
- switch (request) {
- case TT_LWP_STOP :
- return TT_PROC_STOP;
-
- case TT_LWP_CONTINUE :
- return TT_PROC_CONTINUE;
-
- case TT_LWP_GET_EVENT_MASK :
- return TT_PROC_GET_EVENT_MASK;
-
- case TT_LWP_SET_EVENT_MASK :
- return TT_PROC_SET_EVENT_MASK;
-
- case TT_LWP_SINGLE :
- case TT_LWP_RUREGS :
- case TT_LWP_WUREGS :
- case TT_LWP_GET_STATE :
- return -1; /* No equivalent */
-
- default :
- return request;
- }
-}
-
-
-/* This function translates the "pid" used by the rest of
- * gdb to a real pid and a tid. It then calls "call_real_ttrace"
- * with the given arguments.
- *
- * In general, other parts of this module should call this
- * function when they are dealing with external users, who only
- * have tids to pass (but they call it "pid" for historical
- * reasons).
- */
-static int
-call_ttrace( request, gdb_tid, addr, data, addr2 )
- ttreq_t request;
- int gdb_tid;
- TTRACE_ARG_TYPE addr, data, addr2;
-{
- lwpid_t real_tid;
- int real_pid;
- ttreq_t new_request;
- int tt_status;
- char reason_for_failure [100]; /* Arbitrary size, should be big enough. */
-
-#ifdef THREAD_DEBUG
- int is_interesting = 0;
-
- if( TT_LWP_RUREGS == request ) {
- is_interesting = 1; /* Adjust code here as desired */
- }
-
- if( is_interesting && 0 && debug_on ) {
- if( !is_process_ttrace_request( request )) {
- printf( "TT: Thread request, tid is %d", gdb_tid );
- printf( "== SINGLE at %x", addr );
- }
- else {
- printf( "TT: Process request, tid is %d\n", gdb_tid );
- printf( "==! SINGLE at %x", addr );
- }
- }
-#endif
-
- /* The initial SETTRC and SET_EVENT_MASK calls (and all others
- * which happen before any threads get set up) should go
- * directly to "call_real_ttrace", so they don't happen here.
- *
- * But hardware watchpoints do a SET_EVENT_MASK, so we can't
- * rule them out....
- */
-#ifdef THREAD_DEBUG
- if( request == TT_PROC_SETTRC && debug_on )
- printf( "Unexpected call for TT_PROC_SETTRC\n" );
-#endif
-
- /* Sometimes we get called with a bogus tid (e.g., if a
- * thread has terminated, we return 0; inftarg later asks
- * whether the thread has exited/forked/vforked).
- */
- if( gdb_tid == 0 )
- {
- errno = ESRCH; /* ttrace's response would probably be "No such process". */
- return -1;
- }
-
- /* All other cases should be able to expect that there are
- * thread records.
- */
- if( !any_thread_records()) {
-#ifdef THREAD_DEBUG
- if( debug_on )
- warning ("No thread records for ttrace call");
-#endif
- errno = ESRCH; /* ttrace's response would be "No such process". */
- return -1;
- }
-
- /* OK, now the task is to translate the incoming tid into
- * a pid/tid pair.
- */
- real_tid = map_from_gdb_tid( gdb_tid );
- real_pid = get_pid_for( real_tid );
-
- /* Now check the result. "Real_pid" is NULL if our list
- * didn't find it. We have some tricks we can play to fix
- * this, however.
- */
- if( 0 == real_pid ) {
- ttstate_t thread_state;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "No saved pid for tid %d\n", gdb_tid );
-#endif
-
- if( is_process_ttrace_request( request )) {
-
- /* Ok, we couldn't get a tid. Try to translate to
- * the equivalent process operation. We expect this
- * NOT to happen, so this is a desparation-type
- * move. It can happen if there is an internal
- * error and so no "wait()" call is ever done.
- */
- new_request = make_process_version( request );
- if( new_request == -1 ) {
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "...and couldn't make process version of thread operation\n" );
-#endif
-
- /* Use hacky saved pid, which won't always be correct
- * in the multi-process future. Use tid as thread,
- * probably dooming this to failure. FIX!
- */
- if( saved_real_pid != 0 ) {
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "...using saved pid %d\n", saved_real_pid );
-#endif
-
- real_pid = saved_real_pid;
- real_tid = gdb_tid;
- }
-
- else
- error( "Unable to perform thread operation" );
- }
-
- else {
- /* Sucessfully translated this to a process request,
- * which needs no thread value.
- */
- real_pid = gdb_tid;
- real_tid = 0;
- request = new_request;
-
-#ifdef THREAD_DEBUG
- if( debug_on ) {
- printf( "Translated thread request to process request\n" );
- if( saved_real_pid == 0 )
- printf( "...but there's no saved pid\n" );
-
- else {
- if( gdb_tid != saved_real_pid )
- printf( "...but have the wrong pid (%d rather than %d)\n",
- gdb_tid, saved_real_pid );
- }
- }
-#endif
- } /* Translated to a process request */
- } /* Is a process request */
-
- else {
- /* We have to have a thread. Ooops.
- */
- error( "Thread request with no threads (%s)",
- get_printable_name_of_ttrace_request( request ));
- }
- }
-
- /* Ttrace doesn't like to see tid values on process requests,
- * even if we have the right one.
- */
- if (is_process_ttrace_request (request)) {
- real_tid = 0;
- }
-
-#ifdef THREAD_DEBUG
- if( is_interesting && 0 && debug_on ) {
- printf( " now tid %d, pid %d\n", real_tid, real_pid );
- printf( " request is %s\n", get_printable_name_of_ttrace_request (request));
- }
-#endif
-
- /* Finally, the (almost) real call.
- */
- tt_status = call_real_ttrace (request, real_pid, real_tid, addr, data, addr2);
-
-#ifdef THREAD_DEBUG
- if(is_interesting && debug_on ) {
- if( !TT_OK( tt_status, errno )
- && !(tt_status == 0 & errno == 0))
- printf( " got error (errno==%d, status==%d)\n", errno, tt_status );
- }
-#endif
-
- return tt_status;
-}
-
-
-/* Stop all the threads of a process.
- *
- * NOTE: use of TT_PROC_STOP can cause a thread with a real event
- * to get a TTEVT_NONE event, discarding the old event. Be
- * very careful, and only call TT_PROC_STOP when you mean it!
- */
-static void
-stop_all_threads_of_process( real_pid )
- pid_t real_pid;
-{
- int ttw_status;
-
- ttw_status = call_real_ttrace (TT_PROC_STOP,
- (pid_t) real_pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) TT_NIL,
- (TTRACE_ARG_TYPE) TT_NIL,
- TT_NIL );
- if (errno)
- perror_with_name ("ttrace stop of other threads");
-}
-
-
-/* Under some circumstances, it's unsafe to attempt to stop, or even
- query the state of, a process' threads.
-
- In ttrace-based HP-UX, an example is a vforking child process. The
- vforking parent and child are somewhat fragile, w/r/t what we can do
- what we can do to them with ttrace, until after the child exits or
- execs, or until the parent's vfork event is delivered. Until that
- time, we must not try to stop the process' threads, or inquire how
- many there are, or even alter its data segments, or it typically dies
- with a SIGILL. Sigh.
-
- This function returns 1 if this stopped process, and the event that
- we're told was responsible for its current stopped state, cannot safely
- have its threads examined.
- */
-#define CHILD_VFORKED(evt,pid) \
- (((evt) == TTEVT_VFORK) && ((pid) != inferior_pid))
-#define CHILD_URPED(evt,pid) \
- ((((evt) == TTEVT_EXEC) || ((evt) == TTEVT_EXIT)) && ((pid) != vforking_child_pid))
-#define PARENT_VFORKED(evt,pid) \
- (((evt) == TTEVT_VFORK) && ((pid) == inferior_pid))
-
-static int
-can_touch_threads_of_process (pid, stopping_event)
- int pid;
- ttevents_t stopping_event;
-{
- if (CHILD_VFORKED (stopping_event, pid))
- {
- vforking_child_pid = pid;
- vfork_in_flight = 1;
- }
-
- else if (vfork_in_flight &&
- (PARENT_VFORKED (stopping_event, pid) ||
- CHILD_URPED (stopping_event, pid)))
- {
- vfork_in_flight = 0;
- vforking_child_pid = 0;
- }
-
- return ! vfork_in_flight;
-}
-
-
-/* If we can find an as-yet-unhandled thread state of a
- * stopped thread of this process return 1 and set "tsp".
- * Return 0 if we can't.
- *
- * If this function is used when the threads of PIS haven't
- * been stopped, undefined behaviour is guaranteed!
- */
-static int
-select_stopped_thread_of_process (pid, tsp)
- int pid;
- ttstate_t * tsp;
-{
- lwpid_t candidate_tid, tid;
- ttstate_t candidate_tstate, tstate;
-
- /* If we're not allowed to touch the process now, then just
- * return the current value of *TSP.
- *
- * This supports "vfork". It's ok, really, to double the
- * current event (the child EXEC, we hope!).
- */
- if (! can_touch_threads_of_process (pid, tsp->tts_event))
- return 1;
-
- /* Decide which of (possibly more than one) events to
- * return as the first one. We scan them all so that
- * we always return the result of a fake-step first.
- */
- candidate_tid = 0;
- for (tid = get_process_first_stopped_thread_id (pid, &tstate);
- tid != 0;
- tid = get_process_next_stopped_thread_id (pid, &tstate))
- {
- /* TTEVT_NONE events are uninteresting to our clients. They're
- * an artifact of our "stop the world" model--the thread is
- * stopped because we stopped it.
- */
- if (tstate.tts_event == TTEVT_NONE) {
- set_handled( pid, tstate.tts_lwpid );
- }
-
- /* Did we just single-step a single thread, without letting any
- * of the others run? Is this an event for that thread?
- *
- * If so, we believe our client would prefer to see this event
- * over any others. (Typically the client wants to just push
- * one thread a little farther forward, and then go around
- * checking for what all threads are doing.)
- */
- else if (doing_fake_step && (tstate.tts_lwpid == fake_step_tid))
- {
-#ifdef WAIT_BUFFER_DEBUG
- /* It's possible here to see either a SIGTRAP (due to
- * successful completion of a step) or a SYSCALL_ENTRY
- * (due to a step completion with active hardware
- * watchpoints).
- */
- if( debug_on )
- printf( "Ending fake step with tid %d, state %s\n",
- tstate.tts_lwpid,
- get_printable_name_of_ttrace_event( tstate.tts_event ));
-#endif
-
- /* Remember this one, and throw away any previous
- * candidate.
- */
- candidate_tid = tstate.tts_lwpid;
- candidate_tstate = tstate;
- }
-
-#ifdef FORGET_DELETED_BPTS
-
- /* We can't just do this, as if we do, and then wind
- * up the loop with no unhandled events, we need to
- * handle that case--the appropriate reaction is to
- * just continue, but there's no easy way to do that.
- *
- * Better to put this in the ttrace_wait call--if, when
- * we fake a wait, we update our events based on the
- * breakpoint_here_pc call and find there are no more events,
- * then we better continue and so on.
- *
- * Or we could put it in the next/continue fake.
- * But it has to go in the buffering code, not in the
- * real go/wait code.
- */
- else if( (TTEVT_SIGNAL == tstate.tts_event)
- && (5 == tstate.tts_u.tts_signal.tts_signo)
- && (0 != get_raw_pc( tstate.tts_lwpid ))
- && ! breakpoint_here_p( get_raw_pc( tstate.tts_lwpid )) ) {
- /*
- * If the user deleted a breakpoint while this
- * breakpoint-hit event was buffered, we can forget
- * it now.
- */
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Forgetting deleted bp hit for thread %d\n",
- tstate.tts_lwpid );
-#endif
-
- set_handled( pid, tstate.tts_lwpid );
- }
-#endif
-
- /* Else, is this the first "unhandled" event? If so,
- * we believe our client wants to see it (if we don't
- * see a fake-step later on in the scan).
- */
- else if( !was_handled( tstate.tts_lwpid ) && candidate_tid == 0 ) {
- candidate_tid = tstate.tts_lwpid;
- candidate_tstate = tstate;
- }
-
- /* This is either an event that has already been "handled",
- * and thus we believe is uninteresting to our client, or we
- * already have a candidate event. Ignore it...
- */
- }
-
- /* What do we report?
- */
- if( doing_fake_step ) {
- if( candidate_tid == fake_step_tid ) {
- /* Fake step.
- */
- tstate = candidate_tstate;
- }
- else {
- warning( "Internal error: fake-step failed to complete." );
- return 0;
- }
- }
- else if( candidate_tid != 0 ) {
- /* Found a candidate unhandled event.
- */
- tstate = candidate_tstate;
- }
- else if( tid != 0 ) {
- warning( "Internal error in call of ttrace_wait." );
- return 0;
- }
- else {
- warning ("Internal error: no unhandled thread event to select");
- return 0;
- }
-
- copy_ttstate_t (tsp, &tstate);
- return 1;
-} /* End of select_stopped_thread_of_process */
-
-#ifdef PARANOIA
-/* Check our internal thread data against the real thing.
- */
-static void
-check_thread_consistency( real_pid )
- pid_t real_pid;
-{
- int tid; /* really lwpid_t */
- ttstate_t tstate;
- thread_info *p;
-
- /* Spin down the O/S list of threads, checking that they
- * match what we've got.
- */
- for (tid = get_process_first_stopped_thread_id( real_pid, &tstate );
- tid != 0;
- tid = get_process_next_stopped_thread_id( real_pid, &tstate )) {
-
- p = find_thread_info( tid );
-
- if( NULL == p ) {
- warning( "No internal thread data for thread %d.", tid );
- continue;
- }
-
- if( !p->seen ) {
- warning( "Inconsistent internal thread data for thread %d.", tid );
- }
-
- if( p->terminated ) {
- warning( "Thread %d is not terminated, internal error.", tid );
- continue;
- }
-
-
-#define TT_COMPARE( fld ) \
- tstate.fld != p->last_stop_state.fld
-
- if( p->have_state ) {
- if( TT_COMPARE( tts_pid )
- || TT_COMPARE( tts_lwpid )
- || TT_COMPARE( tts_user_tid )
- || TT_COMPARE( tts_event )
- || TT_COMPARE( tts_flags )
- || TT_COMPARE( tts_scno )
- || TT_COMPARE( tts_scnargs )) {
- warning( "Internal thread data for thread %d is wrong.", tid );
- continue;
- }
- }
- }
-}
-#endif /* PARANOIA */
-
-
-/* This function wraps calls to "call_real_ttrace_wait" so
- * that a actual wait is only done when all pending events
- * have been reported.
- *
- * Note that typically it is called with a pid of "0", i.e.
- * the "don't care" value.
- *
- * Return value is the status of the pseudo wait.
- */
-static int
-call_ttrace_wait( pid, option, tsp, tsp_size )
- int pid;
- ttwopt_t option;
- ttstate_t *tsp;
- size_t tsp_size;
-{
- /* This holds the actual, for-real, true process ID.
- */
- static int real_pid;
-
- /* As an argument to ttrace_wait, zero pid
- * means "Any process", and zero tid means
- * "Any thread of the specified process".
- */
- int wait_pid = 0;
- lwpid_t wait_tid = 0;
- lwpid_t real_tid;
-
- int ttw_status = 0; /* To be returned */
-
- thread_info * tinfo = NULL;
-
- if( pid != 0 ) {
- /* Unexpected case.
- */
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "TW: Pid to wait on is %d\n", pid );
-#endif
-
- if( !any_thread_records())
- error( "No thread records for ttrace call w. specific pid" );
-
- /* OK, now the task is to translate the incoming tid into
- * a pid/tid pair.
- */
- real_tid = map_from_gdb_tid( pid );
- real_pid = get_pid_for( real_tid );
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "==TW: real pid %d, real tid %d\n", real_pid, real_tid );
-#endif
- }
-
-
- /* Sanity checks and set-up.
- * Process State
- *
- * Stopped Running Fake-step (v)Fork
- * \________________________________________
- * |
- * No buffered events | error wait wait wait
- * |
- * Buffered events | debuffer error wait debuffer (?)
- *
- */
- if( more_events_left == 0 ) {
-
- if( process_state == RUNNING ) {
- /* OK--normal call of ttrace_wait with no buffered events.
- */
- ;
- }
- else if( process_state == FAKE_STEPPING ) {
- /* Ok--call of ttrace_wait to support
- * fake stepping with no buffered events.
- *
- * But we better be fake-stepping!
- */
- if( !doing_fake_step ) {
- warning( "Inconsistent thread state." );
- }
- }
- else if( (process_state == FORKING)
- || (process_state == VFORKING)) {
- /* Ok--there are two processes, so waiting
- * for the second while the first is stopped
- * is ok. Handled bits stay as they were.
- */
- ;
- }
- else if( process_state == STOPPED ) {
- warning( "Process not running at wait call." );
- }
- else
- /* No known state.
- */
- warning( "Inconsistent process state." );
- }
-
- else {
- /* More events left
- */
- if( process_state == STOPPED ) {
- /* OK--buffered events being unbuffered.
- */
- ;
- }
- else if( process_state == RUNNING ) {
- /* An error--shouldn't have buffered events
- * when running.
- */
- warning( "Trying to continue with buffered events:" );
- }
- else if( process_state == FAKE_STEPPING ) {
- /*
- * Better be fake-stepping!
- */
- if( !doing_fake_step ) {
- warning( "Losing buffered thread events!\n" );
- }
- }
- else if( (process_state == FORKING)
- || (process_state == VFORKING)) {
- /* Ok--there are two processes, so waiting
- * for the second while the first is stopped
- * is ok. Handled bits stay as they were.
- */
- ;
- }
- else
- warning( "Process in unknown state with buffered events." );
- }
-
- /* Sometimes we have to wait for a particular thread
- * (if we're stepping over a bpt). In that case, we
- * _know_ it's going to complete the single-step we
- * asked for (because we're only doing the step under
- * certain very well-understood circumstances), so it
- * can't block.
- */
- if( doing_fake_step ) {
- wait_tid = fake_step_tid;
- wait_pid = get_pid_for( fake_step_tid );
-
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Doing a wait after a fake-step for %d, pid %d\n",
- wait_tid, wait_pid );
-#endif
- }
-
- if( more_events_left == 0 /* No buffered events, need real ones. */
- || process_state != STOPPED ) {
- /* If there are no buffered events, and so we need
- * real ones, or if we are FORKING, VFORKING,
- * FAKE_STEPPING or RUNNING, and thus have to do
- * a real wait, then do a real wait.
- */
-
-#ifdef WAIT_BUFFER_DEBUG
- /* Normal case... */
- if( debug_on )
- printf( "TW: do it for real; pid %d, tid %d\n", wait_pid, wait_tid );
-#endif
-
- /* The actual wait call.
- */
- ttw_status = call_real_ttrace_wait( wait_pid, wait_tid, option, tsp, tsp_size);
-
- /* Note that the routines we'll call will be using "call_real_ttrace",
- * not "call_ttrace", and thus need the real pid rather than the pseudo-tid
- * the rest of the world uses (which is actually the tid).
- */
- real_pid = tsp->tts_pid;
-
- /* For most events: Stop the world!
- *
- * It's sometimes not safe to stop all threads of a process.
- * Sometimes it's not even safe to ask for the thread state
- * of a process!
- */
- if (can_touch_threads_of_process (real_pid, tsp->tts_event))
- {
- /* If we're really only stepping a single thread, then don't
- * try to stop all the others -- we only do this single-stepping
- * business when all others were already stopped...and the stop
- * would mess up other threads' events.
- *
- * Similiarly, if there are other threads with events,
- * don't do the stop.
- */
- if( !doing_fake_step ) {
- if( more_events_left > 0 )
- warning( "Internal error in stopping process" );
-
- stop_all_threads_of_process (real_pid);
-
- /* At this point, we could scan and update_thread_list(),
- * and only use the local list for the rest of the
- * module! We'd get rid of the scans in the various
- * continue routines (adding one in attach). It'd
- * be great--UPGRADE ME!
- */
- }
- }
-
-#ifdef PARANOIA
- else if( debug_on ) {
- if( more_events_left > 0 )
- printf( "== Can't stop process; more events!\n" );
- else
- printf( "== Can't stop process!\n" );
- }
-#endif
-
- process_state = STOPPED;
-
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Process set to STOPPED\n" );
-#endif
- }
-
- else {
- /* Fake a call to ttrace_wait. The process must be
- * STOPPED, as we aren't going to do any wait.
- */
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "TW: fake it\n" );
-#endif
-
- if( process_state != STOPPED ) {
- warning( "Process not stopped at wait call, in state '%s'.\n",
- get_printable_name_of_process_state( process_state ));
- }
-
- if( doing_fake_step )
- error( "Internal error in stepping over breakpoint" );
-
- ttw_status = 0; /* Faking it is always successful! */
- } /* End of fake or not? if */
-
- /* Pick an event to pass to our caller. Be paranoid.
- */
- if( !select_stopped_thread_of_process( real_pid, tsp ))
- warning( "Can't find event, using previous event." );
-
- else if( tsp->tts_event == TTEVT_NONE )
- warning( "Internal error: no thread has a real event." );
-
- else if( doing_fake_step ) {
- if( fake_step_tid != tsp->tts_lwpid )
- warning( "Internal error in stepping over breakpoint." );
-
- /* This wait clears the (current) fake-step if there was one.
- */
- doing_fake_step = 0;
- fake_step_tid = 0;
- }
-
- /* We now have a correct tsp and ttw_status for the thread
- * which we want to report. So it's "handled"! This call
- * will add it to our list if it's not there already.
- */
- set_handled( real_pid, tsp->tts_lwpid );
-
- /* Save a copy of the ttrace state of this thread, in our local
- thread descriptor.
-
- This caches the state. The implementation of queries like
- target_has_execd can then use this cached state, rather than
- be forced to make an explicit ttrace call to get it.
-
- (Guard against the condition that this is the first time we've
- waited on, i.e., seen this thread, and so haven't yet entered
- it into our list of threads.)
- */
- tinfo = find_thread_info (tsp->tts_lwpid);
- if (tinfo != NULL) {
- copy_ttstate_t (&tinfo->last_stop_state, tsp);
- tinfo->have_state = 1;
- }
-
- return ttw_status;
-} /* call_ttrace_wait */
-
-#if defined(CHILD_REPORTED_EXEC_EVENTS_PER_EXEC_CALL)
-int
-child_reported_exec_events_per_exec_call ()
-{
- return 1; /* ttrace reports the event once per call. */
-}
-#endif
-
-
-
-/* Our implementation of hardware watchpoints involves making memory
- pages write-protected. We must remember a page's original permissions,
- and we must also know when it is appropriate to restore a page's
- permissions to its original state.
-
- We use a "dictionary" of hardware-watched pages to do this. Each
- hardware-watched page is recorded in the dictionary. Each page's
- dictionary entry contains the original permissions and a reference
- count. Pages are hashed into the dictionary by their start address.
-
- When hardware watchpoint is set on page X for the first time, page X
- is added to the dictionary with a reference count of 1. If other
- hardware watchpoints are subsequently set on page X, its reference
- count is incremented. When hardware watchpoints are removed from
- page X, its reference count is decremented. If a page's reference
- count drops to 0, it's permissions are restored and the page's entry
- is thrown out of the dictionary.
- */
-typedef struct memory_page {
- CORE_ADDR page_start;
- int reference_count;
- int original_permissions;
- struct memory_page * next;
- struct memory_page * previous;
-} memory_page_t;
-
-#define MEMORY_PAGE_DICTIONARY_BUCKET_COUNT 128
-
-static struct {
- LONGEST page_count;
- int page_size;
- int page_protections_allowed;
- /* These are just the heads of chains of actual page descriptors. */
- memory_page_t buckets [MEMORY_PAGE_DICTIONARY_BUCKET_COUNT];
-} memory_page_dictionary;
-
-
-static void
-require_memory_page_dictionary ()
-{
- int i;
-
- /* Is the memory page dictionary ready for use? If so, we're done. */
- if (memory_page_dictionary.page_count >= (LONGEST) 0)
- return;
-
- /* Else, initialize it. */
- memory_page_dictionary.page_count = (LONGEST) 0;
-
- for (i=0; i<MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; i++)
- {
- memory_page_dictionary.buckets[i].page_start = (CORE_ADDR) 0;
- memory_page_dictionary.buckets[i].reference_count = 0;
- memory_page_dictionary.buckets[i].next = NULL;
- memory_page_dictionary.buckets[i].previous = NULL;
- }
-}
-
-
-static void
-retire_memory_page_dictionary ()
-{
- memory_page_dictionary.page_count = (LONGEST) -1;
-}
-
-
-/* Write-protect the memory page that starts at this address.
-
- Returns the original permissions of the page.
- */
-static int
-write_protect_page (pid, page_start)
- int pid;
- CORE_ADDR page_start;
-{
- int tt_status;
- int original_permissions;
- int new_permissions;
-
- tt_status = call_ttrace (TT_PROC_GET_MPROTECT,
- pid,
- (TTRACE_ARG_TYPE) page_start,
- TT_NIL,
- (TTRACE_ARG_TYPE) &original_permissions);
- if (errno || (tt_status < 0))
- {
- return 0; /* What else can we do? */
- }
-
- /* We'll also write-protect the page now, if that's allowed. */
- if (memory_page_dictionary.page_protections_allowed)
- {
- new_permissions = original_permissions & ~PROT_WRITE;
- tt_status = call_ttrace (TT_PROC_SET_MPROTECT,
- pid,
- (TTRACE_ARG_TYPE) page_start,
- (TTRACE_ARG_TYPE) memory_page_dictionary.page_size,
- (TTRACE_ARG_TYPE) new_permissions);
- if (errno || (tt_status < 0))
- {
- return 0; /* What else can we do? */
- }
- }
-
- return original_permissions;
-}
-
-
-/* Unwrite-protect the memory page that starts at this address, restoring
- (what we must assume are) its original permissions.
- */
-static void
-unwrite_protect_page (pid, page_start, original_permissions)
- int pid;
- CORE_ADDR page_start;
- int original_permissions;
-{
- int tt_status;
-
- tt_status = call_ttrace (TT_PROC_SET_MPROTECT,
- pid,
- (TTRACE_ARG_TYPE) page_start,
- (TTRACE_ARG_TYPE) memory_page_dictionary.page_size,
- (TTRACE_ARG_TYPE) original_permissions);
- if (errno || (tt_status < 0))
- {
- return; /* What else can we do? */
- }
-}
-
-
-/* Memory page-protections are used to implement "hardware" watchpoints
- on HP-UX.
-
- For every memory page that is currently being watched (i.e., that
- presently should be write-protected), write-protect it.
- */
-void
-hppa_enable_page_protection_events (pid)
- int pid;
-{
- int bucket;
-
- memory_page_dictionary.page_protections_allowed = 1;
-
- for (bucket=0; bucket<MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; bucket++)
- {
- memory_page_t * page;
-
- page = memory_page_dictionary.buckets[bucket].next;
- while (page != NULL)
- {
- page->original_permissions = write_protect_page (pid, page->page_start);
- page = page->next;
- }
- }
-}
-
-
-/* Memory page-protections are used to implement "hardware" watchpoints
- on HP-UX.
-
- For every memory page that is currently being watched (i.e., that
- presently is or should be write-protected), un-write-protect it.
- */
-void
-hppa_disable_page_protection_events (pid)
- int pid;
-{
- int bucket;
-
- for (bucket=0; bucket<MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; bucket++)
- {
- memory_page_t * page;
-
- page = memory_page_dictionary.buckets[bucket].next;
- while (page != NULL)
- {
- unwrite_protect_page (pid, page->page_start, page->original_permissions);
- page = page->next;
- }
- }
-
- memory_page_dictionary.page_protections_allowed = 0;
-}
-
-/* Count the number of outstanding events. At this
- * point, we have selected one thread and its event
- * as the one to be "reported" upwards to core gdb.
- * That thread is already marked as "handled".
- *
- * Note: we could just scan our own thread list. FIXME!
- */
-static int
-count_unhandled_events( real_pid, real_tid )
- int real_pid;
- lwpid_t real_tid;
-{
- ttstate_t tstate;
- lwpid_t ttid;
- int events_left;
-
- /* Ok, find out how many threads have real events to report.
- */
- events_left = 0;
- ttid = get_process_first_stopped_thread_id( real_pid, &tstate );
-
-#ifdef THREAD_DEBUG
- if( debug_on ) {
- if( ttid == 0 )
- printf( "Process %d has no threads\n", real_pid );
- else
- printf( "Process %d has these threads:\n", real_pid );
- }
-#endif
-
- while (ttid > 0 ) {
- if( tstate.tts_event != TTEVT_NONE
- && !was_handled( ttid )) {
- /* TTEVT_NONE implies we just stopped it ourselves
- * because we're the stop-the-world guys, so it's
- * not an event from our point of view.
- *
- * If "was_handled" is true, this is an event we
- * already handled, so don't count it.
- *
- * Note that we don't count the thread with the
- * currently-reported event, as it's already marked
- * as handled.
- */
- events_left++;
- }
-
-#if defined( THREAD_DEBUG ) || defined( WAIT_BUFFER_DEBUG )
- if( debug_on ) {
- if( ttid == real_tid )
- printf( "*" ); /* Thread we're reporting */
- else
- printf( " " );
-
- if( tstate.tts_event != TTEVT_NONE )
- printf( "+" ); /* Thread with a real event */
- else
- printf( " " );
-
- if( was_handled( ttid ))
- printf( "h" ); /* Thread has been handled */
- else
- printf( " " );
-
- printf( " %d, with event %s", ttid,
- get_printable_name_of_ttrace_event( tstate.tts_event ));
-
- if( tstate.tts_event == TTEVT_SIGNAL
- && 5 == tstate.tts_u.tts_signal.tts_signo ) {
- CORE_ADDR pc_val;
-
- pc_val = get_raw_pc( ttid );
-
- if( pc_val > 0 )
- printf( " breakpoint at 0x%x\n", pc_val );
- else
- printf( " bpt, can't fetch pc.\n" );
- }
- else
- printf( "\n" );
- }
-#endif
-
- ttid = get_process_next_stopped_thread_id (real_pid, &tstate);
- }
-
-#if defined( THREAD_DEBUG ) || defined( WAIT_BUFFER_DEBUG )
- if( debug_on )
- if( events_left > 0 )
- printf( "There are thus %d pending events\n", events_left );
-#endif
-
- return events_left;
-}
-
-/* This function is provided as a sop to clients that are calling
- * proc_wait to wait for a process to stop. (see the
- * implementation of child_wait.) Return value is the pid for
- * the event that ended the wait.
- *
- * Note: used by core gdb and so uses the pseudo-pid (really tid).
- */
-int
-proc_wait (pid, status)
- int pid;
- int *status;
-{
- ttstate_t tsp;
- int ttwait_return;
- int real_pid;
- ttstate_t state;
- lwpid_t real_tid;
- int return_pid;
-
- /* The ptrace implementation of this also ignores pid.
- */
- *status = 0;
-
- ttwait_return = call_ttrace_wait( 0, TTRACE_WAITOK, &tsp, sizeof (tsp) );
- if (ttwait_return < 0)
- {
- /* ??rehrauer: It appears that if our inferior exits and we
- haven't asked for exit events, that we're not getting any
- indication save a negative return from ttrace_wait and an
- errno set to ESRCH?
- */
- if (errno == ESRCH)
- {
- *status = 0; /* WIFEXITED */
- return inferior_pid;
- }
-
- warning( "Call of ttrace_wait returned with errno %d.",
- errno );
- *status = ttwait_return;
- return inferior_pid;
- }
-
- real_pid = tsp.tts_pid;
- real_tid = tsp.tts_lwpid;
-
- /* One complication is that the "tts_event" structure has
- * a set of flags, and more than one can be set. So we
- * either have to force an order (as we do here), or handle
- * more than one flag at a time.
- */
- if (tsp.tts_event & TTEVT_LWP_CREATE) {
-
- /* Unlike what you might expect, this event is reported in
- * the _creating_ thread, and the _created_ thread (whose tid
- * we have) is still running. So we have to stop it. This
- * has already been done in "call_ttrace_wait", but should we
- * ever abandon the "stop-the-world" model, here's the command
- * to use:
- *
- * call_ttrace( TT_LWP_STOP, real_tid, TT_NIL, TT_NIL, TT_NIL );
- *
- * Note that this would depend on being called _after_ "add_tthread"
- * below for the tid-to-pid translation to be done in "call_ttrace".
- */
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "New thread: pid %d, tid %d, creator tid %d\n",
- real_pid, tsp.tts_u.tts_thread.tts_target_lwpid,
- real_tid );
-#endif
-
- /* Now we have to return the tid of the created thread, not
- * the creating thread, or "wait_for_inferior" won't know we
- * have a new "process" (thread). Plus we should record it
- * right, too.
- */
- real_tid = tsp.tts_u.tts_thread.tts_target_lwpid;
-
- add_tthread( real_pid, real_tid );
- }
-
- else if( (tsp.tts_event & TTEVT_LWP_TERMINATE )
- || (tsp.tts_event & TTEVT_LWP_EXIT) ) {
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Thread dies: %d\n", real_tid );
-#endif
-
- del_tthread( real_tid );
- }
-
- else if (tsp.tts_event & TTEVT_EXEC) {
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Pid %d has zero'th thread %d; inferior pid is %d\n",
- real_pid, real_tid, inferior_pid );
-#endif
-
- add_tthread( real_pid, real_tid );
- }
-
-#ifdef THREAD_DEBUG
- else if( debug_on ) {
- printf( "Process-level event %s, using tid %d\n",
- get_printable_name_of_ttrace_event( tsp.tts_event ),
- real_tid );
-
- /* OK to do this, as "add_tthread" won't add
- * duplicate entries. Also OK not to do it,
- * as this event isn't one which can change the
- * thread state.
- */
- add_tthread( real_pid, real_tid );
- }
-#endif
-
-
- /* How many events are left to report later?
- * In a non-stop-the-world model, this isn't needed.
- *
- * Note that it's not always safe to query the thread state of a process,
- * which is what count_unhandled_events does. (If unsafe, we're left with
- * no other resort than to assume that no more events remain...)
- */
- if (can_touch_threads_of_process (real_pid, tsp.tts_event))
- more_events_left = count_unhandled_events( real_pid, real_tid );
-
- else {
- if( more_events_left > 0 )
- warning( "Vfork or fork causing loss of %d buffered events.",
- more_events_left );
-
- more_events_left = 0;
- }
-
- /* Attempt to translate the ttrace_wait-returned status into the
- ptrace equivalent.
-
- ??rehrauer: This is somewhat fragile. We really ought to rewrite
- clients that expect to pick apart a ptrace wait status, to use
- something a little more abstract.
- */
- if ( (tsp.tts_event & TTEVT_EXEC)
- || (tsp.tts_event & TTEVT_FORK)
- || (tsp.tts_event & TTEVT_VFORK))
- {
- /* Forks come in pairs (parent and child), so core gdb
- * will do two waits. Be ready to notice this.
- */
- if (tsp.tts_event & TTEVT_FORK)
- {
- process_state = FORKING;
-
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Process set to FORKING\n" );
-#endif
- }
- else if (tsp.tts_event & TTEVT_VFORK)
- {
- process_state = VFORKING;
-
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Process set to VFORKING\n" );
-#endif
- }
-
- /* Make an exec or fork look like a breakpoint. Definitely a hack,
- but I don't think non HP-UX-specific clients really carefully
- inspect the first events they get after inferior startup, so
- it probably almost doesn't matter what we claim this is.
- */
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "..a process 'event'\n" );
-#endif
-
- /* Also make fork and exec events look like bpts, so they can be caught.
- */
- *status = 0177 | (_SIGTRAP << 8);
- }
-
- /* Special-cases: We ask for syscall entry and exit events to implement
- "fast" (aka "hardware") watchpoints.
-
- When we get a syscall entry, we want to disable page-protections,
- and resume the inferior; this isn't an event we wish for
- wait_for_inferior to see. Note that we must resume ONLY the
- thread that reported the syscall entry; we don't want to allow
- other threads to run with the page protections off, as they might
- then be able to write to watch memory without it being caught.
-
- When we get a syscall exit, we want to reenable page-protections,
- but we don't want to resume the inferior; this is an event we wish
- wait_for_inferior to see. Make it look like the signal we normally
- get for a single-step completion. This should cause wait_for_inferior
- to evaluate whether any watchpoint triggered.
-
- Or rather, that's what we'd LIKE to do for syscall exit; we can't,
- due to some HP-UX "features". Some syscalls have problems with
- write-protections on some pages, and some syscalls seem to have
- pending writes to those pages at the time we're getting the return
- event. So, we'll single-step the inferior to get out of the syscall,
- and then reenable protections.
-
- Note that we're intentionally allowing the syscall exit case to
- fall through into the succeeding cases, as sometimes we single-
- step out of one syscall only to immediately enter another...
- */
- else if ((tsp.tts_event & TTEVT_SYSCALL_ENTRY)
- || (tsp.tts_event & TTEVT_SYSCALL_RETURN))
- {
- /* Make a syscall event look like a breakpoint. Same comments
- as for exec & fork events.
- */
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "..a syscall 'event'\n" );
-#endif
-
- /* Also make syscall events look like bpts, so they can be caught.
- */
- *status = 0177 | (_SIGTRAP << 8);
- }
-
- else if ((tsp.tts_event & TTEVT_LWP_CREATE)
- || (tsp.tts_event & TTEVT_LWP_TERMINATE)
- || (tsp.tts_event & TTEVT_LWP_EXIT))
- {
- /* Make a thread event look like a breakpoint. Same comments
- * as for exec & fork events.
- */
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "..a thread 'event'\n" );
-#endif
-
- /* Also make thread events look like bpts, so they can be caught.
- */
- *status = 0177 | (_SIGTRAP << 8);
- }
-
- else if ((tsp.tts_event & TTEVT_EXIT))
- { /* WIFEXITED */
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "..an exit\n" );
-#endif
-
- /* Prevent rest of gdb from thinking this is
- * a new thread if for some reason it's never
- * seen the main thread before.
- */
- inferior_pid = map_to_gdb_tid( real_tid ); /* HACK, FIX */
-
- *status = 0 | (tsp.tts_u.tts_exit.tts_exitcode);
- }
-
- else if (tsp.tts_event & TTEVT_SIGNAL)
- { /* WIFSTOPPED */
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "..a signal, %d\n", tsp.tts_u.tts_signal.tts_signo );
-#endif
-
- *status = 0177 | (tsp.tts_u.tts_signal.tts_signo << 8);
- }
-
- else
- { /* !WIFSTOPPED */
-
- /* This means the process or thread terminated. But we should've
- caught an explicit exit/termination above. So warn (this is
- really an internal error) and claim the process or thread
- terminated with a SIGTRAP.
- */
-
- warning ("process_wait: unknown process state");
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Process-level event %s, using tid %d\n",
- get_printable_name_of_ttrace_event( tsp.tts_event ),
- real_tid );
-#endif
-
- *status = _SIGTRAP;
- }
-
- target_post_wait (tsp.tts_pid, *status);
-
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Done waiting, pid is %d, tid %d\n", real_pid, real_tid );
-#endif
-
- /* All code external to this module uses the tid, but calls
- * it "pid". There's some tweaking so that the outside sees
- * the first thread as having the same number as the starting
- * pid.
- */
- return_pid = map_to_gdb_tid( real_tid );
-
- /* Remember this for later use in "hppa_prepare_to_proceed".
- */
- old_gdb_pid = inferior_pid;
- reported_pid = return_pid;
- reported_bpt = ((tsp.tts_event & TTEVT_SIGNAL) && (5 == tsp.tts_u.tts_signal.tts_signo));
-
- if( real_tid == 0 || return_pid == 0 ) {
- warning( "Internal error: process-wait failed." );
- }
-
- return return_pid;
-}
-
-
-/* This function causes the caller's process to be traced by its
- parent. This is intended to be called after GDB forks itself,
- and before the child execs the target. Despite the name, it
- is called by the child.
-
- Note that HP-UX ttrace is rather funky in how this is done.
- If the parent wants to get the initial exec event of a child,
- it must set the ttrace event mask of the child to include execs.
- (The child cannot do this itself.) This must be done after the
- child is forked, but before it execs.
-
- To coordinate the parent and child, we implement a semaphore using
- pipes. After SETTRC'ing itself, the child tells the parent that
- it is now traceable by the parent, and waits for the parent's
- acknowledgement. The parent can then set the child's event mask,
- and notify the child that it can now exec.
-
- (The acknowledgement by parent happens as a result of a call to
- child_acknowledge_created_inferior.)
- */
-int
-parent_attach_all ()
-{
- int tt_status;
-
- /* We need a memory home for a constant, to pass it to ttrace.
- The value of the constant is arbitrary, so long as both
- parent and child use the same value. Might as well use the
- "magic" constant provided by ttrace...
- */
- uint64_t tc_magic_child = TT_VERSION;
- uint64_t tc_magic_parent = 0;
-
- tt_status = call_real_ttrace (
- TT_PROC_SETTRC,
- (int) TT_NIL,
- (lwpid_t) TT_NIL,
- TT_NIL,
- (TTRACE_ARG_TYPE) TT_VERSION,
- TT_NIL );
-
- if (tt_status < 0)
- return tt_status;
-
- /* Notify the parent that we're potentially ready to exec(). */
- write (startup_semaphore.child_channel[SEM_TALK],
- &tc_magic_child,
- sizeof (tc_magic_child));
-
- /* Wait for acknowledgement from the parent. */
- read (startup_semaphore.parent_channel[SEM_LISTEN],
- &tc_magic_parent,
- sizeof (tc_magic_parent));
-
- if (tc_magic_child != tc_magic_parent)
- warning ("mismatched semaphore magic");
-
- /* Discard our copy of the semaphore. */
- (void) close (startup_semaphore.parent_channel[SEM_LISTEN]);
- (void) close (startup_semaphore.parent_channel[SEM_TALK]);
- (void) close (startup_semaphore.child_channel[SEM_LISTEN]);
- (void) close (startup_semaphore.child_channel[SEM_TALK]);
-
- return tt_status;
-}
-
-/* Despite being file-local, this routine is dealing with
- * actual process IDs, not thread ids. That's because it's
- * called before the first "wait" call, and there's no map
- * yet from tids to pids.
- *
- * When it is called, a forked child is running, but waiting on
- * the semaphore. If you stop the child and re-start it,
- * things get confused, so don't do that! An attached child is
- * stopped.
- *
- * Since this is called after either attach or run, we
- * have to be the common part of both.
- */
-static void
-require_notification_of_events ( real_pid )
- int real_pid;
-{
- int tt_status;
- ttevent_t notifiable_events;
-
- lwpid_t tid;
- ttstate_t thread_state;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Require notif, pid is %d\n", real_pid );
-#endif
-
- /* Temporary HACK: tell inftarg.c/child_wait to not
- * loop until pids are the same.
- */
- not_same_real_pid = 0;
-
- sigemptyset (&notifiable_events.tte_signals);
- notifiable_events.tte_opts = TTEO_NONE;
-
- /* This ensures that forked children inherit their parent's
- * event mask, which we're setting here.
- *
- * NOTE: if you debug gdb with itself, then the ultimate
- * debuggee gets flags set by the outermost gdb, as
- * a child of a child will still inherit.
- */
- notifiable_events.tte_opts |= TTEO_PROC_INHERIT;
-
- notifiable_events.tte_events = TTEVT_DEFAULT;
- notifiable_events.tte_events |= TTEVT_SIGNAL;
- notifiable_events.tte_events |= TTEVT_EXEC;
- notifiable_events.tte_events |= TTEVT_EXIT;
- notifiable_events.tte_events |= TTEVT_FORK;
- notifiable_events.tte_events |= TTEVT_VFORK;
- notifiable_events.tte_events |= TTEVT_LWP_CREATE;
- notifiable_events.tte_events |= TTEVT_LWP_EXIT;
- notifiable_events.tte_events |= TTEVT_LWP_TERMINATE;
-
- tt_status = call_real_ttrace (
- TT_PROC_SET_EVENT_MASK,
- real_pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) &notifiable_events,
- (TTRACE_ARG_TYPE) sizeof (notifiable_events),
- TT_NIL);
-}
-
-static void
-require_notification_of_exec_events ( real_pid )
- int real_pid;
-{
- int tt_status;
- ttevent_t notifiable_events;
-
- lwpid_t tid;
- ttstate_t thread_state;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Require notif, pid is %d\n", real_pid );
-#endif
-
- /* Temporary HACK: tell inftarg.c/child_wait to not
- * loop until pids are the same.
- */
- not_same_real_pid = 0;
-
- sigemptyset (&notifiable_events.tte_signals);
- notifiable_events.tte_opts = TTEO_NOSTRCCHLD;
-
- /* This ensures that forked children don't inherit their parent's
- * event mask, which we're setting here.
- */
- notifiable_events.tte_opts &= ~TTEO_PROC_INHERIT;
-
- notifiable_events.tte_events = TTEVT_DEFAULT;
- notifiable_events.tte_events |= TTEVT_EXEC;
- notifiable_events.tte_events |= TTEVT_EXIT;
-
- tt_status = call_real_ttrace (
- TT_PROC_SET_EVENT_MASK,
- real_pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) &notifiable_events,
- (TTRACE_ARG_TYPE) sizeof (notifiable_events),
- TT_NIL);
-}
-
-
-/* This function is called by the parent process, with pid being the
- * ID of the child process, after the debugger has forked.
- */
-void
-child_acknowledge_created_inferior (pid)
- int pid;
-{
- /* We need a memory home for a constant, to pass it to ttrace.
- The value of the constant is arbitrary, so long as both
- parent and child use the same value. Might as well use the
- "magic" constant provided by ttrace...
- */
- uint64_t tc_magic_parent = TT_VERSION;
- uint64_t tc_magic_child = 0;
-
- /* Wait for the child to tell us that it has forked. */
- read (startup_semaphore.child_channel[SEM_LISTEN],
- &tc_magic_child,
- sizeof(tc_magic_child));
-
- /* Clear thread info now. We'd like to do this in
- * "require...", but that messes up attach.
- */
- clear_thread_info();
-
- /* Tell the "rest of gdb" that the initial thread exists.
- * This isn't really a hack. Other thread-based versions
- * of gdb (e.g. gnu-nat.c) seem to do the same thing.
- *
- * Q: Why don't we also add this thread to the local
- * list via "add_tthread"?
- *
- * A: Because we don't know the tid, and can't stop the
- * the process safely to ask what it is. Anyway, we'll
- * add it when it gets the EXEC event.
- */
- add_thread( pid ); /* in thread.c */
-
- /* We can now set the child's ttrace event mask.
- */
- require_notification_of_exec_events (pid);
-
- /* Tell ourselves that the process is running.
- */
- process_state = RUNNING;
-
- /* Notify the child that it can exec. */
- write (startup_semaphore.parent_channel[SEM_TALK],
- &tc_magic_parent,
- sizeof (tc_magic_parent));
-
- /* Discard our copy of the semaphore. */
- (void) close (startup_semaphore.parent_channel[SEM_LISTEN]);
- (void) close (startup_semaphore.parent_channel[SEM_TALK]);
- (void) close (startup_semaphore.child_channel[SEM_LISTEN]);
- (void) close (startup_semaphore.child_channel[SEM_TALK]);
-}
-
-
-/*
- * arrange for notification of all events by
- * calling require_notification_of_events.
- */
-void
-child_post_startup_inferior ( real_pid)
- int real_pid;
-{
- require_notification_of_events (real_pid);
-}
-
-/* From here on, we should expect tids rather than pids.
- */
-static void
-hppa_enable_catch_fork (tid)
- int tid;
-{
- int tt_status;
- ttevent_t ttrace_events;
-
- /* Get the set of events that are currently enabled.
- */
- tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL );
- if (errno)
- perror_with_name ("ttrace");
-
- /* Add forks to that set. */
- ttrace_events.tte_events |= TTEVT_FORK;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "enable fork, tid is %d\n", tid );
-#endif
-
- tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
- if (errno)
- perror_with_name ("ttrace");
-}
-
-
-static void
-hppa_disable_catch_fork (tid)
- int tid;
-{
- int tt_status;
- ttevent_t ttrace_events;
-
- /* Get the set of events that are currently enabled.
- */
- tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
-
- if (errno)
- perror_with_name ("ttrace");
-
- /* Remove forks from that set. */
- ttrace_events.tte_events &= ~TTEVT_FORK;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf("disable fork, tid is %d\n", tid );
-#endif
-
- tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
-
- if (errno)
- perror_with_name ("ttrace");
-}
-
-
-#if defined(CHILD_INSERT_FORK_CATCHPOINT)
-int
-child_insert_fork_catchpoint (tid)
- int tid;
-{
- /* Enable reporting of fork events from the kernel. */
- /* ??rehrauer: For the moment, we're always enabling these events,
- and just ignoring them if there's no catchpoint to catch them.
- */
- return 0;
-}
-#endif
-
-
-#if defined(CHILD_REMOVE_FORK_CATCHPOINT)
-int
-child_remove_fork_catchpoint (tid)
- int tid;
-{
- /* Disable reporting of fork events from the kernel. */
- /* ??rehrauer: For the moment, we're always enabling these events,
- and just ignoring them if there's no catchpoint to catch them.
- */
- return 0;
-}
-#endif
-
-
-static void
-hppa_enable_catch_vfork (tid)
- int tid;
-{
- int tt_status;
- ttevent_t ttrace_events;
-
- /* Get the set of events that are currently enabled.
- */
- tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
-
- if (errno)
- perror_with_name ("ttrace");
-
- /* Add vforks to that set. */
- ttrace_events.tte_events |= TTEVT_VFORK;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf("enable vfork, tid is %d\n", tid );
-#endif
-
- tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
-
- if (errno)
- perror_with_name ("ttrace");
-}
-
-
-static void
-hppa_disable_catch_vfork (tid)
- int tid;
-{
- int tt_status;
- ttevent_t ttrace_events;
-
- /* Get the set of events that are currently enabled. */
- tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
-
- if (errno)
- perror_with_name ("ttrace");
-
- /* Remove vforks from that set. */
- ttrace_events.tte_events &= ~TTEVT_VFORK;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf("disable vfork, tid is %d\n", tid );
-#endif
- tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
-
- if (errno)
- perror_with_name ("ttrace");
-}
-
-
-#if defined(CHILD_INSERT_VFORK_CATCHPOINT)
-int
-child_insert_vfork_catchpoint (tid)
- int tid;
-{
- /* Enable reporting of vfork events from the kernel. */
- /* ??rehrauer: For the moment, we're always enabling these events,
- and just ignoring them if there's no catchpoint to catch them.
- */
- return 0;
-}
-#endif
-
-
-#if defined(CHILD_REMOVE_VFORK_CATCHPOINT)
-int
-child_remove_vfork_catchpoint (tid)
- int tid;
-{
- /* Disable reporting of vfork events from the kernel. */
- /* ??rehrauer: For the moment, we're always enabling these events,
- and just ignoring them if there's no catchpoint to catch them.
- */
- return 0;
-}
-#endif
-
-#if defined(CHILD_HAS_FORKED)
-
-/* Q: Do we need to map the returned process ID to a thread ID?
- *
- * A: I don't think so--here we want a _real_ pid. Any later
- * operations will call "require_notification_of_events" and
- * start the mapping.
- */
-int
-child_has_forked (tid, childpid)
- int tid;
- int *childpid;
-{
- int tt_status;
- ttstate_t ttrace_state;
- thread_info * tinfo;
-
- /* Do we have cached thread state that we can consult? If so, use it. */
- tinfo = find_thread_info (map_from_gdb_tid (tid));
- if (tinfo != NULL) {
- copy_ttstate_t (&ttrace_state, &tinfo->last_stop_state);
- }
-
- /* Nope, must read the thread's current state */
- else
- {
- tt_status = call_ttrace (TT_LWP_GET_STATE,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_state,
- (TTRACE_ARG_TYPE) sizeof (ttrace_state),
- TT_NIL);
-
- if (errno)
- perror_with_name ("ttrace");
-
- if (tt_status < 0)
- return 0;
- }
-
- if (ttrace_state.tts_event & TTEVT_FORK)
- {
- *childpid = ttrace_state.tts_u.tts_fork.tts_fpid;
- return 1;
- }
-
- return 0;
-}
-#endif
-
-
-#if defined(CHILD_HAS_VFORKED)
-
-/* See child_has_forked for pid discussion.
- */
-int
-child_has_vforked (tid, childpid)
- int tid;
- int * childpid;
-{
- int tt_status;
- ttstate_t ttrace_state;
- thread_info * tinfo;
-
- /* Do we have cached thread state that we can consult? If so, use it. */
- tinfo = find_thread_info (map_from_gdb_tid (tid));
- if (tinfo != NULL)
- copy_ttstate_t (&ttrace_state, &tinfo->last_stop_state);
-
- /* Nope, must read the thread's current state */
- else
- {
- tt_status = call_ttrace (TT_LWP_GET_STATE,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_state,
- (TTRACE_ARG_TYPE) sizeof (ttrace_state),
- TT_NIL);
-
- if (errno)
- perror_with_name ("ttrace");
-
- if (tt_status < 0)
- return 0;
- }
-
- if (ttrace_state.tts_event & TTEVT_VFORK)
- {
- *childpid = ttrace_state.tts_u.tts_fork.tts_fpid;
- return 1;
- }
-
- return 0;
-}
-#endif
-
-
-#if defined(CHILD_CAN_FOLLOW_VFORK_PRIOR_TO_EXEC)
-int
-child_can_follow_vfork_prior_to_exec ()
-{
- /* ttrace does allow this.
-
- ??rehrauer: However, I had major-league problems trying to
- convince wait_for_inferior to handle that case. Perhaps when
- it is rewritten to grok multiple processes in an explicit way...
- */
- return 0;
-}
-#endif
-
-
-#if defined(CHILD_INSERT_EXEC_CATCHPOINT)
-int
-child_insert_exec_catchpoint (tid)
- int tid;
-{
- /* Enable reporting of exec events from the kernel. */
- /* ??rehrauer: For the moment, we're always enabling these events,
- and just ignoring them if there's no catchpoint to catch them.
- */
- return 0;
-}
-#endif
-
-
-#if defined(CHILD_REMOVE_EXEC_CATCHPOINT)
-int
-child_remove_exec_catchpoint (tid)
- int tid;
-{
- /* Disable reporting of execevents from the kernel. */
- /* ??rehrauer: For the moment, we're always enabling these events,
- and just ignoring them if there's no catchpoint to catch them.
- */
- return 0;
-}
-#endif
-
-
-#if defined(CHILD_HAS_EXECD)
-int
-child_has_execd (tid, execd_pathname)
- int tid;
- char ** execd_pathname;
-{
- int tt_status;
- ttstate_t ttrace_state;
- thread_info * tinfo;
-
- /* Do we have cached thread state that we can consult? If so, use it. */
- tinfo = find_thread_info (map_from_gdb_tid (tid));
- if (tinfo != NULL)
- copy_ttstate_t (&ttrace_state, &tinfo->last_stop_state);
-
- /* Nope, must read the thread's current state */
- else
- {
- tt_status = call_ttrace (TT_LWP_GET_STATE,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_state,
- (TTRACE_ARG_TYPE) sizeof (ttrace_state),
- TT_NIL);
-
- if (errno)
- perror_with_name ("ttrace");
-
- if (tt_status < 0)
- return 0;
- }
-
- if (ttrace_state.tts_event & TTEVT_EXEC)
- {
- /* See child_pid_to_exec_file in this file: this is a macro.
- */
- char * exec_file = target_pid_to_exec_file (tid);
-
- *execd_pathname = savestring (exec_file, strlen (exec_file));
- return 1;
- }
-
- return 0;
-}
-#endif
-
-
-#if defined(CHILD_HAS_SYSCALL_EVENT)
-int
-child_has_syscall_event (pid, kind, syscall_id)
- int pid;
- enum target_waitkind * kind;
- int * syscall_id;
-{
- int tt_status;
- ttstate_t ttrace_state;
- thread_info * tinfo;
-
- /* Do we have cached thread state that we can consult? If so, use it. */
- tinfo = find_thread_info (map_from_gdb_tid (pid));
- if (tinfo != NULL)
- copy_ttstate_t (&ttrace_state, &tinfo->last_stop_state);
-
- /* Nope, must read the thread's current state */
- else
- {
- tt_status = call_ttrace (TT_LWP_GET_STATE,
- pid,
- (TTRACE_ARG_TYPE) &ttrace_state,
- (TTRACE_ARG_TYPE) sizeof (ttrace_state),
- TT_NIL);
-
- if (errno)
- perror_with_name ("ttrace");
-
- if (tt_status < 0)
- return 0;
- }
-
- *kind = TARGET_WAITKIND_SPURIOUS; /* Until proven otherwise... */
- *syscall_id = -1;
-
- if (ttrace_state.tts_event & TTEVT_SYSCALL_ENTRY)
- *kind = TARGET_WAITKIND_SYSCALL_ENTRY;
- else if (ttrace_state.tts_event & TTEVT_SYSCALL_RETURN)
- *kind = TARGET_WAITKIND_SYSCALL_RETURN;
- else
- return 0;
-
- *syscall_id = ttrace_state.tts_scno;
- return 1;
-}
-#endif
-
-
-
-#if defined(CHILD_THREAD_ALIVE)
-
-/* Check to see if the given thread is alive.
- *
- * We'll trust the thread list, as the more correct
- * approach of stopping the process and spinning down
- * the OS's thread list is _very_ expensive.
- *
- * May need a FIXME for that reason.
- */
-int
-child_thread_alive (gdb_tid)
- lwpid_t gdb_tid;
-{
- lwpid_t tid;
-
- /* This spins down the lists twice.
- * Possible peformance improvement here!
- */
- tid = map_from_gdb_tid( gdb_tid );
- return !is_terminated( tid );
-}
-
-#endif
-
-
-
-/* This function attempts to read the specified number of bytes from the
- save_state_t that is our view into the hardware registers, starting at
- ss_offset, and ending at ss_offset + sizeof_buf - 1
-
- If this function succeeds, it deposits the fetched bytes into buf,
- and returns 0.
-
- If it fails, it returns a negative result. The contents of buf are
- undefined it this function fails.
- */
-int
-read_from_register_save_state (tid, ss_offset, buf, sizeof_buf)
- int tid;
- TTRACE_ARG_TYPE ss_offset;
- char * buf;
- int sizeof_buf;
-{
- int tt_status;
- register_value_t register_value = 0;
-
- tt_status = call_ttrace (TT_LWP_RUREGS,
- tid,
- ss_offset,
- (TTRACE_ARG_TYPE) sizeof_buf,
- (TTRACE_ARG_TYPE) buf);
-
- if( tt_status == 1 )
- /* Map ttrace's version of success to our version.
- * Sometime ttrace returns 0, but that's ok here.
- */
- return 0;
-
- return tt_status;
-}
-
-
-/* This function attempts to write the specified number of bytes to the
- save_state_t that is our view into the hardware registers, starting at
- ss_offset, and ending at ss_offset + sizeof_buf - 1
-
- If this function succeeds, it deposits the bytes in buf, and returns 0.
-
- If it fails, it returns a negative result. The contents of the save_state_t
- are undefined it this function fails.
- */
-int
-write_to_register_save_state (tid, ss_offset, buf, sizeof_buf)
- int tid;
- TTRACE_ARG_TYPE ss_offset;
- char * buf;
- int sizeof_buf;
-{
- int tt_status;
- register_value_t register_value = 0;
-
- tt_status = call_ttrace (TT_LWP_WUREGS,
- tid,
- ss_offset,
- (TTRACE_ARG_TYPE) sizeof_buf,
- (TTRACE_ARG_TYPE) buf);
- return tt_status;
-}
-
-
-/* This function is a sop to the largeish number of direct calls
- to call_ptrace that exist in other files. Rather than create
- functions whose name abstracts away from ptrace, and change all
- the present callers of call_ptrace, we'll do the expedient (and
- perhaps only practical) thing.
-
- Note HP-UX explicitly disallows a mix of ptrace & ttrace on a traced
- process. Thus, we must translate all ptrace requests into their
- process-specific, ttrace equivalents.
- */
-int
-call_ptrace (pt_request, gdb_tid, addr, data)
- int pt_request;
- int gdb_tid;
- PTRACE_ARG3_TYPE addr;
- int data;
-{
- ttreq_t tt_request;
- TTRACE_ARG_TYPE tt_addr = (TTRACE_ARG_TYPE) addr;
- TTRACE_ARG_TYPE tt_data = (TTRACE_ARG_TYPE) data;
- TTRACE_ARG_TYPE tt_addr2 = TT_NIL;
- int tt_status;
- register_value_t register_value;
- int read_buf;
-
- /* Perform the necessary argument translation. Note that some
- cases are funky enough in the ttrace realm that we handle them
- very specially.
- */
- switch (pt_request) {
- /* The following cases cannot conveniently be handled conveniently
- by merely adjusting the ptrace arguments and feeding into the
- generic call to ttrace at the bottom of this function.
-
- Note that because all branches of this switch end in "return",
- there's no need for any "break" statements.
- */
- case PT_SETTRC :
- return parent_attach_all ();
-
- case PT_RUREGS :
- tt_status = read_from_register_save_state (gdb_tid,
- tt_addr,
- &register_value,
- sizeof (register_value));
- if (tt_status < 0)
- return tt_status;
- return register_value;
-
- case PT_WUREGS :
- register_value = (int) tt_data;
- tt_status = write_to_register_save_state (gdb_tid,
- tt_addr,
- &register_value,
- sizeof (register_value));
- return tt_status;
- break;
-
- case PT_READ_I :
- tt_status = call_ttrace (TT_PROC_RDTEXT, /* Implicit 4-byte xfer becomes block-xfer. */
- gdb_tid,
- tt_addr,
- (TTRACE_ARG_TYPE) 4,
- (TTRACE_ARG_TYPE) &read_buf);
- if (tt_status < 0)
- return tt_status;
- return read_buf;
-
- case PT_READ_D :
- tt_status = call_ttrace (TT_PROC_RDDATA, /* Implicit 4-byte xfer becomes block-xfer. */
- gdb_tid,
- tt_addr,
- (TTRACE_ARG_TYPE) 4,
- (TTRACE_ARG_TYPE) &read_buf);
- if (tt_status < 0)
- return tt_status;
- return read_buf;
-
- case PT_ATTACH :
- tt_status = call_real_ttrace (TT_PROC_ATTACH,
- map_from_gdb_tid (gdb_tid),
- (lwpid_t) TT_NIL,
- tt_addr,
- (TTRACE_ARG_TYPE) TT_VERSION,
- tt_addr2);
- if (tt_status < 0)
- return tt_status;
- return tt_status;
-
- /* The following cases are handled by merely adjusting the ptrace
- arguments and feeding into the generic call to ttrace.
- */
- case PT_DETACH :
- tt_request = TT_PROC_DETACH;
- break;
-
- case PT_WRITE_I :
- tt_request = TT_PROC_WRTEXT; /* Translates 4-byte xfer to block-xfer. */
- tt_data = 4; /* This many bytes. */
- tt_addr2 = (TTRACE_ARG_TYPE) &data; /* Address of xfer source. */
- break;
-
- case PT_WRITE_D :
- tt_request = TT_PROC_WRDATA; /* Translates 4-byte xfer to block-xfer. */
- tt_data = 4; /* This many bytes. */
- tt_addr2 = (TTRACE_ARG_TYPE) &data; /* Address of xfer source. */
- break;
-
- case PT_RDTEXT :
- tt_request = TT_PROC_RDTEXT;
- break;
-
- case PT_RDDATA :
- tt_request = TT_PROC_RDDATA;
- break;
-
- case PT_WRTEXT :
- tt_request = TT_PROC_WRTEXT;
- break;
-
- case PT_WRDATA :
- tt_request = TT_PROC_WRDATA;
- break;
-
- case PT_CONTINUE :
- tt_request = TT_PROC_CONTINUE;
- break;
-
- case PT_STEP :
- tt_request = TT_LWP_SINGLE; /* Should not be making this request? */
- break;
-
- case PT_KILL :
- tt_request = TT_PROC_EXIT;
- break;
-
- case PT_GET_PROCESS_PATHNAME :
- tt_request = TT_PROC_GET_PATHNAME;
- break;
-
- default :
- tt_request = pt_request; /* Let ttrace be the one to complain. */
- break;
- }
-
- return call_ttrace (tt_request,
- gdb_tid,
- tt_addr,
- tt_data,
- tt_addr2);
-}
-
-/* Kill that pesky process!
- */
-void
-kill_inferior ()
-{
- int tid;
- int wait_status;
- thread_info * t;
- thread_info **paranoia;
- int para_count, i;
-
- if (inferior_pid == 0)
- return;
-
- /* Walk the list of "threads", some of which are "pseudo threads",
- aka "processes". For each that is NOT inferior_pid, stop it,
- and detach it.
-
- You see, we may not have just a single process to kill. If we're
- restarting or quitting or detaching just after the inferior has
- forked, then we've actually two processes to clean up.
-
- But we can't just call target_mourn_inferior() for each, since that
- zaps the target vector.
- */
-
- paranoia = (thread_info **) malloc( thread_head.count *
- sizeof(thread_info *));
- para_count = 0;
-
- t = thread_head.head;
- while (t) {
-
- paranoia[ para_count ] = t;
- for( i = 0; i < para_count; i++ ){
- if( t->next == paranoia[i] ) {
- warning( "Bad data in gdb's thread data; repairing." );
- t->next = 0;
- }
- }
- para_count++;
-
- if (t->am_pseudo && (t->pid != inferior_pid))
- {
- /* TT_PROC_STOP doesn't require a subsequent ttrace_wait, as it
- * generates no event.
- */
- call_ttrace (TT_PROC_STOP,
- t->pid,
- TT_NIL,
- TT_NIL,
- TT_NIL);
-
- call_ttrace (TT_PROC_DETACH,
- t->pid,
- TT_NIL,
- (TTRACE_ARG_TYPE) TARGET_SIGNAL_0,
- TT_NIL);
- }
- t = t->next;
- }
-
- free( paranoia );
-
- call_ttrace (TT_PROC_STOP,
- inferior_pid,
- TT_NIL,
- TT_NIL,
- TT_NIL);
- target_mourn_inferior ();
- clear_thread_info();
-}
-
-
-#ifndef CHILD_RESUME
-
-/* Sanity check a thread about to be continued.
- */
-static void
-thread_dropping_event_check( p )
- thread_info *p;
-{
- if( !p->handled ) {
- /*
- * This seems to happen when we "next" over a
- * "fork()" while following the parent. If it's
- * the FORK event, that's ok. If it's a SIGNAL
- * in the unfollowed child, that's ok to--but
- * how can we know that's what's going on?
- *
- * FIXME!
- */
- if( p->have_state ) {
- if( p->last_stop_state.tts_event == TTEVT_FORK ) {
- /* Ok */
- ;
- }
- else if( p->last_stop_state.tts_event == TTEVT_SIGNAL ) {
- /* Ok, close eyes and let it happen.
- */
- ;
- }
- else {
- /* This shouldn't happen--we're dropping a
- * real event.
- */
- warning( "About to continue process %d, thread %d with unhandled event %s.",
- p->pid, p->tid,
- get_printable_name_of_ttrace_event(
- p->last_stop_state.tts_event ));
-
-#ifdef PARANOIA
- if( debug_on )
- print_tthread( p );
-#endif
- }
- }
- else {
- /* No saved state, have to assume it failed.
- */
- warning( "About to continue process %d, thread %d with unhandled event.",
- p->pid, p->tid );
-#ifdef PARANOIA
- if( debug_on )
- print_tthread( p );
-#endif
- }
- }
-
-} /* thread_dropping_event_check */
-
-/* Use a loop over the threads to continue all the threads but
- * the one specified, which is to be stepped.
- */
-static void
-threads_continue_all_but_one( gdb_tid, signal )
- lwpid_t gdb_tid;
- int signal;
-{
- thread_info *p;
- int thread_signal;
- lwpid_t real_tid;
- lwpid_t scan_tid;
- ttstate_t state;
- int real_pid;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Using loop over threads to step/resume with signals\n" );
-#endif
-
- /* First update the thread list.
- */
- set_all_unseen();
- real_tid = map_from_gdb_tid( gdb_tid );
- real_pid = get_pid_for( real_tid );
-
- scan_tid = get_process_first_stopped_thread_id( real_pid, &state );
- while ( 0 != scan_tid ) {
-
-#ifdef THREAD_DEBUG
- /* FIX: later should check state is stopped;
- * state.tts_flags & TTS_STATEMASK == TTS_WASSUSPENDED
- */
- if( debug_on )
- if( state.tts_flags & TTS_STATEMASK != TTS_WASSUSPENDED )
- printf( "About to continue non-stopped thread %d\n", scan_tid );
-#endif
-
- p = find_thread_info( scan_tid );
- if( NULL == p ) {
- add_tthread( real_pid, scan_tid );
- p = find_thread_info( scan_tid );
-
- /* This is either a newly-created thread or the
- * result of a fork; in either case there's no
- * actual event to worry about.
- */
- p->handled = 1;
-
- if( state.tts_event != TTEVT_NONE ) {
- /* Oops, do need to worry!
- */
- warning( "Unexpected thread with \"%s\" event.",
- get_printable_name_of_ttrace_event( state.tts_event ));
- }
- }
- else if( scan_tid != p->tid )
- error( "Bad data in thread database." );
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- if( p->terminated )
- printf( "Why are we continuing a dead thread?\n" );
-#endif
-
- p->seen = 1;
-
- scan_tid = get_process_next_stopped_thread_id( real_pid, &state );
- }
-
- /* Remove unseen threads.
- */
- update_thread_list();
-
- /* Now run down the thread list and continue or step.
- */
- for( p = thread_head.head; p; p = p->next ) {
-
- /* Sanity check.
- */
- thread_dropping_event_check( p );
-
- /* Pass the correct signals along.
- */
- if( p->have_signal ) {
- thread_signal = p->signal_value;
- p->have_signal = 0;
- }
- else
- thread_signal = 0;
-
- if( p->tid != real_tid ) {
- /*
- * Not the thread of interest, so continue it
- * as the user expects.
- */
- if( p->stepping_mode == DO_STEP ) {
- /* Just step this thread.
- */
- call_ttrace(
- TT_LWP_SINGLE,
- p->tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( signal ),
- TT_NIL );
- }
- else {
- /* Regular continue (default case).
- */
- call_ttrace(
- TT_LWP_CONTINUE,
- p->tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( thread_signal ),
- TT_NIL );
- }
- }
- else {
- /* Step the thread of interest.
- */
- call_ttrace(
- TT_LWP_SINGLE,
- real_tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( signal ),
- TT_NIL );
- }
- } /* Loop over threads */
-} /* End threads_continue_all_but_one */
-
-/* Use a loop over the threads to continue all the threads.
- * This is done when a signal must be sent to any of the threads.
- */
-static void
-threads_continue_all_with_signals( gdb_tid, signal )
- lwpid_t gdb_tid;
- int signal;
-{
- thread_info *p;
- int thread_signal;
- lwpid_t real_tid;
- lwpid_t scan_tid;
- ttstate_t state;
- int real_pid;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Using loop over threads to resume with signals\n" );
-#endif
-
- /* Scan and update thread list.
- */
- set_all_unseen();
- real_tid = map_from_gdb_tid( gdb_tid );
- real_pid = get_pid_for( real_tid );
-
- scan_tid = get_process_first_stopped_thread_id( real_pid, &state );
- while ( 0 != scan_tid ) {
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- if( state.tts_flags & TTS_STATEMASK != TTS_WASSUSPENDED )
- warning( "About to continue non-stopped thread %d\n", scan_tid );
-#endif
-
- p = find_thread_info( scan_tid );
- if( NULL == p ) {
- add_tthread( real_pid, scan_tid );
- p = find_thread_info( scan_tid );
-
- /* This is either a newly-created thread or the
- * result of a fork; in either case there's no
- * actual event to worry about.
- */
- p->handled = 1;
-
- if( state.tts_event != TTEVT_NONE ) {
- /* Oops, do need to worry!
- */
- warning( "Unexpected thread with \"%s\" event.",
- get_printable_name_of_ttrace_event( state.tts_event ));
- }
- }
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- if( p->terminated )
- printf( "Why are we continuing a dead thread? (1)\n" );
-#endif
-
- p->seen = 1;
-
- scan_tid = get_process_next_stopped_thread_id( real_pid, &state );
- }
-
- /* Remove unseen threads from our list.
- */
- update_thread_list();
-
- /* Continue the threads.
- */
- for( p = thread_head.head; p; p = p->next ) {
-
- /* Sanity check.
- */
- thread_dropping_event_check( p );
-
- /* Pass the correct signals along.
- */
- if( p->tid == real_tid ) {
- thread_signal = signal;
- p->have_signal = 0;
- }
- else if( p->have_signal ) {
- thread_signal = p->signal_value;
- p->have_signal = 0;
- }
- else
- thread_signal = 0;
-
- if( p->stepping_mode == DO_STEP ) {
- call_ttrace(
- TT_LWP_SINGLE,
- p->tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( signal ),
- TT_NIL );
- }
- else {
- /* Continue this thread (default case).
- */
- call_ttrace(
- TT_LWP_CONTINUE,
- p->tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( thread_signal ),
- TT_NIL );
- }
- }
-} /* End threads_continue_all_with_signals */
-
-/* Step one thread only.
- */
-static void
-thread_fake_step( tid, signal )
- lwpid_t tid;
- enum target_signal signal;
-{
- thread_info *p;
-
-#ifdef THREAD_DEBUG
- if( debug_on ) {
- printf( "Doing a fake-step over a bpt, etc. for %d\n", tid );
-
- if( is_terminated( tid ))
- printf( "Why are we continuing a dead thread? (4)\n" );
- }
-#endif
-
- if( doing_fake_step )
- warning( "Step while step already in progress." );
-
- /* See if there's a saved signal value for this
- * thread to be passed on, but no current signal.
- */
- p = find_thread_info( tid );
- if( p != NULL ) {
- if( p->have_signal && signal == NULL ) {
- /* Pass on a saved signal.
- */
- signal = p->signal_value;
- }
-
- p->have_signal = 0;
- }
-
- if( !p->handled )
- warning( "Internal error: continuing unhandled thread." );
-
- call_ttrace( TT_LWP_SINGLE,
- tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host (signal),
- TT_NIL );
-
- /* Do bookkeeping so "call_ttrace_wait" knows it has to wait
- * for this thread only, and clear any saved signal info.
- */
- doing_fake_step = 1;
- fake_step_tid = tid;
-
-} /* End thread_fake_step */
-
-/* Continue one thread when a signal must be sent to it.
- */
-static void
-threads_continue_one_with_signal( gdb_tid, signal )
- lwpid_t gdb_tid;
- int signal;
-{
- thread_info *p;
- lwpid_t real_tid;
- int real_pid;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Continuing one thread with a signal\n" );
-#endif
-
- real_tid = map_from_gdb_tid( gdb_tid );
- real_pid = get_pid_for( real_tid );
-
- p = find_thread_info( real_tid );
- if( NULL == p ) {
- add_tthread( real_pid, real_tid );
- }
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- if( p->terminated )
- printf( "Why are we continuing a dead thread? (2)\n" );
-#endif
-
- if( !p->handled )
- warning( "Internal error: continuing unhandled thread." );
-
- p->have_signal = 0;
-
- call_ttrace( TT_LWP_CONTINUE,
- gdb_tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( signal ),
- TT_NIL );
-}
-#endif
-
-#ifndef CHILD_RESUME
-
-/* Resume execution of the inferior process.
- *
- * This routine is in charge of setting the "handled" bits.
- *
- * If STEP is zero, continue it.
- * If STEP is nonzero, single-step it.
- *
- * If SIGNAL is nonzero, give it that signal.
- *
- * If TID is -1, apply to all threads.
- * If TID is not -1, apply to specified thread.
- *
- * STEP
- * \ !0 0
- * TID \________________________________________________
- * |
- * -1 | Step current Continue all threads
- * | thread and (but which gets any
- * | continue others signal?--We look at
- * | "inferior_pid")
- * |
- * N | Step _this_ thread Continue _this_ thread
- * | and leave others and leave others
- * | stopped; internally stopped; used only for
- * | used by gdb, never hardware watchpoints
- * | a user command. and attach, never a
- * | user command.
- */
-void
-child_resume( gdb_tid, step, signal )
- lwpid_t gdb_tid;
- int step;
- enum target_signal signal;
-{
- int resume_all_threads;
- lwpid_t tid;
- process_state_t new_process_state;
-
- resume_all_threads =
- (gdb_tid == INFTTRACE_ALL_THREADS) ||
- (vfork_in_flight);
-
- if (resume_all_threads) {
- /* Resume all threads, but first pick a tid value
- * so we can get the pid when in call_ttrace doing
- * the map.
- */
- if (vfork_in_flight)
- tid = vforking_child_pid;
- else
- tid = map_from_gdb_tid( inferior_pid );
- }
- else
- tid = map_from_gdb_tid( gdb_tid );
-
-#ifdef THREAD_DEBUG
- if( debug_on ) {
- if( more_events_left )
- printf( "More events; " );
-
- if( signal != 0 )
- printf( "Sending signal %d; ", signal );
-
- if( resume_all_threads ) {
- if( step == 0 )
- printf( "Continue process %d\n", tid );
- else
- printf( "Step/continue thread %d\n", tid );
- }
- else {
- if( step == 0 )
- printf( "Continue thread %d\n", tid );
- else
- printf( "Step just thread %d\n", tid );
- }
-
- if( vfork_in_flight )
- printf( "Vfork in flight\n" );
- }
-#endif
-
- if( process_state == RUNNING )
- warning( "Internal error in resume logic; doing resume or step anyway." );
-
- if( !step /* Asked to continue... */
- && resume_all_threads /* whole process.. */
- && signal != 0 /* with a signal... */
- && more_events_left > 0 ) { /* but we can't yet--save it! */
-
- /* Continue with signal means we have to set the pending
- * signal value for this thread.
- */
- thread_info *k;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Saving signal %d for thread %d\n", signal, tid );
-#endif
-
- k = find_thread_info( tid );
- if( k != NULL ) {
- k->have_signal = 1;
- k->signal_value = signal;
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- if( k->terminated )
- printf( "Why are we continuing a dead thread? (3)\n" );
-#endif
-
- }
-
-#ifdef THREAD_DEBUG
- else if( debug_on ) {
- printf( "No thread info for tid %d\n", tid );
- }
-#endif
- }
-
- /* Are we faking this "continue" or "step"?
- *
- * We used to do steps by continuing all the threads for
- * which the events had been handled already. While
- * conceptually nicer (hides it all in a lower level), this
- * can lead to starvation and a hang (e.g. all but one thread
- * are unhandled at a breakpoint just before a "join" operation,
- * and one thread is in the join, and the user wants to step that
- * thread).
- */
- if( resume_all_threads /* Whole process, therefore user command */
- && more_events_left > 0 ) { /* But we can't do this yet--fake it! */
- thread_info *p;
-
- if( !step ) {
- /* No need to do any notes on a per-thread
- * basis--we're done!
- */
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Faking a process resume.\n" );
-#endif
-
- return;
- }
- else {
-
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Faking a process step.\n" );
-#endif
-
- }
-
- p = find_thread_info( tid );
- if( p == NULL ) {
- warning( "No thread information for tid %d, 'next' command ignored.\n", tid );
- return;
- }
- else {
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- if( p->terminated )
- printf( "Why are we continuing a dead thread? (3.5)\n" );
-#endif
-
- if( p->stepping_mode != DO_DEFAULT ) {
- warning( "Step or continue command applied to thread which is already stepping or continuing; command ignored." );
-
- return;
- }
-
- if( step )
- p->stepping_mode = DO_STEP;
- else
- p->stepping_mode = DO_CONTINUE;
-
- return;
- } /* Have thread info */
- } /* Must fake step or go */
-
- /* Execept for fake-steps, from here on we know we are
- * going to wind up with a running process which will
- * need a real wait.
- */
- new_process_state = RUNNING;
-
- /* An address of TT_USE_CURRENT_PC tells ttrace to continue from where
- * it was. (If GDB wanted it to start some other way, we have already
- * written a new PC value to the child.)
- *
- * If this system does not support PT_STEP, a higher level function will
- * have called single_step() to transmute the step request into a
- * continue request (by setting breakpoints on all possible successor
- * instructions), so we don't have to worry about that here.
- */
- if (step) {
- if( resume_all_threads ) {
- /*
- * Regular user step: other threads get a "continue".
- */
- threads_continue_all_but_one( tid, signal );
- clear_all_handled();
- clear_all_stepping_mode();
- }
-
- else {
- /* "Fake step": gdb is stepping one thread over a
- * breakpoint, watchpoint, or out of a library load
- * event, etc. The rest just stay where they are.
- *
- * Also used when there are pending events: we really
- * step the current thread, but leave the rest stopped.
- * Users can't request this, but "wait_for_inferior"
- * does--a lot!
- */
- thread_fake_step( tid, signal );
-
- /* Clear the "handled" state of this thread, because
- * we'll soon get a new event for it. Other events
- * stay as they were.
- */
- clear_handled( tid );
- clear_stepping_mode( tid );
- new_process_state = FAKE_STEPPING;
- }
- }
-
- else {
- /* TT_LWP_CONTINUE can pass signals to threads,
- * TT_PROC_CONTINUE can't. So if there are any
- * signals to pass, we have to use the (slower)
- * loop over the stopped threads.
- *
- * Equally, if we have to not continue some threads,
- * due to saved events, we have to use the loop.
- */
- if( (signal != 0) || saved_signals_exist()) {
- if( resume_all_threads ) {
-
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Doing a continue by loop of all threads\n" );
-#endif
-
- threads_continue_all_with_signals( tid, signal );
-
- clear_all_handled();
- clear_all_stepping_mode();
- }
-
- else {
-#ifdef THREAD_DEBUG
- printf( "Doing a continue w/signal of just thread %d\n", tid );
-#endif
-
- threads_continue_one_with_signal( tid, signal );
-
- /* Clear the "handled" state of this thread, because
- * we'll soon get a new event for it. Other events
- * can stay as they were.
- */
- clear_handled( tid );
- clear_stepping_mode( tid );
- }
- }
-
- else {
- /* No signals to send.
- */
- if( resume_all_threads ) {
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Doing a continue by process of process %d\n", tid );
-#endif
-
- if( more_events_left > 0 ) {
- warning( "Losing buffered events on continue." );
- more_events_left = 0;
- }
-
- call_ttrace( TT_PROC_CONTINUE,
- tid,
- TT_NIL,
- TT_NIL,
- TT_NIL );
-
- clear_all_handled();
- clear_all_stepping_mode();
- }
-
- else {
-#ifdef THREAD_DEBUG
- if( debug_on ) {
- printf( "Doing a continue of just thread %d\n", tid );
- if( is_terminated( tid ))
- printf( "Why are we continuing a dead thread? (5)\n" );
- }
-#endif
-
- call_ttrace( TT_LWP_CONTINUE,
- tid,
- TT_NIL,
- TT_NIL,
- TT_NIL );
-
- /* Clear the "handled" state of this thread, because
- * we'll soon get a new event for it. Other events
- * can stay as they were.
- */
- clear_handled( tid );
- clear_stepping_mode( tid );
- }
- }
- }
-
- process_state = new_process_state;
-
-#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Process set to %s\n",
- get_printable_name_of_process_state (process_state) );
-#endif
-
-}
-#endif /* CHILD_RESUME */
-
-
-#ifdef ATTACH_DETACH
-/*
- * Like it says.
- *
- * One worry is that we may not be attaching to "inferior_pid"
- * and thus may not want to clear out our data. FIXME?
- *
- */
-static void
-update_thread_state_after_attach( pid, kind_of_go )
- int pid;
- attach_continue_t kind_of_go;
-{
- int tt_status;
- ttstate_t thread_state;
- lwpid_t a_thread;
- lwpid_t tid;
-
- /* The process better be stopped.
- */
- if( process_state != STOPPED
- && process_state != VFORKING )
- warning( "Internal error attaching." );
-
- /* Clear out old tthread info and start over. This has the
- * side effect of ensuring that the TRAP is reported as being
- * in the right thread (re-mapped from tid to pid).
- *
- * It's because we need to add the tthread _now_ that we
- * need to call "clear_thread_info" _now_, and that's why
- * "require_notification_of_events" doesn't clear the thread
- * info (it's called later than this routine).
- */
- clear_thread_info();
- a_thread = 0;
-
- for (tid = get_process_first_stopped_thread_id (pid, &thread_state);
- tid != 0;
- tid = get_process_next_stopped_thread_id (pid, &thread_state))
- {
- thread_info *p;
-
- if (a_thread == 0)
- {
- a_thread = tid;
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Attaching to process %d, thread %d\n",
- pid, a_thread );
-#endif
- }
-
- /* Tell ourselves and the "rest of gdb" that this thread
- * exists.
- *
- * This isn't really a hack. Other thread-based versions
- * of gdb (e.g. gnu-nat.c) seem to do the same thing.
- *
- * We don't need to do mapping here, as we know this
- * is the first thread and thus gets the real pid
- * (and is "inferior_pid").
- *
- * NOTE: it probably isn't the originating thread,
- * but that doesn't matter (we hope!).
- */
- add_tthread( pid, tid );
- p = find_thread_info( tid );
- if( NULL == p ) /* ?We just added it! */
- error( "Internal error adding a thread on attach." );
-
- copy_ttstate_t( &p->last_stop_state, thread_state );
- p->have_state = 1;
-
- if( DO_ATTACH_CONTINUE == kind_of_go ) {
- /*
- * If we are going to CONTINUE afterwards,
- * raising a SIGTRAP, don't bother trying to
- * handle this event. But check first!
- */
- switch( p->last_stop_state.tts_event ) {
-
- case TTEVT_NONE:
- /* Ok to set this handled.
- */
- break;
-
- default:
- warning( "Internal error; skipping event %s on process %d, thread %d.",
- get_printable_name_of_ttrace_event(
- p->last_stop_state.tts_event ),
- p->pid, p->tid);
- }
-
- set_handled( pid, tid );
-
- }
- else {
- /* There will be no "continue" opertion, so the
- * process remains stopped. Don't set any events
- * handled except the "gimmies".
- */
- switch( p->last_stop_state.tts_event ) {
-
- case TTEVT_NONE:
- /* Ok to ignore this.
- */
- set_handled( pid, tid );
- break;
-
- case TTEVT_EXEC:
- case TTEVT_FORK:
- /* Expected "other" FORK or EXEC event from a
- * fork or vfork.
- */
- break;
-
- default:
- printf( "Internal error: failed to handle event %s on process %d, thread %d.",
- get_printable_name_of_ttrace_event(
- p->last_stop_state.tts_event ),
- p->pid, p->tid);
- }
- }
-
- add_thread( tid ); /* in thread.c */
- }
-
-#ifdef PARANOIA
- if( debug_on )
- print_tthreads();
-#endif
-
- /* One mustn't call ttrace_wait() after attaching via ttrace,
- 'cause the process is stopped already.
-
- However, the upper layers of gdb's execution control will
- want to wait after attaching (but not after forks, in
- which case they will be doing a "target_resume", anticipating
- a later TTEVT_EXEC or TTEVT_FORK event).
-
- To make this attach() implementation more compatible with
- others, we'll make the attached-to process raise a SIGTRAP.
-
- Issue: this continues only one thread. That could be
- dangerous if the thread is blocked--the process won't run
- and no trap will be raised. FIX! (check state.tts_flags?
- need one that's either TTS_WASRUNNING--but we've stopped
- it and made it TTS_WASSUSPENDED. Hum...FIXME!)
- */
- if( DO_ATTACH_CONTINUE == kind_of_go ) {
- tt_status = call_real_ttrace(
- TT_LWP_CONTINUE,
- pid,
- a_thread,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host (TARGET_SIGNAL_TRAP),
- TT_NIL);
- if (errno)
- perror_with_name ("ttrace");
-
- clear_handled( a_thread ); /* So TRAP will be reported. */
-
- /* Now running.
- */
- process_state = RUNNING;
- }
-
- attach_flag = 1;
-}
-#endif /* ATTACH_DETACH */
-
-
-#ifdef ATTACH_DETACH
-/* Start debugging the process whose number is PID.
- * (A _real_ pid).
- */
-int
-attach( pid )
- int pid;
-{
- int tt_status;
-
- tt_status = call_real_ttrace (
- TT_PROC_ATTACH,
- pid,
- (lwpid_t) TT_NIL,
- TT_NIL,
- (TTRACE_ARG_TYPE) TT_VERSION,
- TT_NIL);
- if (errno)
- perror_with_name ("ttrace attach");
-
- /* If successful, the process is now stopped.
- */
- process_state = STOPPED;
-
- /* Our caller ("attach_command" in "infcmd.c")
- * expects to do a "wait_for_inferior" after
- * the attach, so make sure the inferior is
- * running when we're done.
- */
- update_thread_state_after_attach( pid, DO_ATTACH_CONTINUE );
-
- return pid;
-}
-
-
-#if defined(CHILD_POST_ATTACH)
-void
-child_post_attach (pid)
- int pid;
-{
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "child-post-attach call\n" );
-#endif
-
- require_notification_of_events (pid);
-}
-#endif
-
-
-/* Stop debugging the process whose number is PID
- and continue it with signal number SIGNAL.
- SIGNAL = 0 means just continue it.
- */
-void
-detach( signal )
- int signal;
-{
- errno = 0;
- call_ttrace (TT_PROC_DETACH,
- inferior_pid,
- TT_NIL,
- (TTRACE_ARG_TYPE) signal,
- TT_NIL);
- attach_flag = 0;
-
- clear_thread_info();
-
- /* Process-state? */
-}
-#endif /* ATTACH_DETACH */
-
-
-/* Default the type of the ttrace transfer to int. */
-#ifndef TTRACE_XFER_TYPE
-#define TTRACE_XFER_TYPE int
-#endif
-
-void
-_initialize_kernel_u_addr ()
-{
-}
-
-#if !defined (CHILD_XFER_MEMORY)
-/* NOTE! I tried using TTRACE_READDATA, etc., to read and write memory
- in the NEW_SUN_TTRACE case.
- It ought to be straightforward. But it appears that writing did
- not write the data that I specified. I cannot understand where
- it got the data that it actually did write. */
-
-/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
- to debugger memory starting at MYADDR. Copy to inferior if
- WRITE is nonzero.
-
- Returns the length copied, which is either the LEN argument or zero.
- This xfer function does not do partial moves, since child_ops
- doesn't allow memory operations to cross below us in the target stack
- anyway. */
-
-int
-child_xfer_memory (memaddr, myaddr, len, write, target)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
- struct target_ops *target; /* ignored */
-{
- register int i;
- /* Round starting address down to longword boundary. */
- register CORE_ADDR addr = memaddr & - sizeof (TTRACE_XFER_TYPE);
- /* Round ending address up; get number of longwords that makes. */
- register int count
- = (((memaddr + len) - addr) + sizeof (TTRACE_XFER_TYPE) - 1)
- / sizeof (TTRACE_XFER_TYPE);
- /* Allocate buffer of that many longwords. */
- register TTRACE_XFER_TYPE *buffer
- = (TTRACE_XFER_TYPE *) alloca (count * sizeof (TTRACE_XFER_TYPE));
-
- if (write)
- {
- /* Fill start and end extra bytes of buffer with existing memory data. */
-
- if (addr != memaddr || len < (int) sizeof (TTRACE_XFER_TYPE)) {
- /* Need part of initial word -- fetch it. */
- buffer[0] = call_ttrace (TT_LWP_RDTEXT,
- inferior_pid,
- (TTRACE_ARG_TYPE) addr,
- TT_NIL,
- TT_NIL);
- }
-
- if (count > 1) /* FIXME, avoid if even boundary */
- {
- buffer[count - 1] = call_ttrace (TT_LWP_RDTEXT,
- inferior_pid,
- ((TTRACE_ARG_TYPE)
- (addr + (count - 1) * sizeof (TTRACE_XFER_TYPE))),
- TT_NIL,
- TT_NIL);
- }
-
- /* Copy data to be written over corresponding part of buffer */
-
- memcpy ((char *) buffer + (memaddr & (sizeof (TTRACE_XFER_TYPE) - 1)),
- myaddr,
- len);
-
- /* Write the entire buffer. */
-
- for (i = 0; i < count; i++, addr += sizeof (TTRACE_XFER_TYPE))
- {
- errno = 0;
- call_ttrace (TT_LWP_WRDATA,
- inferior_pid,
- (TTRACE_ARG_TYPE) addr,
- (TTRACE_ARG_TYPE) buffer[i],
- TT_NIL);
- if (errno)
- {
- /* Using the appropriate one (I or D) is necessary for
- Gould NP1, at least. */
- errno = 0;
- call_ttrace (TT_LWP_WRTEXT,
- inferior_pid,
- (TTRACE_ARG_TYPE) addr,
- (TTRACE_ARG_TYPE) buffer[i],
- TT_NIL);
- }
- if (errno)
- return 0;
- }
- }
- else
- {
- /* Read all the longwords */
- for (i = 0; i < count; i++, addr += sizeof (TTRACE_XFER_TYPE))
- {
- errno = 0;
- buffer[i] = call_ttrace (TT_LWP_RDTEXT,
- inferior_pid,
- (TTRACE_ARG_TYPE) addr,
- TT_NIL,
- TT_NIL);
- if (errno)
- return 0;
- QUIT;
- }
-
- /* Copy appropriate bytes out of the buffer. */
- memcpy (myaddr,
- (char *) buffer + (memaddr & (sizeof (TTRACE_XFER_TYPE) - 1)),
- len);
- }
- return len;
-}
-
-
-static void
-udot_info ()
-{
- int udot_off; /* Offset into user struct */
- int udot_val; /* Value from user struct at udot_off */
- char mess[128]; /* For messages */
-
- if (!target_has_execution)
- {
- error ("The program is not being run.");
- }
-
-#if !defined (KERNEL_U_SIZE)
-
- /* Adding support for this command is easy. Typically you just add a
- routine, called "kernel_u_size" that returns the size of the user
- struct, to the appropriate *-nat.c file and then add to the native
- config file "#define KERNEL_U_SIZE kernel_u_size()" */
- error ("Don't know how large ``struct user'' is in this version of gdb.");
-
-#else
-
- for (udot_off = 0; udot_off < KERNEL_U_SIZE; udot_off += sizeof (udot_val))
- {
- if ((udot_off % 24) == 0)
- {
- if (udot_off > 0)
- {
- printf_filtered ("\n");
- }
- printf_filtered ("%04x:", udot_off);
- }
- udot_val = call_ttrace (TT_LWP_RUREGS,
- inferior_pid,
- (TTRACE_ARG_TYPE) udot_off,
- TT_NIL,
- TT_NIL);
- if (errno != 0)
- {
- sprintf (mess, "\nreading user struct at offset 0x%x", udot_off);
- perror_with_name (mess);
- }
- /* Avoid using nonportable (?) "*" in print specs */
- printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val);
- }
- printf_filtered ("\n");
-
-#endif
-}
-#endif /* !defined (CHILD_XFER_MEMORY). */
-
-/* TTrace version of "target_pid_to_exec_file"
- */
-char *
-child_pid_to_exec_file (tid)
- int tid;
-{
- static char exec_file_buffer[1024];
- int tt_status;
- CORE_ADDR top_of_stack;
- char four_chars[4];
- int name_index;
- int i;
- int done;
- int saved_inferior_pid;
-
- /* As of 10.x HP-UX, there's an explicit request to get the
- *pathname.
- */
- tt_status = call_ttrace (TT_PROC_GET_PATHNAME,
- tid,
- (TTRACE_ARG_TYPE) exec_file_buffer,
- (TTRACE_ARG_TYPE) sizeof (exec_file_buffer) - 1,
- TT_NIL);
- if (tt_status >= 0)
- return exec_file_buffer;
-
- /* ??rehrauer: The above request may or may not be broken. It
- doesn't seem to work when I use it. But, it may be designed
- to only work immediately after an exec event occurs. (I'm
- waiting for COSL to explain.)
-
- In any case, if it fails, try a really, truly amazingly gross
- hack that DDE uses, of pawing through the process' data
- segment to find the pathname.
- */
- top_of_stack = 0x7b03a000;
- name_index = 0;
- done = 0;
-
- /* On the chance that pid != inferior_pid, set inferior_pid
- to pid, so that (grrrr!) implicit uses of inferior_pid get
- the right id.
- */
- saved_inferior_pid = inferior_pid;
- inferior_pid = tid;
-
- /* Try to grab a null-terminated string. */
- while (! done) {
- if (target_read_memory (top_of_stack, four_chars, 4) != 0)
- {
- inferior_pid = saved_inferior_pid;
- return NULL;
- }
- for (i = 0; i < 4; i++) {
- exec_file_buffer[name_index++] = four_chars[i];
- done = (four_chars[i] == '\0');
- if (done)
- break;
- }
- top_of_stack += 4;
- }
-
- if (exec_file_buffer[0] == '\0')
- {
- inferior_pid = saved_inferior_pid;
- return NULL;
- }
-
- inferior_pid = saved_inferior_pid;
- return exec_file_buffer;
-}
-
-
-void
-pre_fork_inferior ()
-{
- int status;
-
- status = pipe (startup_semaphore.parent_channel);
- if (status < 0) {
- warning ("error getting parent pipe for startup semaphore");
- return;
- }
-
- status = pipe (startup_semaphore.child_channel);
- if (status < 0) {
- warning ("error getting child pipe for startup semaphore");
- return;
- }
-}
-
-/* Called via #define REQUIRE_ATTACH from inftarg.c,
- * ultimately from "follow_inferior_fork" in infrun.c,
- * itself called from "resume".
- *
- * This seems to be intended to attach after a fork or
- * vfork, while "attach" is used to attach to a pid
- * given by the user. The check for an existing attach
- * seems odd--it always fails in our test system.
- */
-int
-hppa_require_attach (pid)
- int pid;
-{
- int tt_status;
- CORE_ADDR pc;
- CORE_ADDR pc_addr;
- unsigned int regs_offset;
- process_state_t old_process_state = process_state;
-
- /* Are we already attached? There appears to be no explicit
- * way to answer this via ttrace, so we try something which
- * should be innocuous if we are attached. If that fails,
- * then we assume we're not attached, and so attempt to make
- * it so.
- */
- errno = 0;
- tt_status = call_real_ttrace (TT_PROC_STOP,
- pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) TT_NIL,
- (TTRACE_ARG_TYPE) TT_NIL,
- TT_NIL);
-
- if (errno)
- {
- /* No change to process-state!
- */
- errno = 0;
- pid = attach (pid);
- }
- else
- {
- /* If successful, the process is now stopped. But if
- * we're VFORKING, the parent is still running, so don't
- * change the process state.
- */
- if( process_state != VFORKING )
- process_state = STOPPED;
-
- /* If we were already attached, you'd think that we
- * would need to start going again--but you'd be wrong,
- * as the fork-following code is actually in the middle
- * of the "resume" routine in in "infrun.c" and so
- * will (almost) immediately do a resume.
- *
- * On the other hand, if we are VFORKING, which means
- * that the child and the parent share a process for a
- * while, we know that "resume" won't be resuming
- * until the child EXEC event is seen. But we still
- * don't want to continue, as the event is already
- * there waiting.
- */
- update_thread_state_after_attach( pid, DONT_ATTACH_CONTINUE );
- } /* STOP succeeded */
-
- return pid;
-}
-
-int
-hppa_require_detach (pid, signal)
- int pid;
- int signal;
-{
- int tt_status;
-
- /* If signal is non-zero, we must pass the signal on to the active
- thread prior to detaching. We do this by continuing the threads
- with the signal.
- */
- if (signal != 0)
- {
- errno = 0;
- threads_continue_all_with_signals( pid, signal );
- }
-
- errno = 0;
- tt_status = call_ttrace (TT_PROC_DETACH,
- pid,
- TT_NIL,
- TT_NIL,
- TT_NIL);
-
- errno = 0; /* Ignore any errors. */
-
- /* process_state? */
-
- return pid;
-}
-
-#if defined(HPPA_GET_PROCESS_EVENTS)
-process_event_vector
-hppa_get_process_events (pid, wait_status, must_continue_pid_after)
- int pid;
- int wait_status;
- int * must_continue_pid_after;
-{
- int tt_status;
- ttstate_t ttrace_state;
- process_event_vector events = PEVT_NONE;
-
- /* This is always 1 with ptrace. */
- *must_continue_pid_after = 0;
-
- errno = 0;
- tt_status = call_ttrace (TT_LWP_GET_STATE,
- pid,
- (TTRACE_ARG_TYPE) &ttrace_state,
- (TTRACE_ARG_TYPE) sizeof (ttrace_state),
- TT_NIL);
- if (errno)
- perror_with_name ("ttrace");
- if (tt_status < 0)
- return 0;
-
- if (ttrace_state.tts_event & TTEVT_SIGNAL)
- events |= PEVT_SIGNAL;
- if (ttrace_state.tts_event & TTEVT_FORK)
- events |= PEVT_FORK;
- if (ttrace_state.tts_event & TTEVT_VFORK)
- events |= PEVT_VFORK;
- if (ttrace_state.tts_event & TTEVT_EXEC)
- events |= PEVT_EXEC;
- if (ttrace_state.tts_event & TTEVT_EXIT)
- events |= PEVT_EXIT;
-
- return events;
-}
-#endif /* HPPA_GET_PROCESS_EVENTS */
-
-
-/* Given the starting address of a memory page, hash it to a bucket in
- the memory page dictionary.
- */
-static int
-get_dictionary_bucket_of_page (page_start)
- CORE_ADDR page_start;
-{
- int hash;
-
- hash = (page_start / memory_page_dictionary.page_size);
- hash = hash % MEMORY_PAGE_DICTIONARY_BUCKET_COUNT;
-
- return hash;
-}
-
-
-/* Given a memory page's starting address, get (i.e., find an existing
- or create a new) dictionary entry for the page. The page will be
- write-protected when this function returns, but may have a reference
- count of 0 (if the page was newly-added to the dictionary).
- */
-static memory_page_t *
-get_dictionary_entry_of_page (pid, page_start)
- int pid;
- CORE_ADDR page_start;
-{
- int bucket;
- memory_page_t * page = NULL;
- memory_page_t * previous_page = NULL;
-
- /* We're going to be using the dictionary now, than-kew. */
- require_memory_page_dictionary (pid);
-
- /* Try to find an existing dictionary entry for this page. Hash
- on the page's starting address.
- */
- bucket = get_dictionary_bucket_of_page (page_start);
- page = &memory_page_dictionary.buckets[bucket];
- while (page != NULL)
- {
- if (page->page_start == page_start)
- break;
- previous_page = page;
- page = page->next;
- }
-
- /* Did we find a dictionary entry for this page? If not, then
- add it to the dictionary now.
- */
- if (page == NULL)
- {
- /* Create a new entry. */
- page = (memory_page_t *) xmalloc (sizeof (memory_page_t));
- page->page_start = page_start;
- page->reference_count = 0;
- page->next = NULL;
- page->previous = NULL;
-
- /* We'll write-protect the page now, if that's allowed. */
- page->original_permissions = write_protect_page (pid, page_start);
-
- /* Add the new entry to the dictionary. */
- page->previous = previous_page;
- previous_page->next = page;
-
- memory_page_dictionary.page_count++;
- }
-
- return page;
-}
-
-
-static void
-remove_dictionary_entry_of_page (pid, page)
- int pid;
- memory_page_t * page;
-{
- /* Restore the page's original permissions. */
- unwrite_protect_page (pid, page->page_start, page->original_permissions);
-
- /* Kick the page out of the dictionary. */
- if (page->previous != NULL)
- page->previous->next = page->next;
- if (page->next != NULL)
- page->next->previous = page->previous;
-
- /* Just in case someone retains a handle to this after it's freed. */
- page->page_start = (CORE_ADDR) 0;
-
- memory_page_dictionary.page_count--;
-
- free (page);
-}
-
-
-static void
-hppa_enable_syscall_events (pid)
- int pid;
-{
- int tt_status;
- ttevent_t ttrace_events;
-
- /* Get the set of events that are currently enabled. */
- tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- pid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
- if (errno)
- perror_with_name ("ttrace");
-
- /* Add syscall events to that set. */
- ttrace_events.tte_events |= TTEVT_SYSCALL_ENTRY;
- ttrace_events.tte_events |= TTEVT_SYSCALL_RETURN;
-
- tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- pid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
- if (errno)
- perror_with_name ("ttrace");
-}
-
-
-static void
-hppa_disable_syscall_events (pid)
- int pid;
-{
- int tt_status;
- ttevent_t ttrace_events;
-
- /* Get the set of events that are currently enabled. */
- tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- pid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
- if (errno)
- perror_with_name ("ttrace");
-
- /* Remove syscall events from that set. */
- ttrace_events.tte_events &= ~TTEVT_SYSCALL_ENTRY;
- ttrace_events.tte_events &= ~TTEVT_SYSCALL_RETURN;
-
- tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- pid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
- if (errno)
- perror_with_name ("ttrace");
-}
-
-
-/* The address range beginning with START and ending with START+LEN-1
- (inclusive) is to be watched via page-protection by a new watchpoint.
- Set protection for all pages that overlap that range.
-
- Note that our caller sets TYPE to:
- 0 for a bp_hardware_watchpoint,
- 1 for a bp_read_watchpoint,
- 2 for a bp_access_watchpoint
-
- (Yes, this is intentionally (though lord only knows why) different
- from the TYPE that is passed to hppa_remove_hw_watchpoint.)
- */
-int
-hppa_insert_hw_watchpoint (pid, start, len, type)
- int pid;
- CORE_ADDR start;
- LONGEST len;
- int type;
-{
- CORE_ADDR page_start;
- int dictionary_was_empty;
- int page_size;
- int page_id;
- LONGEST range_size_in_pages;
-
- if (type != 0)
- error ("read or access hardware watchpoints not supported on HP-UX");
-
- /* Examine all pages in the address range. */
- require_memory_page_dictionary ();
-
- dictionary_was_empty = (memory_page_dictionary.page_count == (LONGEST) 0);
-
- page_size = memory_page_dictionary.page_size;
- page_start = (start / page_size) * page_size;
- range_size_in_pages = ((LONGEST) len + (LONGEST) page_size - 1) / (LONGEST) page_size;
-
- for (page_id=0; page_id < range_size_in_pages; page_id++, page_start+=page_size)
- {
- memory_page_t * page;
-
- /* This gets the page entered into the dictionary if it was
- not already entered.
- */
- page = get_dictionary_entry_of_page (pid, page_start);
- page->reference_count++;
- }
-
- /* Our implementation depends on seeing calls to kernel code, for the
- following reason. Here we ask to be notified of syscalls.
-
- When a protected page is accessed by user code, HP-UX raises a SIGBUS.
- Fine.
-
- But when kernel code accesses the page, it doesn't give a SIGBUS.
- Rather, the system call that touched the page fails, with errno=EFAULT.
- Not good for us.
-
- We could accomodate this "feature" by asking to be notified of syscall
- entries & exits; upon getting an entry event, disabling page-protections;
- upon getting an exit event, reenabling page-protections and then checking
- if any watchpoints triggered.
-
- However, this turns out to be a real performance loser. syscalls are
- usually a frequent occurrence. Having to unprotect-reprotect all watched
- pages, and also to then read all watched memory locations and compare for
- triggers, can be quite expensive.
-
- Instead, we'll only ask to be notified of syscall exits. When we get
- one, we'll check whether errno is set. If not, or if it's not EFAULT,
- we can just continue the inferior.
-
- If errno is set upon syscall exit to EFAULT, we must perform some fairly
- hackish stuff to determine whether the failure really was due to a
- page-protect trap on a watched location.
- */
- if (dictionary_was_empty)
- hppa_enable_syscall_events (pid);
-}
-
-
-/* The address range beginning with START and ending with START+LEN-1
- (inclusive) was being watched via page-protection by a watchpoint
- which has been removed. Remove protection for all pages that
- overlap that range, which are not also being watched by other
- watchpoints.
- */
-int
-hppa_remove_hw_watchpoint (pid, start, len, type)
- int pid;
- CORE_ADDR start;
- LONGEST len;
- enum bptype type;
-{
- CORE_ADDR page_start;
- int dictionary_is_empty;
- int page_size;
- int page_id;
- LONGEST range_size_in_pages;
-
- if (type != 0)
- error ("read or access hardware watchpoints not supported on HP-UX");
-
- /* Examine all pages in the address range. */
- require_memory_page_dictionary ();
-
- page_size = memory_page_dictionary.page_size;
- page_start = (start / page_size) * page_size;
- range_size_in_pages = ((LONGEST) len + (LONGEST) page_size - 1) / (LONGEST) page_size;
-
- for (page_id=0; page_id < range_size_in_pages; page_id++, page_start+=page_size)
- {
- memory_page_t * page;
-
- page = get_dictionary_entry_of_page (pid, page_start);
- page->reference_count--;
-
- /* Was this the last reference of this page? If so, then we
- must scrub the entry from the dictionary, and also restore
- the page's original permissions.
- */
- if (page->reference_count == 0)
- remove_dictionary_entry_of_page (pid, page);
- }
-
- dictionary_is_empty = (memory_page_dictionary.page_count == (LONGEST) 0);
-
- /* If write protections are currently disallowed, then that implies that
- wait_for_inferior believes that the inferior is within a system call.
- Since we want to see both syscall entry and return, it's clearly not
- good to disable syscall events in this state!
-
- ??rehrauer: Yeah, it'd be better if we had a specific flag that said,
- "inferior is between syscall events now". Oh well.
- */
- if (dictionary_is_empty && memory_page_dictionary.page_protections_allowed)
- hppa_disable_syscall_events (pid);
-}
-
-
-/* Could we implement a watchpoint of this type via our available
- hardware support?
-
- This query does not consider whether a particular address range
- could be so watched, but just whether support is generally available
- for such things. See hppa_range_profitable_for_hw_watchpoint for a
- query that answers whether a particular range should be watched via
- hardware support.
- */
-int
-hppa_can_use_hw_watchpoint (type, cnt, ot)
- enum bptype type;
- int cnt;
- enum bptype ot;
-{
- return (type == bp_hardware_watchpoint);
-}
-
-
-/* Assuming we could set a hardware watchpoint on this address, do
- we think it would be profitable ("a good idea") to do so? If not,
- we can always set a regular (aka single-step & test) watchpoint
- on the address...
- */
-int
-hppa_range_profitable_for_hw_watchpoint (pid, start, len)
- int pid;
- CORE_ADDR start;
- LONGEST len;
-{
- int range_is_stack_based;
- int range_is_accessible;
- CORE_ADDR page_start;
- int page_size;
- int page;
- LONGEST range_size_in_pages;
-
- /* ??rehrauer: For now, say that all addresses are potentially
- profitable. Possibly later we'll want to test the address
- for "stackness"?
- */
- range_is_stack_based = 0;
-
- /* If any page in the range is inaccessible, then we cannot
- really use hardware watchpointing, even though our client
- thinks we can. In that case, it's actually an error to
- attempt to use hw watchpoints, so we'll tell our client
- that the range is "unprofitable", and hope that they listen...
- */
- range_is_accessible = 1; /* Until proven otherwise. */
-
- /* Examine all pages in the address range. */
- errno = 0;
- page_size = sysconf (_SC_PAGE_SIZE);
-
- /* If we can't determine page size, we're hosed. Tell our
- client it's unprofitable to use hw watchpoints for this
- range.
- */
- if (errno || (page_size <= 0))
- {
- errno = 0;
- return 0;
- }
-
- page_start = (start / page_size) * page_size;
- range_size_in_pages = len / (LONGEST)page_size;
-
- for (page=0; page < range_size_in_pages; page++, page_start+=page_size)
- {
- int tt_status;
- int page_permissions;
-
- /* Is this page accessible? */
- errno = 0;
- tt_status = call_ttrace (TT_PROC_GET_MPROTECT,
- pid,
- (TTRACE_ARG_TYPE) page_start,
- TT_NIL,
- (TTRACE_ARG_TYPE) &page_permissions);
- if (errno || (tt_status < 0))
- {
- errno = 0;
- range_is_accessible = 0;
- break;
- }
-
- /* Yes, go for another... */
- }
-
- return (! range_is_stack_based && range_is_accessible);
-}
-
-
-char *
-hppa_pid_or_tid_to_str (id)
- pid_t id;
-{
- static char buf[100]; /* Static because address returned. */
-
- /* Does this appear to be a process? If so, print it that way. */
- if (is_process_id (id))
- return hppa_pid_to_str (id);
-
- /* Else, print both the GDB thread number and the system thread id. */
- sprintf (buf, "thread %d (", pid_to_thread_id (id));
- strcat (buf, hppa_tid_to_str (id));
- strcat (buf, ")\0");
-
- return buf;
-}
-
-
-/* If the current pid is not the pid this module reported
- * from "proc_wait" with the most recent event, then the
- * user has switched threads.
- *
- * If the last reported event was a breakpoint, then return
- * the old thread id, else return 0.
- */
-pid_t
-hppa_switched_threads( gdb_pid )
- pid_t gdb_pid;
-{
- if( gdb_pid == old_gdb_pid ) {
- /*
- * Core gdb is working with the same pid that it
- * was before we reported the last event. This
- * is ok: e.g. we reported hitting a thread-specific
- * breakpoint, but we were reporting the wrong
- * thread, so the core just ignored the event.
- *
- * No thread switch has happened.
- */
- return (pid_t) 0;
- }
- else if( gdb_pid == reported_pid ) {
- /*
- * Core gdb is working with the pid we reported, so
- * any continue or step will be able to figure out
- * that it needs to step over any hit breakpoints
- * without our (i.e. PREPARE_TO_PROCEED's) help.
- */
- return (pid_t) 0;
- }
- else if( !reported_bpt ) {
- /*
- * The core switched, but we didn't just report a
- * breakpoint, so there's no just-hit breakpoint
- * instruction at "reported_pid"'s PC, and thus there
- * is no need to step over it.
- */
- return (pid_t) 0;
- }
- else {
- /* There's been a real switch, and we reported
- * a hit breakpoint. Let "hppa_prepare_to_proceed"
- * know, so it can see whether the breakpoint is
- * still active.
- */
- return reported_pid;
- }
-
- /* Keep compiler happy with an obvious return at the end.
- */
- return (pid_t) 0;
-}
-
-void
-hppa_ensure_vforking_parent_remains_stopped (pid)
- int pid;
-{
- /* Nothing to do when using ttrace. Only the ptrace-based implementation
- must do real work.
- */
-}
-
-
-int
-hppa_resume_execd_vforking_child_to_get_parent_vfork ()
-{
- return 0; /* No, the parent vfork is available now. */
-}
-
-
-
-void
-_initialize_infttrace ()
-{
- /* Initialize the ttrace-based hardware watchpoint implementation. */
- memory_page_dictionary.page_count = (LONGEST) -1;
- memory_page_dictionary.page_protections_allowed = 1;
-
- errno = 0;
- memory_page_dictionary.page_size = sysconf (_SC_PAGE_SIZE);
-
- if (errno || (memory_page_dictionary.page_size <= 0))
- perror_with_name ("sysconf");
-}
-