diff options
Diffstat (limited to 'gdb/infttrace.c')
| -rw-r--r-- | gdb/infttrace.c | 5711 |
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 (¬ifiable_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) ¬ifiable_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 (¬ifiable_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) ¬ifiable_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, - ®ister_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, - ®ister_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"); -} - |