1 /* Low-level child interface to ttrace.
3 Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* The ttrace(2) system call didn't exist before HP-UX 10.30. Don't
23 try to compile this code unless we have it. */
28 #include "gdbthread.h"
32 #include "gdb_assert.h"
33 #include "gdb_string.h"
35 #include <sys/ttrace.h>
38 #include "inf-child.h"
39 #include "inf-ttrace.h"
41 /* HACK: Save the ttrace ops returned by inf_ttrace_target. */
42 static struct target_ops
*ttrace_ops_hack
;
45 /* HP-UX uses a threading model where each user-space thread
46 corresponds to a kernel thread. These kernel threads are called
47 lwps. The ttrace(2) interface gives us almost full control over
48 the threads, which makes it very easy to support them in GDB. We
49 identify the threads by process ID and lwp ID. The ttrace(2) also
50 provides us with a thread's user ID (in the `tts_user_tid' member
51 of `ttstate_t') but we don't use that (yet) as it isn't necessary
52 to uniquely label the thread. */
54 /* Number of active lwps. */
55 static int inf_ttrace_num_lwps
;
58 /* On HP-UX versions that have the ttrace(2) system call, we can
59 implement "hardware" watchpoints by fiddling with the protection of
60 pages in the address space that contain the variable being watched.
61 In order to implement this, we keep a dictionary of pages for which
62 we have changed the protection. */
64 struct inf_ttrace_page
66 CORE_ADDR addr
; /* Page address. */
67 int prot
; /* Protection. */
68 int refcount
; /* Reference count. */
69 struct inf_ttrace_page
*next
;
70 struct inf_ttrace_page
*prev
;
73 struct inf_ttrace_page_dict
75 struct inf_ttrace_page buckets
[128];
76 int pagesize
; /* Page size. */
77 int count
; /* Number of pages in this dictionary. */
78 } inf_ttrace_page_dict
;
80 struct inf_ttrace_private_thread_info
85 /* Number of lwps that are currently in a system call. */
86 static int inf_ttrace_num_lwps_in_syscall
;
88 /* Flag to indicate whether we should re-enable page protections after
90 static int inf_ttrace_reenable_page_protections
;
92 /* Enable system call events for process PID. */
95 inf_ttrace_enable_syscall_events (pid_t pid
)
100 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
102 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
103 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
104 perror_with_name (("ttrace"));
106 tte
.tte_events
|= (TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
108 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
109 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
110 perror_with_name (("ttrace"));
112 if (ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
113 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
114 perror_with_name (("ttrace"));
116 if (tts
.tts_flags
& TTS_INSYSCALL
)
117 inf_ttrace_num_lwps_in_syscall
++;
119 /* FIXME: Handle multiple threads. */
122 /* Disable system call events for process PID. */
125 inf_ttrace_disable_syscall_events (pid_t pid
)
129 gdb_assert (inf_ttrace_page_dict
.count
== 0);
131 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
132 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
133 perror_with_name (("ttrace"));
135 tte
.tte_events
&= ~(TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
137 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
138 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
139 perror_with_name (("ttrace"));
141 inf_ttrace_num_lwps_in_syscall
= 0;
144 /* Get information about the page at address ADDR for process PID from
147 static struct inf_ttrace_page
*
148 inf_ttrace_get_page (pid_t pid
, CORE_ADDR addr
)
150 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
151 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
153 struct inf_ttrace_page
*page
;
155 bucket
= (addr
/ pagesize
) % num_buckets
;
156 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
159 if (page
->addr
== addr
)
168 /* Add the page at address ADDR for process PID to the dictionary. */
170 static struct inf_ttrace_page
*
171 inf_ttrace_add_page (pid_t pid
, CORE_ADDR addr
)
173 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
174 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
176 struct inf_ttrace_page
*page
;
177 struct inf_ttrace_page
*prev
= NULL
;
179 bucket
= (addr
/ pagesize
) % num_buckets
;
180 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
183 if (page
->addr
== addr
)
194 if (ttrace (TT_PROC_GET_MPROTECT
, pid
, 0,
195 addr
, 0, (uintptr_t)&prot
) == -1)
196 perror_with_name (("ttrace"));
198 page
= XMALLOC (struct inf_ttrace_page
);
207 inf_ttrace_page_dict
.count
++;
208 if (inf_ttrace_page_dict
.count
== 1)
209 inf_ttrace_enable_syscall_events (pid
);
211 if (inf_ttrace_num_lwps_in_syscall
== 0)
213 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
214 addr
, pagesize
, prot
& ~PROT_WRITE
) == -1)
215 perror_with_name (("ttrace"));
222 /* Insert the page at address ADDR of process PID to the dictionary. */
225 inf_ttrace_insert_page (pid_t pid
, CORE_ADDR addr
)
227 struct inf_ttrace_page
*page
;
229 page
= inf_ttrace_get_page (pid
, addr
);
231 page
= inf_ttrace_add_page (pid
, addr
);
236 /* Remove the page at address ADDR of process PID from the dictionary. */
239 inf_ttrace_remove_page (pid_t pid
, CORE_ADDR addr
)
241 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
242 struct inf_ttrace_page
*page
;
244 page
= inf_ttrace_get_page (pid
, addr
);
247 gdb_assert (page
->refcount
>= 0);
249 if (page
->refcount
== 0)
251 if (inf_ttrace_num_lwps_in_syscall
== 0)
253 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
254 addr
, pagesize
, page
->prot
) == -1)
255 perror_with_name (("ttrace"));
258 inf_ttrace_page_dict
.count
--;
259 if (inf_ttrace_page_dict
.count
== 0)
260 inf_ttrace_disable_syscall_events (pid
);
262 page
->prev
->next
= page
->next
;
264 page
->next
->prev
= page
->prev
;
270 /* Mask the bits in PROT from the page protections that are currently
271 in the dictionary for process PID. */
274 inf_ttrace_mask_page_protections (pid_t pid
, int prot
)
276 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
277 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
280 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
282 struct inf_ttrace_page
*page
;
284 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
287 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
288 page
->addr
, pagesize
, page
->prot
& ~prot
) == -1)
289 perror_with_name (("ttrace"));
296 /* Write-protect the pages in the dictionary for process PID. */
299 inf_ttrace_enable_page_protections (pid_t pid
)
301 inf_ttrace_mask_page_protections (pid
, PROT_WRITE
);
304 /* Restore the protection of the pages in the dictionary for process
308 inf_ttrace_disable_page_protections (pid_t pid
)
310 inf_ttrace_mask_page_protections (pid
, 0);
313 /* Insert a "hardware" watchpoint for LEN bytes at address ADDR of
317 inf_ttrace_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
319 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
320 pid_t pid
= ptid_get_pid (inferior_ptid
);
325 gdb_assert (type
== hw_write
);
327 page_addr
= (addr
/ pagesize
) * pagesize
;
328 num_pages
= (len
+ pagesize
- 1) / pagesize
;
330 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
331 inf_ttrace_insert_page (pid
, page_addr
);
336 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
340 inf_ttrace_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
342 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
343 pid_t pid
= ptid_get_pid (inferior_ptid
);
348 gdb_assert (type
== hw_write
);
350 page_addr
= (addr
/ pagesize
) * pagesize
;
351 num_pages
= (len
+ pagesize
- 1) / pagesize
;
353 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
354 inf_ttrace_remove_page (pid
, page_addr
);
360 inf_ttrace_can_use_hw_breakpoint (int type
, int len
, int ot
)
362 return (type
== bp_hardware_watchpoint
);
366 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
371 /* Return non-zero if the current inferior was (potentially) stopped
372 by hitting a "hardware" watchpoint. */
375 inf_ttrace_stopped_by_watchpoint (void)
377 pid_t pid
= ptid_get_pid (inferior_ptid
);
378 lwpid_t lwpid
= ptid_get_lwp (inferior_ptid
);
381 if (inf_ttrace_page_dict
.count
> 0)
383 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
384 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
385 perror_with_name (("ttrace"));
387 if (tts
.tts_event
== TTEVT_SIGNAL
388 && tts
.tts_u
.tts_signal
.tts_signo
== SIGBUS
)
390 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
391 void *addr
= tts
.tts_u
.tts_signal
.tts_siginfo
.si_addr
;
392 CORE_ADDR page_addr
= ((uintptr_t)addr
/ pagesize
) * pagesize
;
394 if (inf_ttrace_get_page (pid
, page_addr
))
403 /* When tracking a vfork(2), we cannot detach from the parent until
404 after the child has called exec(3) or has exited. If we are still
405 attached to the parent, this variable will be set to the process ID
406 of the parent. Otherwise it will be set to zero. */
407 static pid_t inf_ttrace_vfork_ppid
= -1;
410 inf_ttrace_follow_fork (struct target_ops
*ops
, int follow_child
)
413 lwpid_t lwpid
, flwpid
;
416 /* FIXME: kettenis/20050720: This stuff should really be passed as
417 an argument by our caller. */
420 struct target_waitstatus status
;
422 get_last_target_status (&ptid
, &status
);
423 gdb_assert (status
.kind
== TARGET_WAITKIND_FORKED
424 || status
.kind
== TARGET_WAITKIND_VFORKED
);
426 pid
= ptid_get_pid (ptid
);
427 lwpid
= ptid_get_lwp (ptid
);
430 /* Get all important details that core GDB doesn't (and shouldn't)
432 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
433 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
434 perror_with_name (("ttrace"));
436 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
438 if (tts
.tts_u
.tts_fork
.tts_isparent
)
441 lwpid
= tts
.tts_lwpid
;
442 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
443 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
447 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
448 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
450 flwpid
= tts
.tts_lwpid
;
455 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
456 detach_breakpoints (pid
);
458 target_terminal_ours ();
459 fprintf_unfiltered (gdb_stdlog
, _("\
460 Attaching after fork to child process %ld.\n"), (long)fpid
);
464 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
465 detach_breakpoints (fpid
);
467 target_terminal_ours ();
468 fprintf_unfiltered (gdb_stdlog
, _("\
469 Detaching after fork from child process %ld.\n"), (long)fpid
);
472 if (tts
.tts_event
== TTEVT_VFORK
)
474 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
478 /* We can't detach from the parent yet. */
479 inf_ttrace_vfork_ppid
= pid
;
481 reattach_breakpoints (fpid
);
485 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
486 perror_with_name (("ttrace"));
488 /* Wait till we get the TTEVT_VFORK event in the parent.
489 This indicates that the child has called exec(3) or has
490 exited and that the parent is ready to be traced again. */
491 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
492 perror_with_name (("ttrace_wait"));
493 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
494 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
496 reattach_breakpoints (pid
);
501 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
505 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
506 perror_with_name (("ttrace"));
510 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
511 perror_with_name (("ttrace"));
517 struct thread_info
*ti
;
519 /* The child will start out single-threaded. */
520 inf_ttrace_num_lwps
= 1;
521 inf_ttrace_num_lwps_in_syscall
= 0;
524 delete_thread_silent (ptid_build (pid
, lwpid
, 0));
526 /* Add child. inferior_ptid was already set above. */
527 ti
= add_thread_silent (inferior_ptid
);
529 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
530 memset (ti
->private, 0,
531 sizeof (struct inf_ttrace_private_thread_info
));
533 /* Reset breakpoints in the child as appropriate. */
534 follow_inferior_reset_breakpoints ();
541 /* File descriptors for pipes used as semaphores during initial
542 startup of an inferior. */
543 static int inf_ttrace_pfd1
[2];
544 static int inf_ttrace_pfd2
[2];
547 do_cleanup_pfds (void *dummy
)
549 close (inf_ttrace_pfd1
[0]);
550 close (inf_ttrace_pfd1
[1]);
551 close (inf_ttrace_pfd2
[0]);
552 close (inf_ttrace_pfd2
[1]);
556 inf_ttrace_prepare (void)
558 if (pipe (inf_ttrace_pfd1
) == -1)
559 perror_with_name (("pipe"));
561 if (pipe (inf_ttrace_pfd2
) == -1)
563 close (inf_ttrace_pfd1
[0]);
564 close (inf_ttrace_pfd2
[0]);
565 perror_with_name (("pipe"));
569 /* Prepare to be traced. */
574 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
577 /* "Trace me, Dr. Memory!" */
578 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
579 perror_with_name (("ttrace"));
581 /* Tell our parent that we are ready to be traced. */
582 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
583 perror_with_name (("write"));
585 /* Wait until our parent has set the initial event mask. */
586 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
587 perror_with_name (("read"));
589 do_cleanups (old_chain
);
592 /* Start tracing PID. */
595 inf_ttrace_him (int pid
)
597 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
601 /* Wait until our child is ready to be traced. */
602 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
603 perror_with_name (("read"));
605 /* Set the initial event mask. */
606 memset (&tte
, 0, sizeof (tte
));
607 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
608 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
609 #ifdef TTEVT_BPT_SSTEP
610 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
612 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
613 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
614 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
615 perror_with_name (("ttrace"));
617 /* Tell our child that we have set the initial event mask. */
618 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
619 perror_with_name (("write"));
621 do_cleanups (old_chain
);
623 push_target (ttrace_ops_hack
);
625 /* On some targets, there must be some explicit synchronization
626 between the parent and child processes after the debugger forks,
627 and before the child execs the debuggee program. This call
628 basically gives permission for the child to exec. */
630 target_acknowledge_created_inferior (pid
);
632 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
633 be 1 or 2 depending on whether we're starting without or with a
635 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
637 /* On some targets, there must be some explicit actions taken after
638 the inferior has been started up. */
639 target_post_startup_inferior (pid_to_ptid (pid
));
643 inf_ttrace_create_inferior (char *exec_file
, char *allargs
, char **env
,
646 gdb_assert (inf_ttrace_num_lwps
== 0);
647 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
648 gdb_assert (inf_ttrace_page_dict
.count
== 0);
649 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
650 gdb_assert (inf_ttrace_vfork_ppid
== -1);
652 fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, inf_ttrace_him
,
653 inf_ttrace_prepare
, NULL
);
657 inf_ttrace_mourn_inferior (void)
659 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
662 inf_ttrace_num_lwps
= 0;
663 inf_ttrace_num_lwps_in_syscall
= 0;
665 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
667 struct inf_ttrace_page
*page
;
668 struct inf_ttrace_page
*next
;
670 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
678 inf_ttrace_page_dict
.count
= 0;
680 unpush_target (ttrace_ops_hack
);
681 generic_mourn_inferior ();
685 inf_ttrace_attach (char *args
, int from_tty
)
693 error_no_arg (_("process-id to attach"));
696 pid
= strtol (args
, &dummy
, 0);
697 if (pid
== 0 && args
== dummy
)
698 error (_("Illegal process-id: %s."), args
);
700 if (pid
== getpid ()) /* Trying to masturbate? */
701 error (_("I refuse to debug myself!"));
705 exec_file
= get_exec_file (0);
708 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
709 target_pid_to_str (pid_to_ptid (pid
)));
711 printf_unfiltered (_("Attaching to %s\n"),
712 target_pid_to_str (pid_to_ptid (pid
)));
714 gdb_flush (gdb_stdout
);
717 gdb_assert (inf_ttrace_num_lwps
== 0);
718 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
719 gdb_assert (inf_ttrace_vfork_ppid
== -1);
721 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
722 perror_with_name (("ttrace"));
725 /* Set the initial event mask. */
726 memset (&tte
, 0, sizeof (tte
));
727 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
728 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
729 #ifdef TTEVT_BPT_SSTEP
730 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
732 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
733 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
734 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
735 perror_with_name (("ttrace"));
737 push_target (ttrace_ops_hack
);
739 /* We'll bump inf_ttrace_num_lwps up and add the private data to the
740 thread as soon as we get to inf_ttrace_wait. At this point, we
741 don't have lwpid info yet. */
742 inferior_ptid
= pid_to_ptid (pid
);
743 add_thread_silent (inferior_ptid
);
747 inf_ttrace_detach (char *args
, int from_tty
)
749 pid_t pid
= ptid_get_pid (inferior_ptid
);
754 char *exec_file
= get_exec_file (0);
757 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
758 target_pid_to_str (pid_to_ptid (pid
)));
759 gdb_flush (gdb_stdout
);
764 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
765 can pass a signal number here. Does this really work? */
766 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
767 perror_with_name (("ttrace"));
769 if (inf_ttrace_vfork_ppid
!= -1)
771 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
772 perror_with_name (("ttrace"));
773 inf_ttrace_vfork_ppid
= -1;
776 inf_ttrace_num_lwps
= 0;
777 inf_ttrace_num_lwps_in_syscall
= 0;
779 unpush_target (ttrace_ops_hack
);
780 inferior_ptid
= null_ptid
;
784 inf_ttrace_kill (void)
786 pid_t pid
= ptid_get_pid (inferior_ptid
);
791 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
792 perror_with_name (("ttrace"));
793 /* ??? Is it necessary to call ttrace_wait() here? */
795 if (inf_ttrace_vfork_ppid
!= -1)
797 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
798 perror_with_name (("ttrace"));
799 inf_ttrace_vfork_ppid
= -1;
802 target_mourn_inferior ();
805 /* Check is a dying thread is dead by now, and delete it from GDBs
806 thread list if so. */
808 inf_ttrace_delete_dead_threads_callback (struct thread_info
*info
, void *arg
)
811 struct inf_ttrace_private_thread_info
*p
;
813 if (is_exited (info
->ptid
))
816 lwpid
= ptid_get_lwp (info
->ptid
);
817 p
= (struct inf_ttrace_private_thread_info
*) info
->private;
819 /* Check if an lwp that was dying is still there or not. */
820 if (p
->dying
&& (kill (lwpid
, 0) == -1))
822 delete_thread (info
->ptid
);
827 /* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
831 inf_ttrace_resume_lwp (struct thread_info
*info
, ttreq_t request
, int sig
)
833 pid_t pid
= ptid_get_pid (info
->ptid
);
834 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
836 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
838 struct inf_ttrace_private_thread_info
*p
839 = (struct inf_ttrace_private_thread_info
*) info
->private;
840 if (p
->dying
&& errno
== EPROTO
)
841 /* This is expected, it means the dying lwp is really gone
842 by now. If ttrace had an event to inform the debugger
843 the lwp is really gone, this wouldn't be needed. */
844 delete_thread (info
->ptid
);
846 /* This was really unexpected. */
847 perror_with_name (("ttrace"));
851 /* Callback for iterate_over_threads. */
854 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
856 if (!ptid_equal (info
->ptid
, inferior_ptid
) && !is_exited (info
->ptid
))
857 inf_ttrace_resume_lwp (info
, TT_LWP_CONTINUE
, 0);
863 inf_ttrace_resume (ptid_t ptid
, int step
, enum target_signal signal
)
866 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
867 int sig
= target_signal_to_host (signal
);
868 struct thread_info
*info
;
870 /* A specific PTID means `step only this process id'. */
871 resume_all
= (ptid_equal (ptid
, minus_one_ptid
));
873 /* If resuming all threads, it's the current thread that should be
874 handled specially. */
876 ptid
= inferior_ptid
;
878 info
= thread_find_pid (ptid
);
879 inf_ttrace_resume_lwp (info
, request
, sig
);
882 /* Let all the other threads run too. */
883 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
887 inf_ttrace_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
889 pid_t pid
= ptid_get_pid (ptid
);
890 lwpid_t lwpid
= ptid_get_lwp (ptid
);
892 struct thread_info
*ti
;
895 /* Until proven otherwise. */
896 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
901 gdb_assert (pid
!= 0 || lwpid
== 0);
908 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
909 perror_with_name (("ttrace_wait"));
911 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
913 if (inf_ttrace_vfork_ppid
!= -1)
915 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
917 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
918 perror_with_name (("ttrace"));
919 inf_ttrace_vfork_ppid
= -1;
922 tts
.tts_event
= TTEVT_NONE
;
926 clear_sigint_trap ();
928 while (tts
.tts_event
== TTEVT_NONE
);
930 /* Now that we've waited, we can re-enable the page protections. */
931 if (inf_ttrace_reenable_page_protections
)
933 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
934 inf_ttrace_enable_page_protections (tts
.tts_pid
);
935 inf_ttrace_reenable_page_protections
= 0;
938 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
940 if (inf_ttrace_num_lwps
== 0)
942 struct thread_info
*ti
;
944 inf_ttrace_num_lwps
= 1;
946 /* This is the earliest we hear about the lwp member of
947 INFERIOR_PTID, after an attach or fork_inferior. */
948 gdb_assert (ptid_get_lwp (inferior_ptid
) == 0);
950 /* We haven't set the private member on the main thread yet. Do
952 ti
= find_thread_pid (inferior_ptid
);
953 gdb_assert (ti
!= NULL
&& ti
->private == NULL
);
955 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
956 memset (ti
->private, 0,
957 sizeof (struct inf_ttrace_private_thread_info
));
959 /* Notify the core that this ptid changed. This changes
960 inferior_ptid as well. */
961 thread_change_ptid (inferior_ptid
, ptid
);
964 switch (tts
.tts_event
)
966 #ifdef TTEVT_BPT_SSTEP
967 case TTEVT_BPT_SSTEP
:
968 /* Make it look like a breakpoint. */
969 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
970 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
975 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
976 ourstatus
->value
.execd_pathname
=
977 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
978 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
979 (uintptr_t)ourstatus
->value
.execd_pathname
,
980 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
981 perror_with_name (("ttrace"));
982 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
984 /* At this point, all inserted breakpoints are gone. Doing this
985 as soon as we detect an exec prevents the badness of deleting
986 a breakpoint writing the current "shadow contents" to lift
987 the bp. That shadow is NOT valid after an exec. */
988 mark_breakpoints_out ();
992 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
993 inf_ttrace_num_lwps
= 0;
997 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
998 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1000 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1001 ourstatus
->value
.related_pid
= related_ptid
;
1003 /* Make sure the other end of the fork is stopped too. */
1004 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
1005 tts
.tts_u
.tts_fork
.tts_flwpid
,
1006 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
1007 perror_with_name (("ttrace_wait"));
1009 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
1010 if (tts
.tts_u
.tts_fork
.tts_isparent
)
1012 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1013 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1014 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1015 ourstatus
->value
.related_pid
= related_ptid
;
1020 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
1022 related_ptid
= ptid_build (tts
.tts_u
.tts_fork
.tts_fpid
,
1023 tts
.tts_u
.tts_fork
.tts_flwpid
, 0);
1025 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1026 ourstatus
->value
.related_pid
= related_ptid
;
1028 /* HACK: To avoid touching the parent during the vfork, switch
1030 inferior_ptid
= ptid
;
1033 case TTEVT_LWP_CREATE
:
1034 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1035 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1036 ti
= add_thread (ptid
);
1038 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
1039 memset (ti
->private, 0,
1040 sizeof (struct inf_ttrace_private_thread_info
));
1041 inf_ttrace_num_lwps
++;
1042 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1045 case TTEVT_LWP_EXIT
:
1046 if (print_thread_events
)
1047 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
1048 ti
= find_thread_pid (ptid
);
1049 gdb_assert (ti
!= NULL
);
1050 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1051 inf_ttrace_num_lwps
--;
1052 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
1053 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
1054 /* If we don't return -1 here, core GDB will re-add the thread. */
1055 ptid
= minus_one_ptid
;
1058 case TTEVT_LWP_TERMINATE
:
1059 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
1060 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
1061 printf_filtered(_("[%s has been terminated]\n"), target_pid_to_str (ptid
));
1062 ti
= find_thread_pid (ptid
);
1063 gdb_assert (ti
!= NULL
);
1064 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
1065 inf_ttrace_num_lwps
--;
1066 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
1070 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1071 ourstatus
->value
.sig
=
1072 target_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1075 case TTEVT_SYSCALL_ENTRY
:
1076 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1077 inf_ttrace_num_lwps_in_syscall
++;
1078 if (inf_ttrace_num_lwps_in_syscall
== 1)
1080 /* A thread has just entered a system call. Disable any
1081 page protections as the kernel can't deal with them. */
1082 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1084 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1085 ourstatus
->value
.syscall_id
= tts
.tts_scno
;
1088 case TTEVT_SYSCALL_RETURN
:
1089 if (inf_ttrace_num_lwps_in_syscall
> 0)
1091 /* If the last thread has just left the system call, this
1092 would be a logical place to re-enable the page
1093 protections, but that doesn't work. We can't re-enable
1094 them until we've done another wait. */
1095 inf_ttrace_reenable_page_protections
=
1096 (inf_ttrace_num_lwps_in_syscall
== 1);
1097 inf_ttrace_num_lwps_in_syscall
--;
1099 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1100 ourstatus
->value
.syscall_id
= tts
.tts_scno
;
1104 gdb_assert (!"Unexpected ttrace event");
1108 /* Make sure all threads within the process are stopped. */
1109 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1110 perror_with_name (("ttrace"));
1112 /* Now that the whole process is stopped, check if any dying thread
1113 is really dead by now. If a dying thread is still alive, it will
1114 be stopped too, and will still show up in `info threads', tagged
1115 with "(Exiting)". We could make `info threads' prune dead
1116 threads instead via inf_ttrace_thread_alive, but doing this here
1117 has the advantage that a frontend is notificed sooner of thread
1118 exits. Note that a dying lwp is still alive, it still has to be
1119 resumed, like any other lwp. */
1120 iterate_over_threads (inf_ttrace_delete_dead_threads_callback
, NULL
);
1125 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1126 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1127 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1128 corresponding transfer doesn't happen. Return the number of bytes
1129 actually transferred (which may be zero if an error occurs). */
1132 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1133 void *readbuf
, const void *writebuf
)
1135 pid_t pid
= ptid_get_pid (inferior_ptid
);
1137 /* HP-UX treats text space and data space differently. GDB however,
1138 doesn't really know the difference. Therefore we try both. Try
1139 text space before data space though because when we're writing
1140 into text space the instruction cache might need to be flushed. */
1143 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1144 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1148 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1149 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1156 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1157 const char *annex
, gdb_byte
*readbuf
,
1158 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1162 case TARGET_OBJECT_MEMORY
:
1163 return inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1165 case TARGET_OBJECT_UNWIND_TABLE
:
1168 case TARGET_OBJECT_AUXV
:
1171 case TARGET_OBJECT_WCOOKIE
:
1179 /* Print status information about what we're accessing. */
1182 inf_ttrace_files_info (struct target_ops
*ignore
)
1184 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1185 attach_flag
? "attached" : "child",
1186 target_pid_to_str (inferior_ptid
));
1190 inf_ttrace_thread_alive (ptid_t ptid
)
1195 /* Return a string describing the state of the thread specified by
1199 inf_ttrace_extra_thread_info (struct thread_info
*info
)
1201 struct inf_ttrace_private_thread_info
* private =
1202 (struct inf_ttrace_private_thread_info
*) info
->private;
1204 if (private != NULL
&& private->dying
)
1211 inf_ttrace_pid_to_str (ptid_t ptid
)
1213 pid_t pid
= ptid_get_pid (ptid
);
1214 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1215 static char buf
[128];
1218 xsnprintf (buf
, sizeof buf
, "process %ld",
1221 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1222 (long) pid
, (long) lwpid
);
1228 inf_ttrace_target (void)
1230 struct target_ops
*t
= inf_child_target ();
1232 t
->to_attach
= inf_ttrace_attach
;
1233 t
->to_detach
= inf_ttrace_detach
;
1234 t
->to_resume
= inf_ttrace_resume
;
1235 t
->to_wait
= inf_ttrace_wait
;
1236 t
->to_files_info
= inf_ttrace_files_info
;
1237 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1238 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1239 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1240 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1241 t
->to_region_ok_for_hw_watchpoint
=
1242 inf_ttrace_region_ok_for_hw_watchpoint
;
1243 t
->to_kill
= inf_ttrace_kill
;
1244 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1245 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1246 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1247 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1248 t
->to_extra_thread_info
= inf_ttrace_extra_thread_info
;
1249 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1250 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1252 ttrace_ops_hack
= t
;
1258 /* Prevent warning from -Wmissing-prototypes. */
1259 void _initialize_hppa_hpux_nat (void);
1262 _initialize_inf_ttrace (void)
1265 inf_ttrace_page_dict
.pagesize
= getpagesize();