1 /* Low level Unix child interface to ttrace, for GDB when running under HP-UX.
2 Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "gdb_string.h"
30 #include "gdbthread.h"
32 /* We need pstat functionality so that we can get the exec file
33 for a process we attach to.
35 According to HP, we should use the 64bit interfaces, so we
36 define _PSTAT64 to achieve this. */
38 #include <sys/pstat.h>
40 /* Some hackery to work around a use of the #define name NO_FLAGS
41 * in both gdb and HPUX (bfd.h and /usr/include/machine/vmparam.h).
44 #define INFTTRACE_TEMP_HACK NO_FLAGS
49 #include <sys/types.h>
52 #include <sys/param.h>
55 #include <sys/ioctl.h>
57 #include <sys/ttrace.h>
61 #ifdef PTRACE_IN_WRONG_PLACE
64 #include <sys/ptrace.h>
66 #endif /* NO_PTRACE_H */
68 /* Second half of the hackery above. Non-ANSI C, so
69 * we can't use "#error", alas.
72 #if (NO_FLAGS != INFTTRACE_TEMP_HACK )
73 /* #error "Hackery to remove warning didn't work right" */
75 /* Ok, new def'n of NO_FLAGS is same as old one; no action needed. */
78 /* #error "Didn't get expected re-definition of NO_FLAGS" */
79 #define NO_FLAGS INFTTRACE_TEMP_HACK
82 #if !defined (PT_SETTRC)
83 #define PT_SETTRC 0 /* Make process traceable by parent */
85 #if !defined (PT_READ_I)
86 #define PT_READ_I 1 /* Read word from text space */
88 #if !defined (PT_READ_D)
89 #define PT_READ_D 2 /* Read word from data space */
91 #if !defined (PT_READ_U)
92 #define PT_READ_U 3 /* Read word from kernel user struct */
94 #if !defined (PT_WRITE_I)
95 #define PT_WRITE_I 4 /* Write word to text space */
97 #if !defined (PT_WRITE_D)
98 #define PT_WRITE_D 5 /* Write word to data space */
100 #if !defined (PT_WRITE_U)
101 #define PT_WRITE_U 6 /* Write word to kernel user struct */
103 #if !defined (PT_CONTINUE)
104 #define PT_CONTINUE 7 /* Continue after signal */
106 #if !defined (PT_STEP)
107 #define PT_STEP 9 /* Set flag for single stepping */
109 #if !defined (PT_KILL)
110 #define PT_KILL 8 /* Send child a SIGKILL signal */
114 #define PT_ATTACH PTRACE_ATTACH
117 #define PT_DETACH PTRACE_DETACH
122 #include <sys/file.h>
125 /* This semaphore is used to coordinate the child and parent processes
126 after a fork(), and before an exec() by the child. See parent_attach_all
131 int parent_channel[2]; /* Parent "talks" to [1], child "listens" to [0] */
132 int child_channel[2]; /* Child "talks" to [1], parent "listens" to [0] */
137 #define SEM_LISTEN (0)
139 static startup_semaphore_t startup_semaphore;
141 /* See can_touch_threads_of_process for details. */
142 static int vforking_child_pid = 0;
143 static int vfork_in_flight = 0;
145 /* 1 if ok as results of a ttrace or ttrace_wait call, 0 otherwise.
147 #define TT_OK( _status, _errno ) \
148 (((_status) == 1) && ((_errno) == 0))
150 #define TTRACE_ARG_TYPE uint64_t
152 /* When supplied as the "addr" operand, ttrace interprets this
153 to mean, "from the current address".
155 #define TT_USE_CURRENT_PC ((TTRACE_ARG_TYPE) TT_NOPC)
157 /* When supplied as the "addr", "data" or "addr2" operand for most
158 requests, ttrace interprets this to mean, "pay no heed to this
161 #define TT_NIL ((TTRACE_ARG_TYPE) TT_NULLARG)
163 /* This is capable of holding the value of a 32-bit register. The
164 value is always left-aligned in the buffer; i.e., [0] contains
165 the most-significant byte of the register's value, and [sizeof(reg)]
166 contains the least-significant value.
168 ??rehrauer: Yes, this assumes that an int is 32-bits on HP-UX, and
169 that registers are 32-bits on HP-UX. The latter assumption changes
172 typedef int register_value_t;
174 /********************************************************************
180 The rest of GDB sees threads as being things with different
181 "pid" (process id) values. See "thread.c" for details. The
182 separate threads will be seen and reacted to if infttrace passes
183 back different pid values (for _events_). See wait_for_inferior
186 So infttrace is going to use thread ids externally, pretending
187 they are process ids, and keep track internally so that it can
188 use the real process id (and thread id) when calling ttrace.
190 The data structure that supports this is a linked list of the
191 current threads. Since at some date infttrace will have to
192 deal with multiple processes, each list element records its
193 corresponding pid, rather than having a single global.
195 Note that the list is only approximately current; that's ok, as
196 it's up to date when we need it (we hope!). Also, it can contain
197 dead threads, as there's no harm if it does.
199 The approach taken here is to bury the translation from external
200 to internal inside "call_ttrace" and a few other places.
202 There are some wrinkles:
204 o When GDB forks itself to create the debug target process,
205 there's only a pid of 0 around in the child, so the
206 TT_PROC_SETTRC operation uses a more direct call to ttrace;
207 Similiarly, the initial setting of the event mask happens
208 early as well, and so is also special-cased, and an attach
211 o We define an unthreaded application as having a "pseudo"
214 o To keep from confusing the rest of GDB, we don't switch
215 the PID for the pseudo thread to a TID. A table will help:
217 Rest of GDB sees these PIDs: pid tid1 tid2 tid3 ...
219 Our thread list stores: pid pid pid pid ...
222 Ttrace sees these TIDS: tid0 tid1 tid2 tid3 ...
224 Both pid and tid0 will map to tid0, as there are infttrace.c-internal
225 calls to ttrace using tid0.
229 Since we're implementing the "stop the world" model, sub-model
230 "other threads run during step", we have some stuff to do:
232 o User steps require continuing all threads other than the
233 one the user is stepping;
235 o Internal debugger steps (such as over a breakpoint or watchpoint,
236 but not out of a library load thunk) require stepping only
237 the selected thread; this means that we have to report the
238 step finish on that thread, which can lead to complications;
240 o When a thread is created, it is created running, rather
241 than stopped--so we have to stop it.
243 The OS doesn't guarantee the stopped thread list will be stable,
244 no does it guarantee where on the stopped thread list a thread
245 that is single-stepped will wind up: it's possible that it will
246 be off the list for a while, it's possible the step will complete
247 and it will be re-posted to the end...
249 This means we have to scan the stopped thread list, build up
250 a work-list, and then run down the work list; we can't do the
251 step/continue during the scan.
255 Then there's the issue of waiting for an event. We do this by
256 noticing how many events are reported at the end of each wait.
257 From then on, we "fake" all resumes and steps, returning instantly,
258 and don't do another wait. Once all pending events are reported,
259 we can really resume again.
261 To keep this hidden, all the routines which know about tids and
262 pids or real events and simulated ones are static (file-local).
264 This code can make lots of calls to ttrace, in particular it
265 can spin down the list of thread states more than once. If this
266 becomes a performance hit, the spin could be done once and the
267 various "tsp" blocks saved, keeping all later spins in this
270 The O/S doesn't promise to keep the list straight, and so we must
271 re-scan a lot. By observation, it looks like a single-step/wait
272 puts the stepped thread at the end of the list but doesn't change
275 ****************************************************************
278 /* Uncomment these to turn on various debugging output */
279 /* #define THREAD_DEBUG */
280 /* #define WAIT_BUFFER_DEBUG */
281 /* #define PARANOIA */
284 #define INFTTRACE_ALL_THREADS (-1)
285 #define INFTTRACE_STEP (1)
286 #define INFTTRACE_CONTINUE (0)
288 /* FIX: this is used in inftarg.c/child_wait, in a hack.
290 extern int not_same_real_pid;
292 /* This is used to count buffered events.
294 static unsigned int more_events_left = 0;
298 typedef enum process_state_enum
302 FAKE_CONTINUE, /* For later use */
309 static process_state_t process_state = STOPPED;
311 /* User-specified stepping modality.
313 typedef enum stepping_mode_enum
315 DO_DEFAULT, /* ...which is a continue! */
321 /* Action to take on an attach, depends on
322 * what kind (user command, fork, vfork).
324 * At the moment, this is either:
326 * o continue with a SIGTRAP signal, or
330 typedef enum attach_continue_enum
337 /* This flag is true if we are doing a step-over-bpt
338 * with buffered events. We will have to be sure to
339 * report the right thread, as otherwise the spaghetti
340 * code in "infrun.c/wait_for_inferior" will get
343 static int doing_fake_step = 0;
344 static lwpid_t fake_step_tid = 0;
347 /****************************************************
348 * Thread information structure routines and types. *
349 ****************************************************
352 struct thread_info_struct
354 int am_pseudo; /* This is a pseudo-thread for the process. */
355 int pid; /* Process ID */
356 lwpid_t tid; /* Thread ID */
357 int handled; /* 1 if a buffered event was handled. */
358 int seen; /* 1 if this thread was seen on a traverse. */
359 int terminated; /* 1 if thread has terminated. */
360 int have_signal; /* 1 if signal to be sent */
361 enum target_signal signal_value; /* Signal to send */
362 int have_start; /* 1 if alternate starting address */
363 stepping_mode_t stepping_mode; /* Whether to step or continue */
364 CORE_ADDR start; /* Where to start */
365 int have_state; /* 1 if the event state has been set */
366 ttstate_t last_stop_state; /* The most recently-waited event for this thread. */
367 struct thread_info_struct
368 *next; /* All threads are linked via this field. */
369 struct thread_info_struct
370 *next_pseudo; /* All pseudo-threads are linked via this field. */
375 struct thread_info_header_struct
379 thread_info *head_pseudo;
384 static thread_info_header thread_head =
386 static thread_info_header deleted_threads =
389 static ptid_t saved_real_ptid;
392 /*************************************************
393 * Debugging support functions *
394 *************************************************
397 get_raw_pc (lwpid_t ttid)
399 unsigned long pc_val;
403 offset = register_addr (PC_REGNUM, U_REGS_OFFSET);
404 res = read_from_register_save_state (
406 (TTRACE_ARG_TYPE) offset,
411 return (CORE_ADDR) pc_val;
415 return (CORE_ADDR) 0;
420 get_printable_name_of_stepping_mode (stepping_mode_t mode)
429 return "DO_CONTINUE";
431 return "?unknown mode?";
435 /* This function returns a pointer to a string describing the
436 * ttrace event being reported.
439 get_printable_name_of_ttrace_event (ttevents_t event)
441 /* This enumeration is "gappy", so don't use a table. */
448 return "TTEVT_SIGNAL";
456 return "TTEVT_VFORK";
457 case TTEVT_SYSCALL_RETURN:
458 return "TTEVT_SYSCALL_RETURN";
459 case TTEVT_LWP_CREATE:
460 return "TTEVT_LWP_CREATE";
461 case TTEVT_LWP_TERMINATE:
462 return "TTEVT_LWP_TERMINATE";
464 return "TTEVT_LWP_EXIT";
465 case TTEVT_LWP_ABORT_SYSCALL:
466 return "TTEVT_LWP_ABORT_SYSCALL";
467 case TTEVT_SYSCALL_ENTRY:
468 return "TTEVT_SYSCALL_ENTRY";
469 case TTEVT_SYSCALL_RESTART:
470 return "TTEVT_SYSCALL_RESTART";
472 return "?new event?";
477 /* This function translates the ttrace request enumeration into
478 * a character string that is its printable (aka "human readable")
482 get_printable_name_of_ttrace_request (ttreq_t request)
484 if (!IS_TTRACE_REQ (request))
487 /* This enumeration is "gappy", so don't use a table. */
491 return "TT_PROC_SETTRC";
493 return "TT_PROC_ATTACH";
495 return "TT_PROC_DETACH";
497 return "TT_PROC_RDTEXT";
499 return "TT_PROC_WRTEXT";
501 return "TT_PROC_RDDATA";
503 return "TT_PROC_WRDATA";
505 return "TT_PROC_STOP";
506 case TT_PROC_CONTINUE:
507 return "TT_PROC_CONTINUE";
508 case TT_PROC_GET_PATHNAME:
509 return "TT_PROC_GET_PATHNAME";
510 case TT_PROC_GET_EVENT_MASK:
511 return "TT_PROC_GET_EVENT_MASK";
512 case TT_PROC_SET_EVENT_MASK:
513 return "TT_PROC_SET_EVENT_MASK";
514 case TT_PROC_GET_FIRST_LWP_STATE:
515 return "TT_PROC_GET_FIRST_LWP_STATE";
516 case TT_PROC_GET_NEXT_LWP_STATE:
517 return "TT_PROC_GET_NEXT_LWP_STATE";
519 return "TT_PROC_EXIT";
520 case TT_PROC_GET_MPROTECT:
521 return "TT_PROC_GET_MPROTECT";
522 case TT_PROC_SET_MPROTECT:
523 return "TT_PROC_SET_MPROTECT";
524 case TT_PROC_SET_SCBM:
525 return "TT_PROC_SET_SCBM";
527 return "TT_LWP_STOP";
528 case TT_LWP_CONTINUE:
529 return "TT_LWP_CONTINUE";
531 return "TT_LWP_SINGLE";
533 return "TT_LWP_RUREGS";
535 return "TT_LWP_WUREGS";
536 case TT_LWP_GET_EVENT_MASK:
537 return "TT_LWP_GET_EVENT_MASK";
538 case TT_LWP_SET_EVENT_MASK:
539 return "TT_LWP_SET_EVENT_MASK";
540 case TT_LWP_GET_STATE:
541 return "TT_LWP_GET_STATE";
548 /* This function translates the process state enumeration into
549 * a character string that is its printable (aka "human readable")
553 get_printable_name_of_process_state (process_state_t process_state)
555 switch (process_state)
560 return "FAKE_STEPPING";
568 return "?some unknown state?";
572 /* Set a ttrace thread state to a safe, initial state.
575 clear_ttstate_t (ttstate_t *tts)
579 tts->tts_user_tid = 0;
580 tts->tts_event = TTEVT_NONE;
583 /* Copy ttrace thread state TTS_FROM into TTS_TO.
586 copy_ttstate_t (ttstate_t *tts_to, ttstate_t *tts_from)
588 memcpy ((char *) tts_to, (char *) tts_from, sizeof (*tts_to));
591 /* Are there any live threads we know about?
594 any_thread_records (void)
596 return (thread_head.count > 0);
599 /* Create, fill in and link in a thread descriptor.
602 create_thread_info (int pid, lwpid_t tid)
606 int thread_count_of_pid;
608 new_p = xmalloc (sizeof (thread_info));
611 new_p->have_signal = 0;
612 new_p->have_start = 0;
613 new_p->have_state = 0;
614 clear_ttstate_t (&new_p->last_stop_state);
615 new_p->am_pseudo = 0;
618 new_p->terminated = 0;
620 new_p->next_pseudo = NULL;
621 new_p->stepping_mode = DO_DEFAULT;
623 if (0 == thread_head.count)
627 printf ("First thread, pid %d tid %d!\n", pid, tid);
629 saved_real_ptid = inferior_ptid;
635 printf ("Subsequent thread, pid %d tid %d\n", pid, tid);
639 /* Another day, another thread...
643 /* The new thread always goes at the head of the list.
645 new_p->next = thread_head.head;
646 thread_head.head = new_p;
648 /* Is this the "pseudo" thread of a process? It is if there's
649 * no other thread for this process on the list. (Note that this
650 * accomodates multiple processes, such as we see even for simple
651 * cases like forking "non-threaded" programs.)
653 p = thread_head.head;
654 thread_count_of_pid = 0;
657 if (p->pid == new_p->pid)
658 thread_count_of_pid++;
662 /* Did we see any other threads for this pid? (Recall that we just
663 * added this thread to the list...)
665 if (thread_count_of_pid == 1)
667 new_p->am_pseudo = 1;
668 new_p->next_pseudo = thread_head.head_pseudo;
669 thread_head.head_pseudo = new_p;
675 /* Get rid of our thread info.
678 clear_thread_info (void)
685 printf ("Clearing all thread info\n");
688 p = thread_head.head;
696 thread_head.head = NULL;
697 thread_head.head_pseudo = NULL;
698 thread_head.count = 0;
700 p = deleted_threads.head;
708 deleted_threads.head = NULL;
709 deleted_threads.head_pseudo = NULL;
710 deleted_threads.count = 0;
712 /* No threads, so can't have pending events.
714 more_events_left = 0;
717 /* Given a tid, find the thread block for it.
720 find_thread_info (lwpid_t tid)
724 for (p = thread_head.head; p; p = p->next)
732 for (p = deleted_threads.head; p; p = p->next)
743 /* For any but the pseudo thread, this maps to the
744 * thread ID. For the pseudo thread, if you pass either
745 * the thread id or the PID, you get the pseudo thread ID.
747 * We have to be prepared for core gdb to ask about
748 * deleted threads. We do the map, but we don't like it.
751 map_from_gdb_tid (lwpid_t gdb_tid)
755 /* First assume gdb_tid really is a tid, and try to find a
756 * matching entry on the threads list.
758 for (p = thread_head.head; p; p = p->next)
760 if (p->tid == gdb_tid)
764 /* It doesn't appear to be a tid; perhaps it's really a pid?
765 * Try to find a "pseudo" thread entry on the threads list.
767 for (p = thread_head.head_pseudo; p != NULL; p = p->next_pseudo)
769 if (p->pid == gdb_tid)
773 /* Perhaps it's the tid of a deleted thread we may still
774 * have some knowledge of?
776 for (p = deleted_threads.head; p; p = p->next)
778 if (p->tid == gdb_tid)
782 /* Or perhaps it's the pid of a deleted process we may still
785 for (p = deleted_threads.head_pseudo; p != NULL; p = p->next_pseudo)
787 if (p->pid == gdb_tid)
791 return 0; /* Error? */
794 /* Map the other way: from a real tid to the
795 * "pid" known by core gdb. This tid may be
796 * for a thread that just got deleted, so we
797 * also need to consider deleted threads.
800 map_to_gdb_tid (lwpid_t real_tid)
804 for (p = thread_head.head; p; p = p->next)
806 if (p->tid == real_tid)
815 for (p = deleted_threads.head; p; p = p->next)
817 if (p->tid == real_tid)
819 return p->pid; /* Error? */
824 return 0; /* Error? Never heard of this thread! */
827 /* Do any threads have saved signals?
830 saved_signals_exist (void)
834 for (p = thread_head.head; p; p = p->next)
845 /* Is this the tid for the zero-th thread?
848 is_pseudo_thread (lwpid_t tid)
850 thread_info *p = find_thread_info (tid);
851 if (NULL == p || p->terminated)
857 /* Is this thread terminated?
860 is_terminated (lwpid_t tid)
862 thread_info *p = find_thread_info (tid);
865 return p->terminated;
870 /* Is this pid a real PID or a TID?
873 is_process_id (int pid)
880 /* What does PID really represent?
882 tid = map_from_gdb_tid (pid);
884 return 0; /* Actually, is probably an error... */
886 tinfo = find_thread_info (tid);
888 /* Does it appear to be a true thread?
890 if (!tinfo->am_pseudo)
893 /* Else, it looks like it may be a process. See if there's any other
894 * threads with the same process ID, though. If there are, then TID
895 * just happens to be the first thread of several for this process.
897 this_pid = tinfo->pid;
899 for (tinfo = thread_head.head; tinfo; tinfo = tinfo->next)
901 if (tinfo->pid == this_pid)
905 return (this_pid_count == 1);
909 /* Add a thread to our info. Prevent duplicate entries.
912 add_tthread (int pid, lwpid_t tid)
916 p = find_thread_info (tid);
918 p = create_thread_info (pid, tid);
923 /* Notice that a thread was deleted.
926 del_tthread (lwpid_t tid)
931 if (thread_head.count <= 0)
933 error ("Internal error in thread database.");
938 for (p = thread_head.head; p; p = p->next)
945 printf ("Delete here: %d \n", tid);
951 * Deleting a main thread is ok if we're doing
952 * a parent-follow on a child; this is odd but
953 * not wrong. It apparently _doesn't_ happen
954 * on the child-follow, as we don't just delete
955 * the pseudo while keeping the rest of the
956 * threads around--instead, we clear out the whole
957 * thread list at once.
960 thread_info *q_chase;
963 for (q = thread_head.head_pseudo; q; q = q->next)
967 /* Remove from pseudo list.
970 thread_head.head_pseudo = p->next_pseudo;
972 q_chase->next = p->next_pseudo;
979 /* Remove from live list.
984 thread_head.head = p->next;
986 chase->next = p->next;
988 /* Add to deleted thread list.
990 p->next = deleted_threads.head;
991 deleted_threads.head = p;
992 deleted_threads.count++;
995 p->next_pseudo = deleted_threads.head_pseudo;
996 deleted_threads.head_pseudo = p;
1008 /* Get the pid for this tid. (Has to be a real TID!).
1011 get_pid_for (lwpid_t tid)
1015 for (p = thread_head.head; p; p = p->next)
1023 for (p = deleted_threads.head; p; p = p->next)
1034 /* Note that this thread's current event has been handled.
1037 set_handled (int pid, lwpid_t tid)
1041 p = find_thread_info (tid);
1043 p = add_tthread (pid, tid);
1048 /* Was this thread's current event handled?
1051 was_handled (lwpid_t tid)
1055 p = find_thread_info (tid);
1059 return 0; /* New threads have not been handled */
1062 /* Set this thread to unhandled.
1065 clear_handled (lwpid_t tid)
1069 #ifdef WAIT_BUFFER_DEBUG
1071 printf ("clear_handled %d\n", (int) tid);
1074 p = find_thread_info (tid);
1076 error ("Internal error: No thread state to clear?");
1081 /* Set all threads to unhandled.
1084 clear_all_handled (void)
1088 #ifdef WAIT_BUFFER_DEBUG
1090 printf ("clear_all_handled\n");
1093 for (p = thread_head.head; p; p = p->next)
1098 for (p = deleted_threads.head; p; p = p->next)
1104 /* Set this thread to default stepping mode.
1107 clear_stepping_mode (lwpid_t tid)
1111 #ifdef WAIT_BUFFER_DEBUG
1113 printf ("clear_stepping_mode %d\n", (int) tid);
1116 p = find_thread_info (tid);
1118 error ("Internal error: No thread state to clear?");
1120 p->stepping_mode = DO_DEFAULT;
1123 /* Set all threads to do default continue on resume.
1126 clear_all_stepping_mode (void)
1130 #ifdef WAIT_BUFFER_DEBUG
1132 printf ("clear_all_stepping_mode\n");
1135 for (p = thread_head.head; p; p = p->next)
1137 p->stepping_mode = DO_DEFAULT;
1140 for (p = deleted_threads.head; p; p = p->next)
1142 p->stepping_mode = DO_DEFAULT;
1146 /* Set all threads to unseen on this pass.
1149 set_all_unseen (void)
1153 for (p = thread_head.head; p; p = p->next)
1159 #if (defined( THREAD_DEBUG ) || defined( PARANOIA ))
1160 /* debugging routine.
1163 print_tthread (thread_info *p)
1165 printf (" Thread pid %d, tid %d", p->pid, p->tid);
1167 printf (", event is %s",
1168 get_printable_name_of_ttrace_event (p->last_stop_state.tts_event));
1171 printf (", pseudo thread");
1174 printf (", have signal 0x%x", p->signal_value);
1177 printf (", have start at 0x%x", p->start);
1179 printf (", step is %s", get_printable_name_of_stepping_mode (p->stepping_mode));
1182 printf (", handled");
1184 printf (", not handled");
1189 printf (", not seen");
1195 print_tthreads (void)
1199 if (thread_head.count == 0)
1200 printf ("Thread list is empty\n");
1203 printf ("Thread list has ");
1204 if (thread_head.count == 1)
1205 printf ("1 entry:\n");
1207 printf ("%d entries:\n", thread_head.count);
1208 for (p = thread_head.head; p; p = p->next)
1214 if (deleted_threads.count == 0)
1215 printf ("Deleted thread list is empty\n");
1218 printf ("Deleted thread list has ");
1219 if (deleted_threads.count == 1)
1220 printf ("1 entry:\n");
1222 printf ("%d entries:\n", deleted_threads.count);
1224 for (p = deleted_threads.head; p; p = p->next)
1232 /* Update the thread list based on the "seen" bits.
1235 update_thread_list (void)
1241 for (p = thread_head.head; p; p = p->next)
1243 /* Is this an "unseen" thread which really happens to be a process?
1244 If so, is it inferior_ptid and is a vfork in flight? If yes to
1245 all, then DON'T REMOVE IT! We're in the midst of moving a vfork
1246 operation, which is a multiple step thing, to the point where we
1247 can touch the parent again. We've most likely stopped to examine
1248 the child at a late stage in the vfork, and if we're not following
1249 the child, we'd best not treat the parent as a dead "thread"...
1251 if ((!p->seen) && p->am_pseudo && vfork_in_flight
1252 && (p->pid != vforking_child_pid))
1262 printf ("Delete unseen thread: %d \n", p->tid);
1264 del_tthread (p->tid);
1271 /************************************************
1272 * O/S call wrappers *
1273 ************************************************
1276 /* This function simply calls ttrace with the given arguments.
1277 * It exists so that all calls to ttrace are isolated. All
1278 * parameters should be as specified by "man 2 ttrace".
1280 * No other "raw" calls to ttrace should exist in this module.
1283 call_real_ttrace (ttreq_t request, pid_t pid, lwpid_t tid, TTRACE_ARG_TYPE addr,
1284 TTRACE_ARG_TYPE data, TTRACE_ARG_TYPE addr2)
1289 tt_status = ttrace (request, pid, tid, addr, data, addr2);
1294 /* Don't bother for a known benign error: if you ask for the
1295 * first thread state, but there is only one thread and it's
1296 * not stopped, ttrace complains.
1298 * We have this inside the #ifdef because our caller will do
1299 * this check for real.
1301 if (request != TT_PROC_GET_FIRST_LWP_STATE
1305 printf ("TT fail for %s, with pid %d, tid %d, status %d \n",
1306 get_printable_name_of_ttrace_request (request),
1307 pid, tid, tt_status);
1313 /* ??rehrauer: It would probably be most robust to catch and report
1314 * failed requests here. However, some clients of this interface
1315 * seem to expect to catch & deal with them, so we'd best not.
1319 strcpy (reason_for_failure, "ttrace (");
1320 strcat (reason_for_failure, get_printable_name_of_ttrace_request (request));
1321 strcat (reason_for_failure, ")");
1322 printf ("ttrace error, errno = %d\n", errno);
1323 perror_with_name (reason_for_failure);
1331 /* This function simply calls ttrace_wait with the given arguments.
1332 * It exists so that all calls to ttrace_wait are isolated.
1334 * No "raw" calls to ttrace_wait should exist elsewhere.
1337 call_real_ttrace_wait (int pid, lwpid_t tid, ttwopt_t option, ttstate_t *tsp,
1341 thread_info *tinfo = NULL;
1344 ttw_status = ttrace_wait (pid, tid, option, tsp, tsp_size);
1350 printf ("TW fail with pid %d, tid %d \n", pid, tid);
1353 perror_with_name ("ttrace wait");
1360 /* A process may have one or more kernel threads, of which all or
1361 none may be stopped. This function returns the ID of the first
1362 kernel thread in a stopped state, or 0 if none are stopped.
1364 This function can be used with get_process_next_stopped_thread_id
1365 to iterate over the IDs of all stopped threads of this process.
1368 get_process_first_stopped_thread_id (int pid, ttstate_t *thread_state)
1372 tt_status = call_real_ttrace (TT_PROC_GET_FIRST_LWP_STATE,
1375 (TTRACE_ARG_TYPE) thread_state,
1376 (TTRACE_ARG_TYPE) sizeof (*thread_state),
1381 if (errno == EPROTO)
1383 /* This is an error we can handle: there isn't any stopped
1384 * thread. This happens when we're re-starting the application
1385 * and it has only one thread. GET_NEXT handles the case of
1386 * no more stopped threads well; GET_FIRST doesn't. (A ttrace
1394 perror_with_name ("ttrace");
1402 return thread_state->tts_lwpid;
1406 /* This function returns the ID of the "next" kernel thread in a
1407 stopped state, or 0 if there are none. "Next" refers to the
1408 thread following that of the last successful call to this
1409 function or to get_process_first_stopped_thread_id, using
1410 the value of thread_state returned by that call.
1412 This function can be used with get_process_first_stopped_thread_id
1413 to iterate over the IDs of all stopped threads of this process.
1416 get_process_next_stopped_thread_id (int pid, ttstate_t *thread_state)
1420 tt_status = call_real_ttrace (
1421 TT_PROC_GET_NEXT_LWP_STATE,
1424 (TTRACE_ARG_TYPE) thread_state,
1425 (TTRACE_ARG_TYPE) sizeof (*thread_state),
1428 perror_with_name ("ttrace");
1435 else if (tt_status == 0)
1437 /* End of list, no next state. Don't return the
1438 * tts_lwpid, as it's a meaningless "240".
1440 * This is an HPUX "feature".
1445 return thread_state->tts_lwpid;
1448 /* ??rehrauer: Eventually this function perhaps should be calling
1449 pid_to_thread_id. However, that function currently does nothing
1450 for HP-UX. Even then, I'm not clear whether that function
1451 will return a "kernel" thread ID, or a "user" thread ID. If
1452 the former, we can just call it here. If the latter, we must
1453 map from the "user" tid to a "kernel" tid.
1455 NOTE: currently not called.
1458 get_active_tid_of_pid (int pid)
1460 ttstate_t thread_state;
1462 return get_process_first_stopped_thread_id (pid, &thread_state);
1465 /* This function returns 1 if tt_request is a ttrace request that
1466 * operates upon all threads of a (i.e., the entire) process.
1469 is_process_ttrace_request (ttreq_t tt_request)
1471 return IS_TTRACE_PROCREQ (tt_request);
1475 /* This function translates a thread ttrace request into
1476 * the equivalent process request for a one-thread process.
1479 make_process_version (ttreq_t request)
1481 if (!IS_TTRACE_REQ (request))
1483 error ("Internal error, bad ttrace request made\n");
1490 return TT_PROC_STOP;
1492 case TT_LWP_CONTINUE:
1493 return TT_PROC_CONTINUE;
1495 case TT_LWP_GET_EVENT_MASK:
1496 return TT_PROC_GET_EVENT_MASK;
1498 case TT_LWP_SET_EVENT_MASK:
1499 return TT_PROC_SET_EVENT_MASK;
1504 case TT_LWP_GET_STATE:
1505 return -1; /* No equivalent */
1513 /* This function translates the "pid" used by the rest of
1514 * gdb to a real pid and a tid. It then calls "call_real_ttrace"
1515 * with the given arguments.
1517 * In general, other parts of this module should call this
1518 * function when they are dealing with external users, who only
1519 * have tids to pass (but they call it "pid" for historical
1523 call_ttrace (ttreq_t request, int gdb_tid, TTRACE_ARG_TYPE addr,
1524 TTRACE_ARG_TYPE data, TTRACE_ARG_TYPE addr2)
1528 ttreq_t new_request;
1530 char reason_for_failure[100]; /* Arbitrary size, should be big enough. */
1533 int is_interesting = 0;
1535 if (TT_LWP_RUREGS == request)
1537 is_interesting = 1; /* Adjust code here as desired */
1540 if (is_interesting && 0 && debug_on)
1542 if (!is_process_ttrace_request (request))
1544 printf ("TT: Thread request, tid is %d", gdb_tid);
1545 printf ("== SINGLE at %x", addr);
1549 printf ("TT: Process request, tid is %d\n", gdb_tid);
1550 printf ("==! SINGLE at %x", addr);
1555 /* The initial SETTRC and SET_EVENT_MASK calls (and all others
1556 * which happen before any threads get set up) should go
1557 * directly to "call_real_ttrace", so they don't happen here.
1559 * But hardware watchpoints do a SET_EVENT_MASK, so we can't
1563 if (request == TT_PROC_SETTRC && debug_on)
1564 printf ("Unexpected call for TT_PROC_SETTRC\n");
1567 /* Sometimes we get called with a bogus tid (e.g., if a
1568 * thread has terminated, we return 0; inftarg later asks
1569 * whether the thread has exited/forked/vforked).
1573 errno = ESRCH; /* ttrace's response would probably be "No such process". */
1577 /* All other cases should be able to expect that there are
1580 if (!any_thread_records ())
1584 warning ("No thread records for ttrace call");
1586 errno = ESRCH; /* ttrace's response would be "No such process". */
1590 /* OK, now the task is to translate the incoming tid into
1593 real_tid = map_from_gdb_tid (gdb_tid);
1594 real_pid = get_pid_for (real_tid);
1596 /* Now check the result. "Real_pid" is NULL if our list
1597 * didn't find it. We have some tricks we can play to fix
1602 ttstate_t thread_state;
1606 printf ("No saved pid for tid %d\n", gdb_tid);
1609 if (is_process_ttrace_request (request))
1612 /* Ok, we couldn't get a tid. Try to translate to
1613 * the equivalent process operation. We expect this
1614 * NOT to happen, so this is a desparation-type
1615 * move. It can happen if there is an internal
1616 * error and so no "wait()" call is ever done.
1618 new_request = make_process_version (request);
1619 if (new_request == -1)
1624 printf ("...and couldn't make process version of thread operation\n");
1627 /* Use hacky saved pid, which won't always be correct
1628 * in the multi-process future. Use tid as thread,
1629 * probably dooming this to failure. FIX!
1631 if (! ptid_equal (saved_real_ptid, null_ptid))
1635 printf ("...using saved pid %d\n",
1636 PIDGET (saved_real_ptid));
1639 real_pid = PIDGET (saved_real_ptid);
1644 error ("Unable to perform thread operation");
1649 /* Sucessfully translated this to a process request,
1650 * which needs no thread value.
1654 request = new_request;
1659 printf ("Translated thread request to process request\n");
1660 if (ptid_equal (saved_real_ptid, null_ptid))
1661 printf ("...but there's no saved pid\n");
1665 if (gdb_tid != PIDGET (saved_real_ptid))
1666 printf ("...but have the wrong pid (%d rather than %d)\n",
1667 gdb_tid, PIDGET (saved_real_ptid));
1671 } /* Translated to a process request */
1672 } /* Is a process request */
1676 /* We have to have a thread. Ooops.
1678 error ("Thread request with no threads (%s)",
1679 get_printable_name_of_ttrace_request (request));
1683 /* Ttrace doesn't like to see tid values on process requests,
1684 * even if we have the right one.
1686 if (is_process_ttrace_request (request))
1692 if (is_interesting && 0 && debug_on)
1694 printf (" now tid %d, pid %d\n", real_tid, real_pid);
1695 printf (" request is %s\n", get_printable_name_of_ttrace_request (request));
1699 /* Finally, the (almost) real call.
1701 tt_status = call_real_ttrace (request, real_pid, real_tid, addr, data, addr2);
1704 if (is_interesting && debug_on)
1706 if (!TT_OK (tt_status, errno)
1707 && !(tt_status == 0 & errno == 0))
1708 printf (" got error (errno==%d, status==%d)\n", errno, tt_status);
1716 /* Stop all the threads of a process.
1718 * NOTE: use of TT_PROC_STOP can cause a thread with a real event
1719 * to get a TTEVT_NONE event, discarding the old event. Be
1720 * very careful, and only call TT_PROC_STOP when you mean it!
1723 stop_all_threads_of_process (pid_t real_pid)
1727 ttw_status = call_real_ttrace (TT_PROC_STOP,
1730 (TTRACE_ARG_TYPE) TT_NIL,
1731 (TTRACE_ARG_TYPE) TT_NIL,
1734 perror_with_name ("ttrace stop of other threads");
1738 /* Under some circumstances, it's unsafe to attempt to stop, or even
1739 query the state of, a process' threads.
1741 In ttrace-based HP-UX, an example is a vforking child process. The
1742 vforking parent and child are somewhat fragile, w/r/t what we can do
1743 what we can do to them with ttrace, until after the child exits or
1744 execs, or until the parent's vfork event is delivered. Until that
1745 time, we must not try to stop the process' threads, or inquire how
1746 many there are, or even alter its data segments, or it typically dies
1747 with a SIGILL. Sigh.
1749 This function returns 1 if this stopped process, and the event that
1750 we're told was responsible for its current stopped state, cannot safely
1751 have its threads examined.
1753 #define CHILD_VFORKED(evt,pid) \
1754 (((evt) == TTEVT_VFORK) && ((pid) != PIDGET (inferior_ptid)))
1755 #define CHILD_URPED(evt,pid) \
1756 ((((evt) == TTEVT_EXEC) || ((evt) == TTEVT_EXIT)) && ((pid) != vforking_child_pid))
1757 #define PARENT_VFORKED(evt,pid) \
1758 (((evt) == TTEVT_VFORK) && ((pid) == PIDGET (inferior_ptid)))
1761 can_touch_threads_of_process (int pid, ttevents_t stopping_event)
1763 if (CHILD_VFORKED (stopping_event, pid))
1765 vforking_child_pid = pid;
1766 vfork_in_flight = 1;
1769 else if (vfork_in_flight &&
1770 (PARENT_VFORKED (stopping_event, pid) ||
1771 CHILD_URPED (stopping_event, pid)))
1773 vfork_in_flight = 0;
1774 vforking_child_pid = 0;
1777 return !vfork_in_flight;
1781 /* If we can find an as-yet-unhandled thread state of a
1782 * stopped thread of this process return 1 and set "tsp".
1783 * Return 0 if we can't.
1785 * If this function is used when the threads of PIS haven't
1786 * been stopped, undefined behaviour is guaranteed!
1789 select_stopped_thread_of_process (int pid, ttstate_t *tsp)
1791 lwpid_t candidate_tid, tid;
1792 ttstate_t candidate_tstate, tstate;
1794 /* If we're not allowed to touch the process now, then just
1795 * return the current value of *TSP.
1797 * This supports "vfork". It's ok, really, to double the
1798 * current event (the child EXEC, we hope!).
1800 if (!can_touch_threads_of_process (pid, tsp->tts_event))
1803 /* Decide which of (possibly more than one) events to
1804 * return as the first one. We scan them all so that
1805 * we always return the result of a fake-step first.
1808 for (tid = get_process_first_stopped_thread_id (pid, &tstate);
1810 tid = get_process_next_stopped_thread_id (pid, &tstate))
1812 /* TTEVT_NONE events are uninteresting to our clients. They're
1813 * an artifact of our "stop the world" model--the thread is
1814 * stopped because we stopped it.
1816 if (tstate.tts_event == TTEVT_NONE)
1818 set_handled (pid, tstate.tts_lwpid);
1821 /* Did we just single-step a single thread, without letting any
1822 * of the others run? Is this an event for that thread?
1824 * If so, we believe our client would prefer to see this event
1825 * over any others. (Typically the client wants to just push
1826 * one thread a little farther forward, and then go around
1827 * checking for what all threads are doing.)
1829 else if (doing_fake_step && (tstate.tts_lwpid == fake_step_tid))
1831 #ifdef WAIT_BUFFER_DEBUG
1832 /* It's possible here to see either a SIGTRAP (due to
1833 * successful completion of a step) or a SYSCALL_ENTRY
1834 * (due to a step completion with active hardware
1838 printf ("Ending fake step with tid %d, state %s\n",
1840 get_printable_name_of_ttrace_event (tstate.tts_event));
1843 /* Remember this one, and throw away any previous
1846 candidate_tid = tstate.tts_lwpid;
1847 candidate_tstate = tstate;
1850 #ifdef FORGET_DELETED_BPTS
1852 /* We can't just do this, as if we do, and then wind
1853 * up the loop with no unhandled events, we need to
1854 * handle that case--the appropriate reaction is to
1855 * just continue, but there's no easy way to do that.
1857 * Better to put this in the ttrace_wait call--if, when
1858 * we fake a wait, we update our events based on the
1859 * breakpoint_here_pc call and find there are no more events,
1860 * then we better continue and so on.
1862 * Or we could put it in the next/continue fake.
1863 * But it has to go in the buffering code, not in the
1864 * real go/wait code.
1866 else if ((TTEVT_SIGNAL == tstate.tts_event)
1867 && (5 == tstate.tts_u.tts_signal.tts_signo)
1868 && (0 != get_raw_pc (tstate.tts_lwpid))
1869 && !breakpoint_here_p (get_raw_pc (tstate.tts_lwpid)))
1872 * If the user deleted a breakpoint while this
1873 * breakpoint-hit event was buffered, we can forget
1876 #ifdef WAIT_BUFFER_DEBUG
1878 printf ("Forgetting deleted bp hit for thread %d\n",
1882 set_handled (pid, tstate.tts_lwpid);
1886 /* Else, is this the first "unhandled" event? If so,
1887 * we believe our client wants to see it (if we don't
1888 * see a fake-step later on in the scan).
1890 else if (!was_handled (tstate.tts_lwpid) && candidate_tid == 0)
1892 candidate_tid = tstate.tts_lwpid;
1893 candidate_tstate = tstate;
1896 /* This is either an event that has already been "handled",
1897 * and thus we believe is uninteresting to our client, or we
1898 * already have a candidate event. Ignore it...
1902 /* What do we report?
1904 if (doing_fake_step)
1906 if (candidate_tid == fake_step_tid)
1910 tstate = candidate_tstate;
1914 warning ("Internal error: fake-step failed to complete.");
1918 else if (candidate_tid != 0)
1920 /* Found a candidate unhandled event.
1922 tstate = candidate_tstate;
1926 warning ("Internal error in call of ttrace_wait.");
1931 warning ("Internal error: no unhandled thread event to select");
1935 copy_ttstate_t (tsp, &tstate);
1937 } /* End of select_stopped_thread_of_process */
1940 /* Check our internal thread data against the real thing.
1943 check_thread_consistency (pid_t real_pid)
1945 int tid; /* really lwpid_t */
1949 /* Spin down the O/S list of threads, checking that they
1950 * match what we've got.
1952 for (tid = get_process_first_stopped_thread_id (real_pid, &tstate);
1954 tid = get_process_next_stopped_thread_id (real_pid, &tstate))
1957 p = find_thread_info (tid);
1961 warning ("No internal thread data for thread %d.", tid);
1967 warning ("Inconsistent internal thread data for thread %d.", tid);
1972 warning ("Thread %d is not terminated, internal error.", tid);
1977 #define TT_COMPARE( fld ) \
1978 tstate.fld != p->last_stop_state.fld
1982 if (TT_COMPARE (tts_pid)
1983 || TT_COMPARE (tts_lwpid)
1984 || TT_COMPARE (tts_user_tid)
1985 || TT_COMPARE (tts_event)
1986 || TT_COMPARE (tts_flags)
1987 || TT_COMPARE (tts_scno)
1988 || TT_COMPARE (tts_scnargs))
1990 warning ("Internal thread data for thread %d is wrong.", tid);
1996 #endif /* PARANOIA */
1999 /* This function wraps calls to "call_real_ttrace_wait" so
2000 * that a actual wait is only done when all pending events
2001 * have been reported.
2003 * Note that typically it is called with a pid of "0", i.e.
2004 * the "don't care" value.
2006 * Return value is the status of the pseudo wait.
2009 call_ttrace_wait (int pid, ttwopt_t option, ttstate_t *tsp, size_t tsp_size)
2011 /* This holds the actual, for-real, true process ID.
2013 static int real_pid;
2015 /* As an argument to ttrace_wait, zero pid
2016 * means "Any process", and zero tid means
2017 * "Any thread of the specified process".
2020 lwpid_t wait_tid = 0;
2023 int ttw_status = 0; /* To be returned */
2025 thread_info *tinfo = NULL;
2033 printf ("TW: Pid to wait on is %d\n", pid);
2036 if (!any_thread_records ())
2037 error ("No thread records for ttrace call w. specific pid");
2039 /* OK, now the task is to translate the incoming tid into
2042 real_tid = map_from_gdb_tid (pid);
2043 real_pid = get_pid_for (real_tid);
2046 printf ("==TW: real pid %d, real tid %d\n", real_pid, real_tid);
2051 /* Sanity checks and set-up.
2054 * Stopped Running Fake-step (v)Fork
2055 * \________________________________________
2057 * No buffered events | error wait wait wait
2059 * Buffered events | debuffer error wait debuffer (?)
2062 if (more_events_left == 0)
2065 if (process_state == RUNNING)
2067 /* OK--normal call of ttrace_wait with no buffered events.
2071 else if (process_state == FAKE_STEPPING)
2073 /* Ok--call of ttrace_wait to support
2074 * fake stepping with no buffered events.
2076 * But we better be fake-stepping!
2078 if (!doing_fake_step)
2080 warning ("Inconsistent thread state.");
2083 else if ((process_state == FORKING)
2084 || (process_state == VFORKING))
2086 /* Ok--there are two processes, so waiting
2087 * for the second while the first is stopped
2088 * is ok. Handled bits stay as they were.
2092 else if (process_state == STOPPED)
2094 warning ("Process not running at wait call.");
2099 warning ("Inconsistent process state.");
2106 if (process_state == STOPPED)
2108 /* OK--buffered events being unbuffered.
2112 else if (process_state == RUNNING)
2114 /* An error--shouldn't have buffered events
2117 warning ("Trying to continue with buffered events:");
2119 else if (process_state == FAKE_STEPPING)
2122 * Better be fake-stepping!
2124 if (!doing_fake_step)
2126 warning ("Losing buffered thread events!\n");
2129 else if ((process_state == FORKING)
2130 || (process_state == VFORKING))
2132 /* Ok--there are two processes, so waiting
2133 * for the second while the first is stopped
2134 * is ok. Handled bits stay as they were.
2139 warning ("Process in unknown state with buffered events.");
2142 /* Sometimes we have to wait for a particular thread
2143 * (if we're stepping over a bpt). In that case, we
2144 * _know_ it's going to complete the single-step we
2145 * asked for (because we're only doing the step under
2146 * certain very well-understood circumstances), so it
2149 if (doing_fake_step)
2151 wait_tid = fake_step_tid;
2152 wait_pid = get_pid_for (fake_step_tid);
2154 #ifdef WAIT_BUFFER_DEBUG
2156 printf ("Doing a wait after a fake-step for %d, pid %d\n",
2157 wait_tid, wait_pid);
2161 if (more_events_left == 0 /* No buffered events, need real ones. */
2162 || process_state != STOPPED)
2164 /* If there are no buffered events, and so we need
2165 * real ones, or if we are FORKING, VFORKING,
2166 * FAKE_STEPPING or RUNNING, and thus have to do
2167 * a real wait, then do a real wait.
2170 #ifdef WAIT_BUFFER_DEBUG
2171 /* Normal case... */
2173 printf ("TW: do it for real; pid %d, tid %d\n", wait_pid, wait_tid);
2176 /* The actual wait call.
2178 ttw_status = call_real_ttrace_wait (wait_pid, wait_tid, option, tsp, tsp_size);
2180 /* Note that the routines we'll call will be using "call_real_ttrace",
2181 * not "call_ttrace", and thus need the real pid rather than the pseudo-tid
2182 * the rest of the world uses (which is actually the tid).
2184 real_pid = tsp->tts_pid;
2186 /* For most events: Stop the world!
2188 * It's sometimes not safe to stop all threads of a process.
2189 * Sometimes it's not even safe to ask for the thread state
2192 if (can_touch_threads_of_process (real_pid, tsp->tts_event))
2194 /* If we're really only stepping a single thread, then don't
2195 * try to stop all the others -- we only do this single-stepping
2196 * business when all others were already stopped...and the stop
2197 * would mess up other threads' events.
2199 * Similiarly, if there are other threads with events,
2200 * don't do the stop.
2202 if (!doing_fake_step)
2204 if (more_events_left > 0)
2205 warning ("Internal error in stopping process");
2207 stop_all_threads_of_process (real_pid);
2209 /* At this point, we could scan and update_thread_list(),
2210 * and only use the local list for the rest of the
2211 * module! We'd get rid of the scans in the various
2212 * continue routines (adding one in attach). It'd
2213 * be great--UPGRADE ME!
2221 if (more_events_left > 0)
2222 printf ("== Can't stop process; more events!\n");
2224 printf ("== Can't stop process!\n");
2228 process_state = STOPPED;
2230 #ifdef WAIT_BUFFER_DEBUG
2232 printf ("Process set to STOPPED\n");
2238 /* Fake a call to ttrace_wait. The process must be
2239 * STOPPED, as we aren't going to do any wait.
2241 #ifdef WAIT_BUFFER_DEBUG
2243 printf ("TW: fake it\n");
2246 if (process_state != STOPPED)
2248 warning ("Process not stopped at wait call, in state '%s'.\n",
2249 get_printable_name_of_process_state (process_state));
2252 if (doing_fake_step)
2253 error ("Internal error in stepping over breakpoint");
2255 ttw_status = 0; /* Faking it is always successful! */
2256 } /* End of fake or not? if */
2258 /* Pick an event to pass to our caller. Be paranoid.
2260 if (!select_stopped_thread_of_process (real_pid, tsp))
2261 warning ("Can't find event, using previous event.");
2263 else if (tsp->tts_event == TTEVT_NONE)
2264 warning ("Internal error: no thread has a real event.");
2266 else if (doing_fake_step)
2268 if (fake_step_tid != tsp->tts_lwpid)
2269 warning ("Internal error in stepping over breakpoint.");
2271 /* This wait clears the (current) fake-step if there was one.
2273 doing_fake_step = 0;
2277 /* We now have a correct tsp and ttw_status for the thread
2278 * which we want to report. So it's "handled"! This call
2279 * will add it to our list if it's not there already.
2281 set_handled (real_pid, tsp->tts_lwpid);
2283 /* Save a copy of the ttrace state of this thread, in our local
2286 This caches the state. The implementation of queries like
2287 hpux_has_execd can then use this cached state, rather than
2288 be forced to make an explicit ttrace call to get it.
2290 (Guard against the condition that this is the first time we've
2291 waited on, i.e., seen this thread, and so haven't yet entered
2292 it into our list of threads.)
2294 tinfo = find_thread_info (tsp->tts_lwpid);
2297 copy_ttstate_t (&tinfo->last_stop_state, tsp);
2298 tinfo->have_state = 1;
2302 } /* call_ttrace_wait */
2304 #if defined(CHILD_REPORTED_EXEC_EVENTS_PER_EXEC_CALL)
2306 child_reported_exec_events_per_exec_call (void)
2308 return 1; /* ttrace reports the event once per call. */
2314 /* Our implementation of hardware watchpoints involves making memory
2315 pages write-protected. We must remember a page's original permissions,
2316 and we must also know when it is appropriate to restore a page's
2317 permissions to its original state.
2319 We use a "dictionary" of hardware-watched pages to do this. Each
2320 hardware-watched page is recorded in the dictionary. Each page's
2321 dictionary entry contains the original permissions and a reference
2322 count. Pages are hashed into the dictionary by their start address.
2324 When hardware watchpoint is set on page X for the first time, page X
2325 is added to the dictionary with a reference count of 1. If other
2326 hardware watchpoints are subsequently set on page X, its reference
2327 count is incremented. When hardware watchpoints are removed from
2328 page X, its reference count is decremented. If a page's reference
2329 count drops to 0, it's permissions are restored and the page's entry
2330 is thrown out of the dictionary.
2332 typedef struct memory_page
2334 CORE_ADDR page_start;
2335 int reference_count;
2336 int original_permissions;
2337 struct memory_page *next;
2338 struct memory_page *previous;
2342 #define MEMORY_PAGE_DICTIONARY_BUCKET_COUNT 128
2348 int page_protections_allowed;
2349 /* These are just the heads of chains of actual page descriptors. */
2350 memory_page_t buckets[MEMORY_PAGE_DICTIONARY_BUCKET_COUNT];
2352 memory_page_dictionary;
2356 require_memory_page_dictionary (void)
2360 /* Is the memory page dictionary ready for use? If so, we're done. */
2361 if (memory_page_dictionary.page_count >= (LONGEST) 0)
2364 /* Else, initialize it. */
2365 memory_page_dictionary.page_count = (LONGEST) 0;
2367 for (i = 0; i < MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; i++)
2369 memory_page_dictionary.buckets[i].page_start = (CORE_ADDR) 0;
2370 memory_page_dictionary.buckets[i].reference_count = 0;
2371 memory_page_dictionary.buckets[i].next = NULL;
2372 memory_page_dictionary.buckets[i].previous = NULL;
2378 retire_memory_page_dictionary (void)
2380 memory_page_dictionary.page_count = (LONGEST) - 1;
2384 /* Write-protect the memory page that starts at this address.
2386 Returns the original permissions of the page.
2389 write_protect_page (int pid, CORE_ADDR page_start)
2392 int original_permissions;
2393 int new_permissions;
2395 tt_status = call_ttrace (TT_PROC_GET_MPROTECT,
2397 (TTRACE_ARG_TYPE) page_start,
2399 (TTRACE_ARG_TYPE) & original_permissions);
2400 if (errno || (tt_status < 0))
2402 return 0; /* What else can we do? */
2405 /* We'll also write-protect the page now, if that's allowed. */
2406 if (memory_page_dictionary.page_protections_allowed)
2408 new_permissions = original_permissions & ~PROT_WRITE;
2409 tt_status = call_ttrace (TT_PROC_SET_MPROTECT,
2411 (TTRACE_ARG_TYPE) page_start,
2412 (TTRACE_ARG_TYPE) memory_page_dictionary.page_size,
2413 (TTRACE_ARG_TYPE) new_permissions);
2414 if (errno || (tt_status < 0))
2416 return 0; /* What else can we do? */
2420 return original_permissions;
2424 /* Unwrite-protect the memory page that starts at this address, restoring
2425 (what we must assume are) its original permissions.
2428 unwrite_protect_page (int pid, CORE_ADDR page_start, int original_permissions)
2432 tt_status = call_ttrace (TT_PROC_SET_MPROTECT,
2434 (TTRACE_ARG_TYPE) page_start,
2435 (TTRACE_ARG_TYPE) memory_page_dictionary.page_size,
2436 (TTRACE_ARG_TYPE) original_permissions);
2437 if (errno || (tt_status < 0))
2439 return; /* What else can we do? */
2444 /* Memory page-protections are used to implement "hardware" watchpoints
2447 For every memory page that is currently being watched (i.e., that
2448 presently should be write-protected), write-protect it.
2451 hppa_enable_page_protection_events (int pid)
2455 memory_page_dictionary.page_protections_allowed = 1;
2457 for (bucket = 0; bucket < MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; bucket++)
2459 memory_page_t *page;
2461 page = memory_page_dictionary.buckets[bucket].next;
2462 while (page != NULL)
2464 page->original_permissions = write_protect_page (pid, page->page_start);
2471 /* Memory page-protections are used to implement "hardware" watchpoints
2474 For every memory page that is currently being watched (i.e., that
2475 presently is or should be write-protected), un-write-protect it.
2478 hppa_disable_page_protection_events (int pid)
2482 for (bucket = 0; bucket < MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; bucket++)
2484 memory_page_t *page;
2486 page = memory_page_dictionary.buckets[bucket].next;
2487 while (page != NULL)
2489 unwrite_protect_page (pid, page->page_start, page->original_permissions);
2494 memory_page_dictionary.page_protections_allowed = 0;
2497 /* Count the number of outstanding events. At this
2498 * point, we have selected one thread and its event
2499 * as the one to be "reported" upwards to core gdb.
2500 * That thread is already marked as "handled".
2502 * Note: we could just scan our own thread list. FIXME!
2505 count_unhandled_events (int real_pid, lwpid_t real_tid)
2511 /* Ok, find out how many threads have real events to report.
2514 ttid = get_process_first_stopped_thread_id (real_pid, &tstate);
2520 printf ("Process %d has no threads\n", real_pid);
2522 printf ("Process %d has these threads:\n", real_pid);
2528 if (tstate.tts_event != TTEVT_NONE
2529 && !was_handled (ttid))
2531 /* TTEVT_NONE implies we just stopped it ourselves
2532 * because we're the stop-the-world guys, so it's
2533 * not an event from our point of view.
2535 * If "was_handled" is true, this is an event we
2536 * already handled, so don't count it.
2538 * Note that we don't count the thread with the
2539 * currently-reported event, as it's already marked
2545 #if defined( THREAD_DEBUG ) || defined( WAIT_BUFFER_DEBUG )
2548 if (ttid == real_tid)
2549 printf ("*"); /* Thread we're reporting */
2553 if (tstate.tts_event != TTEVT_NONE)
2554 printf ("+"); /* Thread with a real event */
2558 if (was_handled (ttid))
2559 printf ("h"); /* Thread has been handled */
2563 printf (" %d, with event %s", ttid,
2564 get_printable_name_of_ttrace_event (tstate.tts_event));
2566 if (tstate.tts_event == TTEVT_SIGNAL
2567 && 5 == tstate.tts_u.tts_signal.tts_signo)
2571 pc_val = get_raw_pc (ttid);
2574 printf (" breakpoint at 0x%x\n", pc_val);
2576 printf (" bpt, can't fetch pc.\n");
2583 ttid = get_process_next_stopped_thread_id (real_pid, &tstate);
2586 #if defined( THREAD_DEBUG ) || defined( WAIT_BUFFER_DEBUG )
2588 if (events_left > 0)
2589 printf ("There are thus %d pending events\n", events_left);
2595 /* This function is provided as a sop to clients that are calling
2596 * ptrace_wait to wait for a process to stop. (see the
2597 * implementation of child_wait.) Return value is the pid for
2598 * the event that ended the wait.
2600 * Note: used by core gdb and so uses the pseudo-pid (really tid).
2603 ptrace_wait (ptid_t ptid, int *status)
2612 /* The ptrace implementation of this also ignores pid.
2616 ttwait_return = call_ttrace_wait (0, TTRACE_WAITOK, &tsp, sizeof (tsp));
2617 if (ttwait_return < 0)
2619 /* ??rehrauer: It appears that if our inferior exits and we
2620 haven't asked for exit events, that we're not getting any
2621 indication save a negative return from ttrace_wait and an
2626 *status = 0; /* WIFEXITED */
2627 return PIDGET (inferior_ptid);
2630 warning ("Call of ttrace_wait returned with errno %d.",
2632 *status = ttwait_return;
2633 return PIDGET (inferior_ptid);
2636 real_pid = tsp.tts_pid;
2637 real_tid = tsp.tts_lwpid;
2639 /* One complication is that the "tts_event" structure has
2640 * a set of flags, and more than one can be set. So we
2641 * either have to force an order (as we do here), or handle
2642 * more than one flag at a time.
2644 if (tsp.tts_event & TTEVT_LWP_CREATE)
2647 /* Unlike what you might expect, this event is reported in
2648 * the _creating_ thread, and the _created_ thread (whose tid
2649 * we have) is still running. So we have to stop it. This
2650 * has already been done in "call_ttrace_wait", but should we
2651 * ever abandon the "stop-the-world" model, here's the command
2654 * call_ttrace( TT_LWP_STOP, real_tid, TT_NIL, TT_NIL, TT_NIL );
2656 * Note that this would depend on being called _after_ "add_tthread"
2657 * below for the tid-to-pid translation to be done in "call_ttrace".
2662 printf ("New thread: pid %d, tid %d, creator tid %d\n",
2663 real_pid, tsp.tts_u.tts_thread.tts_target_lwpid,
2667 /* Now we have to return the tid of the created thread, not
2668 * the creating thread, or "wait_for_inferior" won't know we
2669 * have a new "process" (thread). Plus we should record it
2672 real_tid = tsp.tts_u.tts_thread.tts_target_lwpid;
2674 add_tthread (real_pid, real_tid);
2677 else if ((tsp.tts_event & TTEVT_LWP_TERMINATE)
2678 || (tsp.tts_event & TTEVT_LWP_EXIT))
2683 printf ("Thread dies: %d\n", real_tid);
2686 del_tthread (real_tid);
2689 else if (tsp.tts_event & TTEVT_EXEC)
2694 printf ("Pid %d has zero'th thread %d; inferior pid is %d\n",
2695 real_pid, real_tid, PIDGET (inferior_ptid));
2698 add_tthread (real_pid, real_tid);
2704 printf ("Process-level event %s, using tid %d\n",
2705 get_printable_name_of_ttrace_event (tsp.tts_event),
2708 /* OK to do this, as "add_tthread" won't add
2709 * duplicate entries. Also OK not to do it,
2710 * as this event isn't one which can change the
2713 add_tthread (real_pid, real_tid);
2718 /* How many events are left to report later?
2719 * In a non-stop-the-world model, this isn't needed.
2721 * Note that it's not always safe to query the thread state of a process,
2722 * which is what count_unhandled_events does. (If unsafe, we're left with
2723 * no other resort than to assume that no more events remain...)
2725 if (can_touch_threads_of_process (real_pid, tsp.tts_event))
2726 more_events_left = count_unhandled_events (real_pid, real_tid);
2730 if (more_events_left > 0)
2731 warning ("Vfork or fork causing loss of %d buffered events.",
2734 more_events_left = 0;
2737 /* Attempt to translate the ttrace_wait-returned status into the
2740 ??rehrauer: This is somewhat fragile. We really ought to rewrite
2741 clients that expect to pick apart a ptrace wait status, to use
2742 something a little more abstract.
2744 if ((tsp.tts_event & TTEVT_EXEC)
2745 || (tsp.tts_event & TTEVT_FORK)
2746 || (tsp.tts_event & TTEVT_VFORK))
2748 /* Forks come in pairs (parent and child), so core gdb
2749 * will do two waits. Be ready to notice this.
2751 if (tsp.tts_event & TTEVT_FORK)
2753 process_state = FORKING;
2755 #ifdef WAIT_BUFFER_DEBUG
2757 printf ("Process set to FORKING\n");
2760 else if (tsp.tts_event & TTEVT_VFORK)
2762 process_state = VFORKING;
2764 #ifdef WAIT_BUFFER_DEBUG
2766 printf ("Process set to VFORKING\n");
2770 /* Make an exec or fork look like a breakpoint. Definitely a hack,
2771 but I don't think non HP-UX-specific clients really carefully
2772 inspect the first events they get after inferior startup, so
2773 it probably almost doesn't matter what we claim this is.
2778 printf ("..a process 'event'\n");
2781 /* Also make fork and exec events look like bpts, so they can be caught.
2783 *status = 0177 | (_SIGTRAP << 8);
2786 /* Special-cases: We ask for syscall entry and exit events to implement
2787 "fast" (aka "hardware") watchpoints.
2789 When we get a syscall entry, we want to disable page-protections,
2790 and resume the inferior; this isn't an event we wish for
2791 wait_for_inferior to see. Note that we must resume ONLY the
2792 thread that reported the syscall entry; we don't want to allow
2793 other threads to run with the page protections off, as they might
2794 then be able to write to watch memory without it being caught.
2796 When we get a syscall exit, we want to reenable page-protections,
2797 but we don't want to resume the inferior; this is an event we wish
2798 wait_for_inferior to see. Make it look like the signal we normally
2799 get for a single-step completion. This should cause wait_for_inferior
2800 to evaluate whether any watchpoint triggered.
2802 Or rather, that's what we'd LIKE to do for syscall exit; we can't,
2803 due to some HP-UX "features". Some syscalls have problems with
2804 write-protections on some pages, and some syscalls seem to have
2805 pending writes to those pages at the time we're getting the return
2806 event. So, we'll single-step the inferior to get out of the syscall,
2807 and then reenable protections.
2809 Note that we're intentionally allowing the syscall exit case to
2810 fall through into the succeeding cases, as sometimes we single-
2811 step out of one syscall only to immediately enter another...
2813 else if ((tsp.tts_event & TTEVT_SYSCALL_ENTRY)
2814 || (tsp.tts_event & TTEVT_SYSCALL_RETURN))
2816 /* Make a syscall event look like a breakpoint. Same comments
2817 as for exec & fork events.
2821 printf ("..a syscall 'event'\n");
2824 /* Also make syscall events look like bpts, so they can be caught.
2826 *status = 0177 | (_SIGTRAP << 8);
2829 else if ((tsp.tts_event & TTEVT_LWP_CREATE)
2830 || (tsp.tts_event & TTEVT_LWP_TERMINATE)
2831 || (tsp.tts_event & TTEVT_LWP_EXIT))
2833 /* Make a thread event look like a breakpoint. Same comments
2834 * as for exec & fork events.
2838 printf ("..a thread 'event'\n");
2841 /* Also make thread events look like bpts, so they can be caught.
2843 *status = 0177 | (_SIGTRAP << 8);
2846 else if ((tsp.tts_event & TTEVT_EXIT))
2851 printf ("..an exit\n");
2854 /* Prevent rest of gdb from thinking this is
2855 * a new thread if for some reason it's never
2856 * seen the main thread before.
2858 inferior_ptid = pid_to_ptid (map_to_gdb_tid (real_tid)); /* HACK, FIX */
2860 *status = 0 | (tsp.tts_u.tts_exit.tts_exitcode);
2863 else if (tsp.tts_event & TTEVT_SIGNAL)
2867 printf ("..a signal, %d\n", tsp.tts_u.tts_signal.tts_signo);
2870 *status = 0177 | (tsp.tts_u.tts_signal.tts_signo << 8);
2876 /* This means the process or thread terminated. But we should've
2877 caught an explicit exit/termination above. So warn (this is
2878 really an internal error) and claim the process or thread
2879 terminated with a SIGTRAP.
2882 warning ("process_wait: unknown process state");
2886 printf ("Process-level event %s, using tid %d\n",
2887 get_printable_name_of_ttrace_event (tsp.tts_event),
2894 target_post_wait (pid_to_ptid (tsp.tts_pid), *status);
2899 printf ("Done waiting, pid is %d, tid %d\n", real_pid, real_tid);
2902 /* All code external to this module uses the tid, but calls
2903 * it "pid". There's some tweaking so that the outside sees
2904 * the first thread as having the same number as the starting
2907 return_pid = map_to_gdb_tid (real_tid);
2909 if (real_tid == 0 || return_pid == 0)
2911 warning ("Internal error: process-wait failed.");
2918 /* This function causes the caller's process to be traced by its
2919 parent. This is intended to be called after GDB forks itself,
2920 and before the child execs the target. Despite the name, it
2921 is called by the child.
2923 Note that HP-UX ttrace is rather funky in how this is done.
2924 If the parent wants to get the initial exec event of a child,
2925 it must set the ttrace event mask of the child to include execs.
2926 (The child cannot do this itself.) This must be done after the
2927 child is forked, but before it execs.
2929 To coordinate the parent and child, we implement a semaphore using
2930 pipes. After SETTRC'ing itself, the child tells the parent that
2931 it is now traceable by the parent, and waits for the parent's
2932 acknowledgement. The parent can then set the child's event mask,
2933 and notify the child that it can now exec.
2935 (The acknowledgement by parent happens as a result of a call to
2936 child_acknowledge_created_inferior.)
2939 parent_attach_all (int p1, PTRACE_ARG3_TYPE p2, int p3)
2943 /* We need a memory home for a constant, to pass it to ttrace.
2944 The value of the constant is arbitrary, so long as both
2945 parent and child use the same value. Might as well use the
2946 "magic" constant provided by ttrace...
2948 uint64_t tc_magic_child = TT_VERSION;
2949 uint64_t tc_magic_parent = 0;
2951 tt_status = call_real_ttrace (
2956 (TTRACE_ARG_TYPE) TT_VERSION,
2962 /* Notify the parent that we're potentially ready to exec(). */
2963 write (startup_semaphore.child_channel[SEM_TALK],
2965 sizeof (tc_magic_child));
2967 /* Wait for acknowledgement from the parent. */
2968 read (startup_semaphore.parent_channel[SEM_LISTEN],
2970 sizeof (tc_magic_parent));
2972 if (tc_magic_child != tc_magic_parent)
2973 warning ("mismatched semaphore magic");
2975 /* Discard our copy of the semaphore. */
2976 (void) close (startup_semaphore.parent_channel[SEM_LISTEN]);
2977 (void) close (startup_semaphore.parent_channel[SEM_TALK]);
2978 (void) close (startup_semaphore.child_channel[SEM_LISTEN]);
2979 (void) close (startup_semaphore.child_channel[SEM_TALK]);
2984 /* Despite being file-local, this routine is dealing with
2985 * actual process IDs, not thread ids. That's because it's
2986 * called before the first "wait" call, and there's no map
2987 * yet from tids to pids.
2989 * When it is called, a forked child is running, but waiting on
2990 * the semaphore. If you stop the child and re-start it,
2991 * things get confused, so don't do that! An attached child is
2994 * Since this is called after either attach or run, we
2995 * have to be the common part of both.
2998 require_notification_of_events (int real_pid)
3001 ttevent_t notifiable_events;
3004 ttstate_t thread_state;
3008 printf ("Require notif, pid is %d\n", real_pid);
3011 /* Temporary HACK: tell inftarg.c/child_wait to not
3012 * loop until pids are the same.
3014 not_same_real_pid = 0;
3016 sigemptyset (¬ifiable_events.tte_signals);
3017 notifiable_events.tte_opts = TTEO_NONE;
3019 /* This ensures that forked children inherit their parent's
3020 * event mask, which we're setting here.
3022 * NOTE: if you debug gdb with itself, then the ultimate
3023 * debuggee gets flags set by the outermost gdb, as
3024 * a child of a child will still inherit.
3026 notifiable_events.tte_opts |= TTEO_PROC_INHERIT;
3028 notifiable_events.tte_events = TTEVT_DEFAULT;
3029 notifiable_events.tte_events |= TTEVT_SIGNAL;
3030 notifiable_events.tte_events |= TTEVT_EXEC;
3031 notifiable_events.tte_events |= TTEVT_EXIT;
3032 notifiable_events.tte_events |= TTEVT_FORK;
3033 notifiable_events.tte_events |= TTEVT_VFORK;
3034 notifiable_events.tte_events |= TTEVT_LWP_CREATE;
3035 notifiable_events.tte_events |= TTEVT_LWP_EXIT;
3036 notifiable_events.tte_events |= TTEVT_LWP_TERMINATE;
3038 tt_status = call_real_ttrace (
3039 TT_PROC_SET_EVENT_MASK,
3042 (TTRACE_ARG_TYPE) & notifiable_events,
3043 (TTRACE_ARG_TYPE) sizeof (notifiable_events),
3048 require_notification_of_exec_events (int real_pid)
3051 ttevent_t notifiable_events;
3054 ttstate_t thread_state;
3058 printf ("Require notif, pid is %d\n", real_pid);
3061 /* Temporary HACK: tell inftarg.c/child_wait to not
3062 * loop until pids are the same.
3064 not_same_real_pid = 0;
3066 sigemptyset (¬ifiable_events.tte_signals);
3067 notifiable_events.tte_opts = TTEO_NOSTRCCHLD;
3069 /* This ensures that forked children don't inherit their parent's
3070 * event mask, which we're setting here.
3072 notifiable_events.tte_opts &= ~TTEO_PROC_INHERIT;
3074 notifiable_events.tte_events = TTEVT_DEFAULT;
3075 notifiable_events.tte_events |= TTEVT_EXEC;
3076 notifiable_events.tte_events |= TTEVT_EXIT;
3078 tt_status = call_real_ttrace (
3079 TT_PROC_SET_EVENT_MASK,
3082 (TTRACE_ARG_TYPE) & notifiable_events,
3083 (TTRACE_ARG_TYPE) sizeof (notifiable_events),
3088 /* This function is called by the parent process, with pid being the
3089 * ID of the child process, after the debugger has forked.
3092 child_acknowledge_created_inferior (int pid)
3094 /* We need a memory home for a constant, to pass it to ttrace.
3095 The value of the constant is arbitrary, so long as both
3096 parent and child use the same value. Might as well use the
3097 "magic" constant provided by ttrace...
3099 uint64_t tc_magic_parent = TT_VERSION;
3100 uint64_t tc_magic_child = 0;
3102 /* Wait for the child to tell us that it has forked. */
3103 read (startup_semaphore.child_channel[SEM_LISTEN],
3105 sizeof (tc_magic_child));
3107 /* Clear thread info now. We'd like to do this in
3108 * "require...", but that messes up attach.
3110 clear_thread_info ();
3112 /* Tell the "rest of gdb" that the initial thread exists.
3113 * This isn't really a hack. Other thread-based versions
3114 * of gdb (e.g. gnu-nat.c) seem to do the same thing.
3116 * Q: Why don't we also add this thread to the local
3117 * list via "add_tthread"?
3119 * A: Because we don't know the tid, and can't stop the
3120 * the process safely to ask what it is. Anyway, we'll
3121 * add it when it gets the EXEC event.
3123 add_thread (pid_to_ptid (pid)); /* in thread.c */
3125 /* We can now set the child's ttrace event mask.
3127 require_notification_of_exec_events (pid);
3129 /* Tell ourselves that the process is running.
3131 process_state = RUNNING;
3133 /* Notify the child that it can exec. */
3134 write (startup_semaphore.parent_channel[SEM_TALK],
3136 sizeof (tc_magic_parent));
3138 /* Discard our copy of the semaphore. */
3139 (void) close (startup_semaphore.parent_channel[SEM_LISTEN]);
3140 (void) close (startup_semaphore.parent_channel[SEM_TALK]);
3141 (void) close (startup_semaphore.child_channel[SEM_LISTEN]);
3142 (void) close (startup_semaphore.child_channel[SEM_TALK]);
3147 * arrange for notification of all events by
3148 * calling require_notification_of_events.
3151 child_post_startup_inferior (ptid_t ptid)
3153 require_notification_of_events (PIDGET (ptid));
3156 /* From here on, we should expect tids rather than pids.
3159 hppa_enable_catch_fork (int tid)
3162 ttevent_t ttrace_events;
3164 /* Get the set of events that are currently enabled.
3166 tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
3168 (TTRACE_ARG_TYPE) & ttrace_events,
3169 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
3172 perror_with_name ("ttrace");
3174 /* Add forks to that set. */
3175 ttrace_events.tte_events |= TTEVT_FORK;
3179 printf ("enable fork, tid is %d\n", tid);
3182 tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
3184 (TTRACE_ARG_TYPE) & ttrace_events,
3185 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
3188 perror_with_name ("ttrace");
3193 hppa_disable_catch_fork (int tid)
3196 ttevent_t ttrace_events;
3198 /* Get the set of events that are currently enabled.
3200 tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
3202 (TTRACE_ARG_TYPE) & ttrace_events,
3203 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
3207 perror_with_name ("ttrace");
3209 /* Remove forks from that set. */
3210 ttrace_events.tte_events &= ~TTEVT_FORK;
3214 printf ("disable fork, tid is %d\n", tid);
3217 tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
3219 (TTRACE_ARG_TYPE) & ttrace_events,
3220 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
3224 perror_with_name ("ttrace");
3228 #if defined(CHILD_INSERT_FORK_CATCHPOINT)
3230 child_insert_fork_catchpoint (int tid)
3232 /* Enable reporting of fork events from the kernel. */
3233 /* ??rehrauer: For the moment, we're always enabling these events,
3234 and just ignoring them if there's no catchpoint to catch them.
3241 #if defined(CHILD_REMOVE_FORK_CATCHPOINT)
3243 child_remove_fork_catchpoint (int tid)
3245 /* Disable reporting of fork events from the kernel. */
3246 /* ??rehrauer: For the moment, we're always enabling these events,
3247 and just ignoring them if there's no catchpoint to catch them.
3255 hppa_enable_catch_vfork (int tid)
3258 ttevent_t ttrace_events;
3260 /* Get the set of events that are currently enabled.
3262 tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
3264 (TTRACE_ARG_TYPE) & ttrace_events,
3265 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
3269 perror_with_name ("ttrace");
3271 /* Add vforks to that set. */
3272 ttrace_events.tte_events |= TTEVT_VFORK;
3276 printf ("enable vfork, tid is %d\n", tid);
3279 tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
3281 (TTRACE_ARG_TYPE) & ttrace_events,
3282 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
3286 perror_with_name ("ttrace");
3291 hppa_disable_catch_vfork (int tid)
3294 ttevent_t ttrace_events;
3296 /* Get the set of events that are currently enabled. */
3297 tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
3299 (TTRACE_ARG_TYPE) & ttrace_events,
3300 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
3304 perror_with_name ("ttrace");
3306 /* Remove vforks from that set. */
3307 ttrace_events.tte_events &= ~TTEVT_VFORK;
3311 printf ("disable vfork, tid is %d\n", tid);
3313 tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
3315 (TTRACE_ARG_TYPE) & ttrace_events,
3316 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
3320 perror_with_name ("ttrace");
3324 #if defined(CHILD_INSERT_VFORK_CATCHPOINT)
3326 child_insert_vfork_catchpoint (int tid)
3328 /* Enable reporting of vfork events from the kernel. */
3329 /* ??rehrauer: For the moment, we're always enabling these events,
3330 and just ignoring them if there's no catchpoint to catch them.
3337 #if defined(CHILD_REMOVE_VFORK_CATCHPOINT)
3339 child_remove_vfork_catchpoint (int tid)
3341 /* Disable reporting of vfork events from the kernel. */
3342 /* ??rehrauer: For the moment, we're always enabling these events,
3343 and just ignoring them if there's no catchpoint to catch them.
3349 /* Q: Do we need to map the returned process ID to a thread ID?
3351 * A: I don't think so--here we want a _real_ pid. Any later
3352 * operations will call "require_notification_of_events" and
3353 * start the mapping.
3356 hpux_has_forked (int tid, int *childpid)
3359 ttstate_t ttrace_state;
3362 /* Do we have cached thread state that we can consult? If so, use it. */
3363 tinfo = find_thread_info (map_from_gdb_tid (tid));
3366 copy_ttstate_t (&ttrace_state, &tinfo->last_stop_state);
3369 /* Nope, must read the thread's current state */
3372 tt_status = call_ttrace (TT_LWP_GET_STATE,
3374 (TTRACE_ARG_TYPE) & ttrace_state,
3375 (TTRACE_ARG_TYPE) sizeof (ttrace_state),
3379 perror_with_name ("ttrace");
3385 if (ttrace_state.tts_event & TTEVT_FORK)
3387 *childpid = ttrace_state.tts_u.tts_fork.tts_fpid;
3394 /* See hpux_has_forked for pid discussion.
3397 hpux_has_vforked (int tid, int *childpid)
3400 ttstate_t ttrace_state;
3403 /* Do we have cached thread state that we can consult? If so, use it. */
3404 tinfo = find_thread_info (map_from_gdb_tid (tid));
3406 copy_ttstate_t (&ttrace_state, &tinfo->last_stop_state);
3408 /* Nope, must read the thread's current state */
3411 tt_status = call_ttrace (TT_LWP_GET_STATE,
3413 (TTRACE_ARG_TYPE) & ttrace_state,
3414 (TTRACE_ARG_TYPE) sizeof (ttrace_state),
3418 perror_with_name ("ttrace");
3424 if (ttrace_state.tts_event & TTEVT_VFORK)
3426 *childpid = ttrace_state.tts_u.tts_fork.tts_fpid;
3434 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
3436 child_insert_exec_catchpoint (int tid)
3438 /* Enable reporting of exec events from the kernel. */
3439 /* ??rehrauer: For the moment, we're always enabling these events,
3440 and just ignoring them if there's no catchpoint to catch them.
3447 #if defined(CHILD_REMOVE_EXEC_CATCHPOINT)
3449 child_remove_exec_catchpoint (int tid)
3451 /* Disable reporting of execevents from the kernel. */
3452 /* ??rehrauer: For the moment, we're always enabling these events,
3453 and just ignoring them if there's no catchpoint to catch them.
3461 hpux_has_execd (int tid, char **execd_pathname)
3464 ttstate_t ttrace_state;
3467 /* Do we have cached thread state that we can consult? If so, use it. */
3468 tinfo = find_thread_info (map_from_gdb_tid (tid));
3470 copy_ttstate_t (&ttrace_state, &tinfo->last_stop_state);
3472 /* Nope, must read the thread's current state */
3475 tt_status = call_ttrace (TT_LWP_GET_STATE,
3477 (TTRACE_ARG_TYPE) & ttrace_state,
3478 (TTRACE_ARG_TYPE) sizeof (ttrace_state),
3482 perror_with_name ("ttrace");
3488 if (ttrace_state.tts_event & TTEVT_EXEC)
3490 /* See child_pid_to_exec_file in this file: this is a macro.
3492 char *exec_file = target_pid_to_exec_file (tid);
3494 *execd_pathname = savestring (exec_file, strlen (exec_file));
3503 hpux_has_syscall_event (int pid, enum target_waitkind *kind, int *syscall_id)
3506 ttstate_t ttrace_state;
3509 /* Do we have cached thread state that we can consult? If so, use it. */
3510 tinfo = find_thread_info (map_from_gdb_tid (pid));
3512 copy_ttstate_t (&ttrace_state, &tinfo->last_stop_state);
3514 /* Nope, must read the thread's current state */
3517 tt_status = call_ttrace (TT_LWP_GET_STATE,
3519 (TTRACE_ARG_TYPE) & ttrace_state,
3520 (TTRACE_ARG_TYPE) sizeof (ttrace_state),
3524 perror_with_name ("ttrace");
3530 *kind = TARGET_WAITKIND_SPURIOUS; /* Until proven otherwise... */
3533 if (ttrace_state.tts_event & TTEVT_SYSCALL_ENTRY)
3534 *kind = TARGET_WAITKIND_SYSCALL_ENTRY;
3535 else if (ttrace_state.tts_event & TTEVT_SYSCALL_RETURN)
3536 *kind = TARGET_WAITKIND_SYSCALL_RETURN;
3540 *syscall_id = ttrace_state.tts_scno;
3546 #if defined(CHILD_THREAD_ALIVE)
3548 /* Check to see if the given thread is alive.
3550 * We'll trust the thread list, as the more correct
3551 * approach of stopping the process and spinning down
3552 * the OS's thread list is _very_ expensive.
3554 * May need a FIXME for that reason.
3557 child_thread_alive (ptid_t ptid)
3559 lwpid_t gdb_tid = PIDGET (ptid);
3562 /* This spins down the lists twice.
3563 * Possible peformance improvement here!
3565 tid = map_from_gdb_tid (gdb_tid);
3566 return !is_terminated (tid);
3573 /* This function attempts to read the specified number of bytes from the
3574 save_state_t that is our view into the hardware registers, starting at
3575 ss_offset, and ending at ss_offset + sizeof_buf - 1
3577 If this function succeeds, it deposits the fetched bytes into buf,
3580 If it fails, it returns a negative result. The contents of buf are
3581 undefined it this function fails.
3584 read_from_register_save_state (int tid, TTRACE_ARG_TYPE ss_offset, char *buf,
3588 register_value_t register_value = 0;
3590 tt_status = call_ttrace (TT_LWP_RUREGS,
3593 (TTRACE_ARG_TYPE) sizeof_buf,
3594 (TTRACE_ARG_TYPE) buf);
3597 /* Map ttrace's version of success to our version.
3598 * Sometime ttrace returns 0, but that's ok here.
3606 /* This function attempts to write the specified number of bytes to the
3607 save_state_t that is our view into the hardware registers, starting at
3608 ss_offset, and ending at ss_offset + sizeof_buf - 1
3610 If this function succeeds, it deposits the bytes in buf, and returns 0.
3612 If it fails, it returns a negative result. The contents of the save_state_t
3613 are undefined it this function fails.
3616 write_to_register_save_state (int tid, TTRACE_ARG_TYPE ss_offset, char *buf,
3620 register_value_t register_value = 0;
3622 tt_status = call_ttrace (TT_LWP_WUREGS,
3625 (TTRACE_ARG_TYPE) sizeof_buf,
3626 (TTRACE_ARG_TYPE) buf);
3631 /* This function is a sop to the largeish number of direct calls
3632 to call_ptrace that exist in other files. Rather than create
3633 functions whose name abstracts away from ptrace, and change all
3634 the present callers of call_ptrace, we'll do the expedient (and
3635 perhaps only practical) thing.
3637 Note HP-UX explicitly disallows a mix of ptrace & ttrace on a traced
3638 process. Thus, we must translate all ptrace requests into their
3639 process-specific, ttrace equivalents.
3642 call_ptrace (int pt_request, int gdb_tid, PTRACE_ARG3_TYPE addr, int data)
3645 TTRACE_ARG_TYPE tt_addr = (TTRACE_ARG_TYPE) addr;
3646 TTRACE_ARG_TYPE tt_data = (TTRACE_ARG_TYPE) data;
3647 TTRACE_ARG_TYPE tt_addr2 = TT_NIL;
3649 register_value_t register_value;
3652 /* Perform the necessary argument translation. Note that some
3653 cases are funky enough in the ttrace realm that we handle them
3658 /* The following cases cannot conveniently be handled conveniently
3659 by merely adjusting the ptrace arguments and feeding into the
3660 generic call to ttrace at the bottom of this function.
3662 Note that because all branches of this switch end in "return",
3663 there's no need for any "break" statements.
3666 return parent_attach_all (0, 0, 0);
3669 tt_status = read_from_register_save_state (gdb_tid,
3672 sizeof (register_value));
3675 return register_value;
3678 register_value = (int) tt_data;
3679 tt_status = write_to_register_save_state (gdb_tid,
3682 sizeof (register_value));
3687 tt_status = call_ttrace (TT_PROC_RDTEXT, /* Implicit 4-byte xfer becomes block-xfer. */
3690 (TTRACE_ARG_TYPE) 4,
3691 (TTRACE_ARG_TYPE) & read_buf);
3697 tt_status = call_ttrace (TT_PROC_RDDATA, /* Implicit 4-byte xfer becomes block-xfer. */
3700 (TTRACE_ARG_TYPE) 4,
3701 (TTRACE_ARG_TYPE) & read_buf);
3707 tt_status = call_real_ttrace (TT_PROC_ATTACH,
3708 map_from_gdb_tid (gdb_tid),
3711 (TTRACE_ARG_TYPE) TT_VERSION,
3717 /* The following cases are handled by merely adjusting the ptrace
3718 arguments and feeding into the generic call to ttrace.
3721 tt_request = TT_PROC_DETACH;
3725 tt_request = TT_PROC_WRTEXT; /* Translates 4-byte xfer to block-xfer. */
3726 tt_data = 4; /* This many bytes. */
3727 tt_addr2 = (TTRACE_ARG_TYPE) & data; /* Address of xfer source. */
3731 tt_request = TT_PROC_WRDATA; /* Translates 4-byte xfer to block-xfer. */
3732 tt_data = 4; /* This many bytes. */
3733 tt_addr2 = (TTRACE_ARG_TYPE) & data; /* Address of xfer source. */
3737 tt_request = TT_PROC_RDTEXT;
3741 tt_request = TT_PROC_RDDATA;
3745 tt_request = TT_PROC_WRTEXT;
3749 tt_request = TT_PROC_WRDATA;
3753 tt_request = TT_PROC_CONTINUE;
3757 tt_request = TT_LWP_SINGLE; /* Should not be making this request? */
3761 tt_request = TT_PROC_EXIT;
3764 case PT_GET_PROCESS_PATHNAME:
3765 tt_request = TT_PROC_GET_PATHNAME;
3769 tt_request = pt_request; /* Let ttrace be the one to complain. */
3773 return call_ttrace (tt_request,
3780 /* Kill that pesky process!
3783 kill_inferior (void)
3788 thread_info **paranoia;
3791 if (PIDGET (inferior_ptid) == 0)
3794 /* Walk the list of "threads", some of which are "pseudo threads",
3795 aka "processes". For each that is NOT inferior_ptid, stop it,
3798 You see, we may not have just a single process to kill. If we're
3799 restarting or quitting or detaching just after the inferior has
3800 forked, then we've actually two processes to clean up.
3802 But we can't just call target_mourn_inferior() for each, since that
3803 zaps the target vector.
3806 paranoia = (thread_info **) xmalloc (thread_head.count *
3807 sizeof (thread_info *));
3810 t = thread_head.head;
3814 paranoia[para_count] = t;
3815 for (i = 0; i < para_count; i++)
3817 if (t->next == paranoia[i])
3819 warning ("Bad data in gdb's thread data; repairing.");
3825 if (t->am_pseudo && (t->pid != PIDGET (inferior_ptid)))
3827 call_ttrace (TT_PROC_EXIT,
3838 call_ttrace (TT_PROC_EXIT,
3839 PIDGET (inferior_ptid),
3843 target_mourn_inferior ();
3844 clear_thread_info ();
3848 #ifndef CHILD_RESUME
3850 /* Sanity check a thread about to be continued.
3853 thread_dropping_event_check (thread_info *p)
3858 * This seems to happen when we "next" over a
3859 * "fork()" while following the parent. If it's
3860 * the FORK event, that's ok. If it's a SIGNAL
3861 * in the unfollowed child, that's ok to--but
3862 * how can we know that's what's going on?
3868 if (p->last_stop_state.tts_event == TTEVT_FORK)
3873 else if (p->last_stop_state.tts_event == TTEVT_SIGNAL)
3875 /* Ok, close eyes and let it happen.
3881 /* This shouldn't happen--we're dropping a
3884 warning ("About to continue process %d, thread %d with unhandled event %s.",
3886 get_printable_name_of_ttrace_event (
3887 p->last_stop_state.tts_event));
3897 /* No saved state, have to assume it failed.
3899 warning ("About to continue process %d, thread %d with unhandled event.",
3908 } /* thread_dropping_event_check */
3910 /* Use a loop over the threads to continue all the threads but
3911 * the one specified, which is to be stepped.
3914 threads_continue_all_but_one (lwpid_t gdb_tid, int signal)
3925 printf ("Using loop over threads to step/resume with signals\n");
3928 /* First update the thread list.
3931 real_tid = map_from_gdb_tid (gdb_tid);
3932 real_pid = get_pid_for (real_tid);
3934 scan_tid = get_process_first_stopped_thread_id (real_pid, &state);
3935 while (0 != scan_tid)
3939 /* FIX: later should check state is stopped;
3940 * state.tts_flags & TTS_STATEMASK == TTS_WASSUSPENDED
3943 if ((state.tts_flags & TTS_STATEMASK) != TTS_WASSUSPENDED)
3944 printf ("About to continue non-stopped thread %d\n", scan_tid);
3947 p = find_thread_info (scan_tid);
3950 add_tthread (real_pid, scan_tid);
3951 p = find_thread_info (scan_tid);
3953 /* This is either a newly-created thread or the
3954 * result of a fork; in either case there's no
3955 * actual event to worry about.
3959 if (state.tts_event != TTEVT_NONE)
3961 /* Oops, do need to worry!
3963 warning ("Unexpected thread with \"%s\" event.",
3964 get_printable_name_of_ttrace_event (state.tts_event));
3967 else if (scan_tid != p->tid)
3968 error ("Bad data in thread database.");
3973 printf ("Why are we continuing a dead thread?\n");
3978 scan_tid = get_process_next_stopped_thread_id (real_pid, &state);
3981 /* Remove unseen threads.
3983 update_thread_list ();
3985 /* Now run down the thread list and continue or step.
3987 for (p = thread_head.head; p; p = p->next)
3992 thread_dropping_event_check (p);
3994 /* Pass the correct signals along.
3998 thread_signal = p->signal_value;
4004 if (p->tid != real_tid)
4007 * Not the thread of interest, so continue it
4008 * as the user expects.
4010 if (p->stepping_mode == DO_STEP)
4012 /* Just step this thread.
4018 (TTRACE_ARG_TYPE) target_signal_to_host (signal),
4023 /* Regular continue (default case).
4029 (TTRACE_ARG_TYPE) target_signal_to_host (thread_signal),
4035 /* Step the thread of interest.
4041 (TTRACE_ARG_TYPE) target_signal_to_host (signal),
4044 } /* Loop over threads */
4045 } /* End threads_continue_all_but_one */
4047 /* Use a loop over the threads to continue all the threads.
4048 * This is done when a signal must be sent to any of the threads.
4051 threads_continue_all_with_signals (lwpid_t gdb_tid, int signal)
4062 printf ("Using loop over threads to resume with signals\n");
4065 /* Scan and update thread list.
4068 real_tid = map_from_gdb_tid (gdb_tid);
4069 real_pid = get_pid_for (real_tid);
4071 scan_tid = get_process_first_stopped_thread_id (real_pid, &state);
4072 while (0 != scan_tid)
4077 if ((state.tts_flags & TTS_STATEMASK) != TTS_WASSUSPENDED)
4078 warning ("About to continue non-stopped thread %d\n", scan_tid);
4081 p = find_thread_info (scan_tid);
4084 add_tthread (real_pid, scan_tid);
4085 p = find_thread_info (scan_tid);
4087 /* This is either a newly-created thread or the
4088 * result of a fork; in either case there's no
4089 * actual event to worry about.
4093 if (state.tts_event != TTEVT_NONE)
4095 /* Oops, do need to worry!
4097 warning ("Unexpected thread with \"%s\" event.",
4098 get_printable_name_of_ttrace_event (state.tts_event));
4105 printf ("Why are we continuing a dead thread? (1)\n");
4110 scan_tid = get_process_next_stopped_thread_id (real_pid, &state);
4113 /* Remove unseen threads from our list.
4115 update_thread_list ();
4117 /* Continue the threads.
4119 for (p = thread_head.head; p; p = p->next)
4124 thread_dropping_event_check (p);
4126 /* Pass the correct signals along.
4128 if (p->tid == real_tid)
4130 thread_signal = signal;
4133 else if (p->have_signal)
4135 thread_signal = p->signal_value;
4141 if (p->stepping_mode == DO_STEP)
4147 (TTRACE_ARG_TYPE) target_signal_to_host (signal),
4152 /* Continue this thread (default case).
4158 (TTRACE_ARG_TYPE) target_signal_to_host (thread_signal),
4162 } /* End threads_continue_all_with_signals */
4164 /* Step one thread only.
4167 thread_fake_step (lwpid_t tid, enum target_signal signal)
4174 printf ("Doing a fake-step over a bpt, etc. for %d\n", tid);
4176 if (is_terminated (tid))
4177 printf ("Why are we continuing a dead thread? (4)\n");
4181 if (doing_fake_step)
4182 warning ("Step while step already in progress.");
4184 /* See if there's a saved signal value for this
4185 * thread to be passed on, but no current signal.
4187 p = find_thread_info (tid);
4190 if (p->have_signal && signal == TARGET_SIGNAL_0)
4192 /* Pass on a saved signal.
4194 signal = p->signal_value;
4201 warning ("Internal error: continuing unhandled thread.");
4203 call_ttrace (TT_LWP_SINGLE,
4206 (TTRACE_ARG_TYPE) target_signal_to_host (signal),
4209 /* Do bookkeeping so "call_ttrace_wait" knows it has to wait
4210 * for this thread only, and clear any saved signal info.
4212 doing_fake_step = 1;
4213 fake_step_tid = tid;
4215 } /* End thread_fake_step */
4217 /* Continue one thread when a signal must be sent to it.
4220 threads_continue_one_with_signal (lwpid_t gdb_tid, int signal)
4228 printf ("Continuing one thread with a signal\n");
4231 real_tid = map_from_gdb_tid (gdb_tid);
4232 real_pid = get_pid_for (real_tid);
4234 p = find_thread_info (real_tid);
4237 add_tthread (real_pid, real_tid);
4243 printf ("Why are we continuing a dead thread? (2)\n");
4247 warning ("Internal error: continuing unhandled thread.");
4251 call_ttrace (TT_LWP_CONTINUE,
4254 (TTRACE_ARG_TYPE) target_signal_to_host (signal),
4259 #ifndef CHILD_RESUME
4261 /* Resume execution of the inferior process.
4263 * This routine is in charge of setting the "handled" bits.
4265 * If STEP is zero, continue it.
4266 * If STEP is nonzero, single-step it.
4268 * If SIGNAL is nonzero, give it that signal.
4270 * If TID is -1, apply to all threads.
4271 * If TID is not -1, apply to specified thread.
4275 * TID \________________________________________________
4277 * -1 | Step current Continue all threads
4278 * | thread and (but which gets any
4279 * | continue others signal?--We look at
4280 * | "inferior_ptid")
4282 * N | Step _this_ thread Continue _this_ thread
4283 * | and leave others and leave others
4284 * | stopped; internally stopped; used only for
4285 * | used by gdb, never hardware watchpoints
4286 * | a user command. and attach, never a
4290 child_resume (ptid_t ptid, int step, enum target_signal signal)
4292 int resume_all_threads;
4294 process_state_t new_process_state;
4295 lwpid_t gdb_tid = PIDGET (ptid);
4297 resume_all_threads =
4298 (gdb_tid == INFTTRACE_ALL_THREADS) ||
4301 if (resume_all_threads)
4303 /* Resume all threads, but first pick a tid value
4304 * so we can get the pid when in call_ttrace doing
4307 if (vfork_in_flight)
4308 tid = vforking_child_pid;
4310 tid = map_from_gdb_tid (PIDGET (inferior_ptid));
4313 tid = map_from_gdb_tid (gdb_tid);
4318 if (more_events_left)
4319 printf ("More events; ");
4322 printf ("Sending signal %d; ", signal);
4324 if (resume_all_threads)
4327 printf ("Continue process %d\n", tid);
4329 printf ("Step/continue thread %d\n", tid);
4334 printf ("Continue thread %d\n", tid);
4336 printf ("Step just thread %d\n", tid);
4339 if (vfork_in_flight)
4340 printf ("Vfork in flight\n");
4344 if (process_state == RUNNING)
4345 warning ("Internal error in resume logic; doing resume or step anyway.");
4347 if (!step /* Asked to continue... */
4348 && resume_all_threads /* whole process.. */
4349 && signal != 0 /* with a signal... */
4350 && more_events_left > 0)
4351 { /* but we can't yet--save it! */
4353 /* Continue with signal means we have to set the pending
4354 * signal value for this thread.
4360 printf ("Saving signal %d for thread %d\n", signal, tid);
4363 k = find_thread_info (tid);
4367 k->signal_value = signal;
4372 printf ("Why are we continuing a dead thread? (3)\n");
4380 printf ("No thread info for tid %d\n", tid);
4385 /* Are we faking this "continue" or "step"?
4387 * We used to do steps by continuing all the threads for
4388 * which the events had been handled already. While
4389 * conceptually nicer (hides it all in a lower level), this
4390 * can lead to starvation and a hang (e.g. all but one thread
4391 * are unhandled at a breakpoint just before a "join" operation,
4392 * and one thread is in the join, and the user wants to step that
4395 if (resume_all_threads /* Whole process, therefore user command */
4396 && more_events_left > 0)
4397 { /* But we can't do this yet--fake it! */
4402 /* No need to do any notes on a per-thread
4403 * basis--we're done!
4405 #ifdef WAIT_BUFFER_DEBUG
4407 printf ("Faking a process resume.\n");
4415 #ifdef WAIT_BUFFER_DEBUG
4417 printf ("Faking a process step.\n");
4422 p = find_thread_info (tid);
4425 warning ("No thread information for tid %d, 'next' command ignored.\n", tid);
4434 printf ("Why are we continuing a dead thread? (3.5)\n");
4437 if (p->stepping_mode != DO_DEFAULT)
4439 warning ("Step or continue command applied to thread which is already stepping or continuing; command ignored.");
4445 p->stepping_mode = DO_STEP;
4447 p->stepping_mode = DO_CONTINUE;
4450 } /* Have thread info */
4451 } /* Must fake step or go */
4453 /* Execept for fake-steps, from here on we know we are
4454 * going to wind up with a running process which will
4457 new_process_state = RUNNING;
4459 /* An address of TT_USE_CURRENT_PC tells ttrace to continue from where
4460 * it was. (If GDB wanted it to start some other way, we have already
4461 * written a new PC value to the child.)
4463 * If this system does not support PT_STEP, a higher level function will
4464 * have called single_step() to transmute the step request into a
4465 * continue request (by setting breakpoints on all possible successor
4466 * instructions), so we don't have to worry about that here.
4470 if (resume_all_threads)
4473 * Regular user step: other threads get a "continue".
4475 threads_continue_all_but_one (tid, signal);
4476 clear_all_handled ();
4477 clear_all_stepping_mode ();
4482 /* "Fake step": gdb is stepping one thread over a
4483 * breakpoint, watchpoint, or out of a library load
4484 * event, etc. The rest just stay where they are.
4486 * Also used when there are pending events: we really
4487 * step the current thread, but leave the rest stopped.
4488 * Users can't request this, but "wait_for_inferior"
4491 thread_fake_step (tid, signal);
4493 /* Clear the "handled" state of this thread, because
4494 * we'll soon get a new event for it. Other events
4495 * stay as they were.
4497 clear_handled (tid);
4498 clear_stepping_mode (tid);
4499 new_process_state = FAKE_STEPPING;
4505 /* TT_LWP_CONTINUE can pass signals to threads, TT_PROC_CONTINUE can't.
4506 Therefore, we really can't use TT_PROC_CONTINUE here.
4508 Consider a process which stopped due to signal which gdb decides
4509 to handle and not pass on to the inferior. In that case we must
4510 clear the pending signal by restarting the inferior using
4511 TT_LWP_CONTINUE and pass zero as the signal number. Else the
4512 pending signal will be passed to the inferior. interrupt.exp
4513 in the testsuite does this precise thing and fails due to the
4514 unwanted signal delivery to the inferior. */
4515 /* drow/2002-12-05: However, note that we must use TT_PROC_CONTINUE
4516 if we are tracing a vfork. */
4517 if (vfork_in_flight)
4519 call_ttrace (TT_PROC_CONTINUE, tid, TT_NIL, TT_NIL, TT_NIL);
4520 clear_all_handled ();
4521 clear_all_stepping_mode ();
4523 else if (resume_all_threads)
4527 printf ("Doing a continue by loop of all threads\n");
4530 threads_continue_all_with_signals (tid, signal);
4532 clear_all_handled ();
4533 clear_all_stepping_mode ();
4538 printf ("Doing a continue w/signal of just thread %d\n", tid);
4541 threads_continue_one_with_signal (tid, signal);
4543 /* Clear the "handled" state of this thread, because we
4544 will soon get a new event for it. Other events can
4545 stay as they were. */
4546 clear_handled (tid);
4547 clear_stepping_mode (tid);
4551 process_state = new_process_state;
4553 #ifdef WAIT_BUFFER_DEBUG
4555 printf ("Process set to %s\n",
4556 get_printable_name_of_process_state (process_state));
4560 #endif /* CHILD_RESUME */
4563 #ifdef ATTACH_DETACH
4567 * One worry is that we may not be attaching to "inferior_ptid"
4568 * and thus may not want to clear out our data. FIXME?
4572 update_thread_state_after_attach (int pid, attach_continue_t kind_of_go)
4575 ttstate_t thread_state;
4579 /* The process better be stopped.
4581 if (process_state != STOPPED
4582 && process_state != VFORKING)
4583 warning ("Internal error attaching.");
4585 /* Clear out old tthread info and start over. This has the
4586 * side effect of ensuring that the TRAP is reported as being
4587 * in the right thread (re-mapped from tid to pid).
4589 * It's because we need to add the tthread _now_ that we
4590 * need to call "clear_thread_info" _now_, and that's why
4591 * "require_notification_of_events" doesn't clear the thread
4592 * info (it's called later than this routine).
4594 clear_thread_info ();
4597 for (tid = get_process_first_stopped_thread_id (pid, &thread_state);
4599 tid = get_process_next_stopped_thread_id (pid, &thread_state))
4608 printf ("Attaching to process %d, thread %d\n",
4613 /* Tell ourselves and the "rest of gdb" that this thread
4616 * This isn't really a hack. Other thread-based versions
4617 * of gdb (e.g. gnu-nat.c) seem to do the same thing.
4619 * We don't need to do mapping here, as we know this
4620 * is the first thread and thus gets the real pid
4621 * (and is "inferior_ptid").
4623 * NOTE: it probably isn't the originating thread,
4624 * but that doesn't matter (we hope!).
4626 add_tthread (pid, tid);
4627 p = find_thread_info (tid);
4628 if (NULL == p) /* ?We just added it! */
4629 error ("Internal error adding a thread on attach.");
4631 copy_ttstate_t (&p->last_stop_state, &thread_state);
4634 if (DO_ATTACH_CONTINUE == kind_of_go)
4637 * If we are going to CONTINUE afterwards,
4638 * raising a SIGTRAP, don't bother trying to
4639 * handle this event. But check first!
4641 switch (p->last_stop_state.tts_event)
4645 /* Ok to set this handled.
4650 warning ("Internal error; skipping event %s on process %d, thread %d.",
4651 get_printable_name_of_ttrace_event (
4652 p->last_stop_state.tts_event),
4656 set_handled (pid, tid);
4661 /* There will be no "continue" opertion, so the
4662 * process remains stopped. Don't set any events
4663 * handled except the "gimmies".
4665 switch (p->last_stop_state.tts_event)
4669 /* Ok to ignore this.
4671 set_handled (pid, tid);
4676 /* Expected "other" FORK or EXEC event from a
4682 printf ("Internal error: failed to handle event %s on process %d, thread %d.",
4683 get_printable_name_of_ttrace_event (
4684 p->last_stop_state.tts_event),
4689 add_thread (pid_to_ptid (pid)); /* in thread.c */
4697 /* One mustn't call ttrace_wait() after attaching via ttrace,
4698 'cause the process is stopped already.
4700 However, the upper layers of gdb's execution control will
4701 want to wait after attaching (but not after forks, in
4702 which case they will be doing a "target_resume", anticipating
4703 a later TTEVT_EXEC or TTEVT_FORK event).
4705 To make this attach() implementation more compatible with
4706 others, we'll make the attached-to process raise a SIGTRAP.
4708 Issue: this continues only one thread. That could be
4709 dangerous if the thread is blocked--the process won't run
4710 and no trap will be raised. FIX! (check state.tts_flags?
4711 need one that's either TTS_WASRUNNING--but we've stopped
4712 it and made it TTS_WASSUSPENDED. Hum...FIXME!)
4714 if (DO_ATTACH_CONTINUE == kind_of_go)
4716 tt_status = call_real_ttrace (
4721 (TTRACE_ARG_TYPE) target_signal_to_host (TARGET_SIGNAL_TRAP),
4724 perror_with_name ("ttrace");
4726 clear_handled (a_thread); /* So TRAP will be reported. */
4730 process_state = RUNNING;
4735 #endif /* ATTACH_DETACH */
4738 #ifdef ATTACH_DETACH
4739 /* Start debugging the process whose number is PID.
4747 tt_status = call_real_ttrace (
4752 (TTRACE_ARG_TYPE) TT_VERSION,
4755 perror_with_name ("ttrace attach");
4757 /* If successful, the process is now stopped.
4759 process_state = STOPPED;
4761 /* Our caller ("attach_command" in "infcmd.c")
4762 * expects to do a "wait_for_inferior" after
4763 * the attach, so make sure the inferior is
4764 * running when we're done.
4766 update_thread_state_after_attach (pid, DO_ATTACH_CONTINUE);
4772 #if defined(CHILD_POST_ATTACH)
4774 child_post_attach (int pid)
4778 printf ("child-post-attach call\n");
4781 require_notification_of_events (pid);
4786 /* Stop debugging the process whose number is PID
4787 and continue it with signal number SIGNAL.
4788 SIGNAL = 0 means just continue it.
4794 call_ttrace (TT_PROC_DETACH,
4795 PIDGET (inferior_ptid),
4797 (TTRACE_ARG_TYPE) signal,
4801 clear_thread_info ();
4803 /* Process-state? */
4805 #endif /* ATTACH_DETACH */
4808 /* Default the type of the ttrace transfer to int. */
4809 #ifndef TTRACE_XFER_TYPE
4810 #define TTRACE_XFER_TYPE int
4814 _initialize_kernel_u_addr (void)
4818 #if !defined (CHILD_XFER_MEMORY)
4819 /* NOTE! I tried using TTRACE_READDATA, etc., to read and write memory
4820 in the NEW_SUN_TTRACE case.
4821 It ought to be straightforward. But it appears that writing did
4822 not write the data that I specified. I cannot understand where
4823 it got the data that it actually did write. */
4825 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
4826 to debugger memory starting at MYADDR. Copy to inferior if
4827 WRITE is nonzero. TARGET is ignored.
4829 Returns the length copied, which is either the LEN argument or zero.
4830 This xfer function does not do partial moves, since child_ops
4831 doesn't allow memory operations to cross below us in the target stack
4835 child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
4836 struct mem_attrib *attrib,
4837 struct target_ops *target)
4840 /* Round starting address down to longword boundary. */
4841 CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (TTRACE_XFER_TYPE);
4842 /* Round ending address up; get number of longwords that makes. */
4844 = (((memaddr + len) - addr) + sizeof (TTRACE_XFER_TYPE) - 1)
4845 / sizeof (TTRACE_XFER_TYPE);
4846 /* Allocate buffer of that many longwords. */
4847 /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
4848 because it uses alloca to allocate a buffer of arbitrary size.
4849 For very large xfers, this could crash GDB's stack. */
4850 TTRACE_XFER_TYPE *buffer
4851 = (TTRACE_XFER_TYPE *) alloca (count * sizeof (TTRACE_XFER_TYPE));
4855 /* Fill start and end extra bytes of buffer with existing memory data. */
4857 if (addr != memaddr || len < (int) sizeof (TTRACE_XFER_TYPE))
4859 /* Need part of initial word -- fetch it. */
4860 buffer[0] = call_ttrace (TT_LWP_RDTEXT,
4861 PIDGET (inferior_ptid),
4862 (TTRACE_ARG_TYPE) addr,
4867 if (count > 1) /* FIXME, avoid if even boundary */
4869 buffer[count - 1] = call_ttrace (TT_LWP_RDTEXT,
4870 PIDGET (inferior_ptid),
4872 (addr + (count - 1) * sizeof (TTRACE_XFER_TYPE))),
4877 /* Copy data to be written over corresponding part of buffer */
4879 memcpy ((char *) buffer + (memaddr & (sizeof (TTRACE_XFER_TYPE) - 1)),
4883 /* Write the entire buffer. */
4885 for (i = 0; i < count; i++, addr += sizeof (TTRACE_XFER_TYPE))
4888 call_ttrace (TT_LWP_WRDATA,
4889 PIDGET (inferior_ptid),
4890 (TTRACE_ARG_TYPE) addr,
4891 (TTRACE_ARG_TYPE) buffer[i],
4895 /* Using the appropriate one (I or D) is necessary for
4896 Gould NP1, at least. */
4898 call_ttrace (TT_LWP_WRTEXT,
4899 PIDGET (inferior_ptid),
4900 (TTRACE_ARG_TYPE) addr,
4901 (TTRACE_ARG_TYPE) buffer[i],
4910 /* Read all the longwords */
4911 for (i = 0; i < count; i++, addr += sizeof (TTRACE_XFER_TYPE))
4914 buffer[i] = call_ttrace (TT_LWP_RDTEXT,
4915 PIDGET (inferior_ptid),
4916 (TTRACE_ARG_TYPE) addr,
4924 /* Copy appropriate bytes out of the buffer. */
4926 (char *) buffer + (memaddr & (sizeof (TTRACE_XFER_TYPE) - 1)),
4936 int udot_off; /* Offset into user struct */
4937 int udot_val; /* Value from user struct at udot_off */
4938 char mess[128]; /* For messages */
4940 if (!target_has_execution)
4942 error ("The program is not being run.");
4945 #if !defined (KERNEL_U_SIZE)
4947 /* Adding support for this command is easy. Typically you just add a
4948 routine, called "kernel_u_size" that returns the size of the user
4949 struct, to the appropriate *-nat.c file and then add to the native
4950 config file "#define KERNEL_U_SIZE kernel_u_size()" */
4951 error ("Don't know how large ``struct user'' is in this version of gdb.");
4955 for (udot_off = 0; udot_off < KERNEL_U_SIZE; udot_off += sizeof (udot_val))
4957 if ((udot_off % 24) == 0)
4961 printf_filtered ("\n");
4963 printf_filtered ("%04x:", udot_off);
4965 udot_val = call_ttrace (TT_LWP_RUREGS,
4966 PIDGET (inferior_ptid),
4967 (TTRACE_ARG_TYPE) udot_off,
4972 sprintf (mess, "\nreading user struct at offset 0x%x", udot_off);
4973 perror_with_name (mess);
4975 /* Avoid using nonportable (?) "*" in print specs */
4976 printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val);
4978 printf_filtered ("\n");
4982 #endif /* !defined (CHILD_XFER_MEMORY). */
4985 /* TTrace version of "target_pid_to_exec_file"
4988 child_pid_to_exec_file (int tid)
4991 static char exec_file_buffer[1024];
4993 static struct pst_status buf;
4995 /* On various versions of hpux11, this may fail due to a supposed
4996 kernel bug. We have alternate methods to get this information
4998 tt_status = call_ttrace (TT_PROC_GET_PATHNAME,
5000 (uint64_t) exec_file_buffer,
5001 sizeof (exec_file_buffer) - 1,
5004 return exec_file_buffer;
5006 /* Try to get process information via pstat and extract the filename
5007 from the pst_cmd field within the pst_status structure. */
5008 if (pstat_getproc (&buf, sizeof (struct pst_status), 0, tid) != -1)
5010 char *p = buf.pst_cmd;
5012 while (*p && *p != ' ')
5016 return (buf.pst_cmd);
5023 pre_fork_inferior (void)
5027 status = pipe (startup_semaphore.parent_channel);
5030 warning ("error getting parent pipe for startup semaphore");
5034 status = pipe (startup_semaphore.child_channel);
5037 warning ("error getting child pipe for startup semaphore");
5042 /* Called from child_follow_fork in hppah-nat.c.
5044 * This seems to be intended to attach after a fork or
5045 * vfork, while "attach" is used to attach to a pid
5046 * given by the user. The check for an existing attach
5047 * seems odd--it always fails in our test system.
5050 hppa_require_attach (int pid)
5055 unsigned int regs_offset;
5056 process_state_t old_process_state = process_state;
5058 /* Are we already attached? There appears to be no explicit
5059 * way to answer this via ttrace, so we try something which
5060 * should be innocuous if we are attached. If that fails,
5061 * then we assume we're not attached, and so attempt to make
5065 tt_status = call_real_ttrace (TT_PROC_STOP,
5068 (TTRACE_ARG_TYPE) TT_NIL,
5069 (TTRACE_ARG_TYPE) TT_NIL,
5074 /* No change to process-state!
5081 /* If successful, the process is now stopped. But if
5082 * we're VFORKING, the parent is still running, so don't
5083 * change the process state.
5085 if (process_state != VFORKING)
5086 process_state = STOPPED;
5088 /* If we were already attached, you'd think that we
5089 * would need to start going again--but you'd be wrong,
5090 * as the fork-following code is actually in the middle
5091 * of the "resume" routine in in "infrun.c" and so
5092 * will (almost) immediately do a resume.
5094 * On the other hand, if we are VFORKING, which means
5095 * that the child and the parent share a process for a
5096 * while, we know that "resume" won't be resuming
5097 * until the child EXEC event is seen. But we still
5098 * don't want to continue, as the event is already
5101 update_thread_state_after_attach (pid, DONT_ATTACH_CONTINUE);
5102 } /* STOP succeeded */
5108 hppa_require_detach (int pid, int signal)
5112 /* If signal is non-zero, we must pass the signal on to the active
5113 thread prior to detaching. We do this by continuing the threads
5119 threads_continue_all_with_signals (pid, signal);
5123 tt_status = call_ttrace (TT_PROC_DETACH,
5129 errno = 0; /* Ignore any errors. */
5131 /* process_state? */
5136 /* Given the starting address of a memory page, hash it to a bucket in
5137 the memory page dictionary.
5140 get_dictionary_bucket_of_page (CORE_ADDR page_start)
5144 hash = (page_start / memory_page_dictionary.page_size);
5145 hash = hash % MEMORY_PAGE_DICTIONARY_BUCKET_COUNT;
5151 /* Given a memory page's starting address, get (i.e., find an existing
5152 or create a new) dictionary entry for the page. The page will be
5153 write-protected when this function returns, but may have a reference
5154 count of 0 (if the page was newly-added to the dictionary).
5156 static memory_page_t *
5157 get_dictionary_entry_of_page (int pid, CORE_ADDR page_start)
5160 memory_page_t *page = NULL;
5161 memory_page_t *previous_page = NULL;
5163 /* We're going to be using the dictionary now, than-kew. */
5164 require_memory_page_dictionary ();
5166 /* Try to find an existing dictionary entry for this page. Hash
5167 on the page's starting address.
5169 bucket = get_dictionary_bucket_of_page (page_start);
5170 page = &memory_page_dictionary.buckets[bucket];
5171 while (page != NULL)
5173 if (page->page_start == page_start)
5175 previous_page = page;
5179 /* Did we find a dictionary entry for this page? If not, then
5180 add it to the dictionary now.
5184 /* Create a new entry. */
5185 page = (memory_page_t *) xmalloc (sizeof (memory_page_t));
5186 page->page_start = page_start;
5187 page->reference_count = 0;
5189 page->previous = NULL;
5191 /* We'll write-protect the page now, if that's allowed. */
5192 page->original_permissions = write_protect_page (pid, page_start);
5194 /* Add the new entry to the dictionary. */
5195 page->previous = previous_page;
5196 previous_page->next = page;
5198 memory_page_dictionary.page_count++;
5206 remove_dictionary_entry_of_page (int pid, memory_page_t *page)
5208 /* Restore the page's original permissions. */
5209 unwrite_protect_page (pid, page->page_start, page->original_permissions);
5211 /* Kick the page out of the dictionary. */
5212 if (page->previous != NULL)
5213 page->previous->next = page->next;
5214 if (page->next != NULL)
5215 page->next->previous = page->previous;
5217 /* Just in case someone retains a handle to this after it's freed. */
5218 page->page_start = (CORE_ADDR) 0;
5220 memory_page_dictionary.page_count--;
5227 hppa_enable_syscall_events (int pid)
5230 ttevent_t ttrace_events;
5232 /* Get the set of events that are currently enabled. */
5233 tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
5235 (TTRACE_ARG_TYPE) & ttrace_events,
5236 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
5239 perror_with_name ("ttrace");
5241 /* Add syscall events to that set. */
5242 ttrace_events.tte_events |= TTEVT_SYSCALL_ENTRY;
5243 ttrace_events.tte_events |= TTEVT_SYSCALL_RETURN;
5245 tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
5247 (TTRACE_ARG_TYPE) & ttrace_events,
5248 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
5251 perror_with_name ("ttrace");
5256 hppa_disable_syscall_events (int pid)
5259 ttevent_t ttrace_events;
5261 /* Get the set of events that are currently enabled. */
5262 tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
5264 (TTRACE_ARG_TYPE) & ttrace_events,
5265 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
5268 perror_with_name ("ttrace");
5270 /* Remove syscall events from that set. */
5271 ttrace_events.tte_events &= ~TTEVT_SYSCALL_ENTRY;
5272 ttrace_events.tte_events &= ~TTEVT_SYSCALL_RETURN;
5274 tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
5276 (TTRACE_ARG_TYPE) & ttrace_events,
5277 (TTRACE_ARG_TYPE) sizeof (ttrace_events),
5280 perror_with_name ("ttrace");
5284 /* The address range beginning with START and ending with START+LEN-1
5285 (inclusive) is to be watched via page-protection by a new watchpoint.
5286 Set protection for all pages that overlap that range.
5288 Note that our caller sets TYPE to:
5289 0 for a bp_hardware_watchpoint,
5290 1 for a bp_read_watchpoint,
5291 2 for a bp_access_watchpoint
5293 (Yes, this is intentionally (though lord only knows why) different
5294 from the TYPE that is passed to hppa_remove_hw_watchpoint.)
5297 hppa_insert_hw_watchpoint (int pid, CORE_ADDR start, LONGEST len, int type)
5299 CORE_ADDR page_start;
5300 int dictionary_was_empty;
5303 LONGEST range_size_in_pages;
5306 error ("read or access hardware watchpoints not supported on HP-UX");
5308 /* Examine all pages in the address range. */
5309 require_memory_page_dictionary ();
5311 dictionary_was_empty = (memory_page_dictionary.page_count == (LONGEST) 0);
5313 page_size = memory_page_dictionary.page_size;
5314 page_start = (start / page_size) * page_size;
5315 range_size_in_pages = ((LONGEST) len + (LONGEST) page_size - 1) / (LONGEST) page_size;
5317 for (page_id = 0; page_id < range_size_in_pages; page_id++, page_start += page_size)
5319 memory_page_t *page;
5321 /* This gets the page entered into the dictionary if it was
5322 not already entered.
5324 page = get_dictionary_entry_of_page (pid, page_start);
5325 page->reference_count++;
5328 /* Our implementation depends on seeing calls to kernel code, for the
5329 following reason. Here we ask to be notified of syscalls.
5331 When a protected page is accessed by user code, HP-UX raises a SIGBUS.
5334 But when kernel code accesses the page, it doesn't give a SIGBUS.
5335 Rather, the system call that touched the page fails, with errno=EFAULT.
5338 We could accomodate this "feature" by asking to be notified of syscall
5339 entries & exits; upon getting an entry event, disabling page-protections;
5340 upon getting an exit event, reenabling page-protections and then checking
5341 if any watchpoints triggered.
5343 However, this turns out to be a real performance loser. syscalls are
5344 usually a frequent occurrence. Having to unprotect-reprotect all watched
5345 pages, and also to then read all watched memory locations and compare for
5346 triggers, can be quite expensive.
5348 Instead, we'll only ask to be notified of syscall exits. When we get
5349 one, we'll check whether errno is set. If not, or if it's not EFAULT,
5350 we can just continue the inferior.
5352 If errno is set upon syscall exit to EFAULT, we must perform some fairly
5353 hackish stuff to determine whether the failure really was due to a
5354 page-protect trap on a watched location.
5356 if (dictionary_was_empty)
5357 hppa_enable_syscall_events (pid);
5363 /* The address range beginning with START and ending with START+LEN-1
5364 (inclusive) was being watched via page-protection by a watchpoint
5365 which has been removed. Remove protection for all pages that
5366 overlap that range, which are not also being watched by other
5370 hppa_remove_hw_watchpoint (int pid, CORE_ADDR start, LONGEST len, int type)
5372 CORE_ADDR page_start;
5373 int dictionary_is_empty;
5376 LONGEST range_size_in_pages;
5379 error ("read or access hardware watchpoints not supported on HP-UX");
5381 /* Examine all pages in the address range. */
5382 require_memory_page_dictionary ();
5384 page_size = memory_page_dictionary.page_size;
5385 page_start = (start / page_size) * page_size;
5386 range_size_in_pages = ((LONGEST) len + (LONGEST) page_size - 1) / (LONGEST) page_size;
5388 for (page_id = 0; page_id < range_size_in_pages; page_id++, page_start += page_size)
5390 memory_page_t *page;
5392 page = get_dictionary_entry_of_page (pid, page_start);
5393 page->reference_count--;
5395 /* Was this the last reference of this page? If so, then we
5396 must scrub the entry from the dictionary, and also restore
5397 the page's original permissions.
5399 if (page->reference_count == 0)
5400 remove_dictionary_entry_of_page (pid, page);
5403 dictionary_is_empty = (memory_page_dictionary.page_count == (LONGEST) 0);
5405 /* If write protections are currently disallowed, then that implies that
5406 wait_for_inferior believes that the inferior is within a system call.
5407 Since we want to see both syscall entry and return, it's clearly not
5408 good to disable syscall events in this state!
5410 ??rehrauer: Yeah, it'd be better if we had a specific flag that said,
5411 "inferior is between syscall events now". Oh well.
5413 if (dictionary_is_empty && memory_page_dictionary.page_protections_allowed)
5414 hppa_disable_syscall_events (pid);
5420 /* Could we implement a watchpoint of this type via our available
5423 This query does not consider whether a particular address range
5424 could be so watched, but just whether support is generally available
5425 for such things. See hppa_range_profitable_for_hw_watchpoint for a
5426 query that answers whether a particular range should be watched via
5430 hppa_can_use_hw_watchpoint (int type, int cnt, int ot)
5432 return (type == bp_hardware_watchpoint);
5436 /* Assuming we could set a hardware watchpoint on this address, do
5437 we think it would be profitable ("a good idea") to do so? If not,
5438 we can always set a regular (aka single-step & test) watchpoint
5442 hppa_range_profitable_for_hw_watchpoint (int pid, CORE_ADDR start, LONGEST len)
5444 int range_is_stack_based;
5445 int range_is_accessible;
5446 CORE_ADDR page_start;
5449 LONGEST range_size_in_pages;
5451 /* ??rehrauer: For now, say that all addresses are potentially
5452 profitable. Possibly later we'll want to test the address
5455 range_is_stack_based = 0;
5457 /* If any page in the range is inaccessible, then we cannot
5458 really use hardware watchpointing, even though our client
5459 thinks we can. In that case, it's actually an error to
5460 attempt to use hw watchpoints, so we'll tell our client
5461 that the range is "unprofitable", and hope that they listen...
5463 range_is_accessible = 1; /* Until proven otherwise. */
5465 /* Examine all pages in the address range. */
5467 page_size = sysconf (_SC_PAGE_SIZE);
5469 /* If we can't determine page size, we're hosed. Tell our
5470 client it's unprofitable to use hw watchpoints for this
5473 if (errno || (page_size <= 0))
5479 page_start = (start / page_size) * page_size;
5480 range_size_in_pages = len / (LONGEST) page_size;
5482 for (page = 0; page < range_size_in_pages; page++, page_start += page_size)
5485 int page_permissions;
5487 /* Is this page accessible? */
5489 tt_status = call_ttrace (TT_PROC_GET_MPROTECT,
5491 (TTRACE_ARG_TYPE) page_start,
5493 (TTRACE_ARG_TYPE) & page_permissions);
5494 if (errno || (tt_status < 0))
5497 range_is_accessible = 0;
5501 /* Yes, go for another... */
5504 return (!range_is_stack_based && range_is_accessible);
5509 hppa_pid_or_tid_to_str (ptid_t ptid)
5511 static char buf[100]; /* Static because address returned. */
5512 pid_t id = PIDGET (ptid);
5514 /* Does this appear to be a process? If so, print it that way. */
5515 if (is_process_id (id))
5516 return child_pid_to_str (ptid);
5518 /* Else, print both the GDB thread number and the system thread id. */
5519 sprintf (buf, "thread %d (", pid_to_thread_id (ptid));
5520 strcat (buf, hppa_tid_to_str (ptid));
5521 strcat (buf, ")\0");
5528 hppa_ensure_vforking_parent_remains_stopped (int pid)
5530 /* Nothing to do when using ttrace. Only the ptrace-based implementation
5537 hppa_resume_execd_vforking_child_to_get_parent_vfork (void)
5539 return 0; /* No, the parent vfork is available now. */
5543 /* Write a register as a 64bit value. This may be necessary if the
5544 native OS is too braindamaged to allow some (or all) registers to
5545 be written in 32bit hunks such as hpux11 and the PC queue registers.
5547 This is horribly gross and disgusting. */
5550 ttrace_write_reg_64 (int gdb_tid, CORE_ADDR dest_addr, CORE_ADDR src_addr)
5556 tid = map_from_gdb_tid (gdb_tid);
5557 pid = get_pid_for (tid);
5560 tt_status = ttrace (TT_LWP_WUREGS,
5563 (TTRACE_ARG_TYPE) dest_addr,
5565 (TTRACE_ARG_TYPE) src_addr );
5570 /* Don't bother for a known benign error: if you ask for the
5571 first thread state, but there is only one thread and it's
5572 not stopped, ttrace complains.
5574 We have this inside the #ifdef because our caller will do
5575 this check for real. */
5576 if( request != TT_PROC_GET_FIRST_LWP_STATE
5577 || errno != EPROTO )
5580 printf( "TT fail for %s, with pid %d, tid %d, status %d \n",
5581 get_printable_name_of_ttrace_request (TT_LWP_WUREGS),
5582 pid, tid, tt_status );
5591 _initialize_infttrace (void)
5593 /* Initialize the ttrace-based hardware watchpoint implementation. */
5594 memory_page_dictionary.page_count = (LONGEST) - 1;
5595 memory_page_dictionary.page_protections_allowed = 1;
5598 memory_page_dictionary.page_size = sysconf (_SC_PAGE_SIZE);
5600 /* We do a lot of casts from pointers to TTRACE_ARG_TYPE; make sure
5602 if (sizeof (TTRACE_ARG_TYPE) < sizeof (void *))
5603 internal_error (__FILE__, __LINE__, "failed internal consistency check");
5605 if (errno || (memory_page_dictionary.page_size <= 0))
5606 perror_with_name ("sysconf");