1 /* Low-level child interface to ttrace.
3 Copyright (C) 2004, 2005, 2006, 2007 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>
37 #include "inf-child.h"
38 #include "inf-ttrace.h"
40 /* HACK: Save the ttrace ops returned by inf_ttrace_target. */
41 static struct target_ops
*ttrace_ops_hack
;
44 /* HP-UX uses a threading model where each user-space thread
45 corresponds to a kernel thread. These kernel threads are called
46 lwps. The ttrace(2) interface gives us almost full control over
47 the threads, which makes it very easy to support them in GDB. We
48 identify the threads by process ID and lwp ID. The ttrace(2) also
49 provides us with a thread's user ID (in the `tts_user_tid' member
50 of `ttstate_t') but we don't use that (yet) as it isn't necessary
51 to uniquely label the thread. */
53 /* Number of active lwps. */
54 static int inf_ttrace_num_lwps
;
57 /* On HP-UX versions that have the ttrace(2) system call, we can
58 implement "hardware" watchpoints by fiddling with the protection of
59 pages in the address space that contain the variable being watched.
60 In order to implement this, we keep a dictionary of pages for which
61 we have changed the protection. */
63 struct inf_ttrace_page
65 CORE_ADDR addr
; /* Page address. */
66 int prot
; /* Protection. */
67 int refcount
; /* Reference count. */
68 struct inf_ttrace_page
*next
;
69 struct inf_ttrace_page
*prev
;
72 struct inf_ttrace_page_dict
74 struct inf_ttrace_page buckets
[128];
75 int pagesize
; /* Page size. */
76 int count
; /* Number of pages in this dictionary. */
77 } inf_ttrace_page_dict
;
79 struct inf_ttrace_private_thread_info
84 /* Number of lwps that are currently in a system call. */
85 static int inf_ttrace_num_lwps_in_syscall
;
87 /* Flag to indicate whether we should re-enable page protections after
89 static int inf_ttrace_reenable_page_protections
;
91 /* Enable system call events for process PID. */
94 inf_ttrace_enable_syscall_events (pid_t pid
)
99 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
101 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
102 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
103 perror_with_name (("ttrace"));
105 tte
.tte_events
|= (TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
107 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
108 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
109 perror_with_name (("ttrace"));
111 if (ttrace (TT_PROC_GET_FIRST_LWP_STATE
, pid
, 0,
112 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
113 perror_with_name (("ttrace"));
115 if (tts
.tts_flags
& TTS_INSYSCALL
)
116 inf_ttrace_num_lwps_in_syscall
++;
118 /* FIXME: Handle multiple threads. */
121 /* Disable system call events for process PID. */
124 inf_ttrace_disable_syscall_events (pid_t pid
)
128 gdb_assert (inf_ttrace_page_dict
.count
== 0);
130 if (ttrace (TT_PROC_GET_EVENT_MASK
, pid
, 0,
131 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
132 perror_with_name (("ttrace"));
134 tte
.tte_events
&= ~(TTEVT_SYSCALL_ENTRY
| TTEVT_SYSCALL_RETURN
);
136 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
137 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
138 perror_with_name (("ttrace"));
140 inf_ttrace_num_lwps_in_syscall
= 0;
143 /* Get information about the page at address ADDR for process PID from
146 static struct inf_ttrace_page
*
147 inf_ttrace_get_page (pid_t pid
, CORE_ADDR addr
)
149 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
150 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
152 struct inf_ttrace_page
*page
;
154 bucket
= (addr
/ pagesize
) % num_buckets
;
155 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
158 if (page
->addr
== addr
)
167 /* Add the page at address ADDR for process PID to the dictionary. */
169 static struct inf_ttrace_page
*
170 inf_ttrace_add_page (pid_t pid
, CORE_ADDR addr
)
172 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
173 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
175 struct inf_ttrace_page
*page
;
176 struct inf_ttrace_page
*prev
= NULL
;
178 bucket
= (addr
/ pagesize
) % num_buckets
;
179 page
= &inf_ttrace_page_dict
.buckets
[bucket
];
182 if (page
->addr
== addr
)
193 if (ttrace (TT_PROC_GET_MPROTECT
, pid
, 0,
194 addr
, 0, (uintptr_t)&prot
) == -1)
195 perror_with_name (("ttrace"));
197 page
= XMALLOC (struct inf_ttrace_page
);
206 inf_ttrace_page_dict
.count
++;
207 if (inf_ttrace_page_dict
.count
== 1)
208 inf_ttrace_enable_syscall_events (pid
);
210 if (inf_ttrace_num_lwps_in_syscall
== 0)
212 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
213 addr
, pagesize
, prot
& ~PROT_WRITE
) == -1)
214 perror_with_name (("ttrace"));
221 /* Insert the page at address ADDR of process PID to the dictionary. */
224 inf_ttrace_insert_page (pid_t pid
, CORE_ADDR addr
)
226 struct inf_ttrace_page
*page
;
228 page
= inf_ttrace_get_page (pid
, addr
);
230 page
= inf_ttrace_add_page (pid
, addr
);
235 /* Remove the page at address ADDR of process PID from the dictionary. */
238 inf_ttrace_remove_page (pid_t pid
, CORE_ADDR addr
)
240 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
241 struct inf_ttrace_page
*page
;
243 page
= inf_ttrace_get_page (pid
, addr
);
246 gdb_assert (page
->refcount
>= 0);
248 if (page
->refcount
== 0)
250 if (inf_ttrace_num_lwps_in_syscall
== 0)
252 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
253 addr
, pagesize
, page
->prot
) == -1)
254 perror_with_name (("ttrace"));
257 inf_ttrace_page_dict
.count
--;
258 if (inf_ttrace_page_dict
.count
== 0)
259 inf_ttrace_disable_syscall_events (pid
);
261 page
->prev
->next
= page
->next
;
263 page
->next
->prev
= page
->prev
;
269 /* Mask the bits in PROT from the page protections that are currently
270 in the dictionary for process PID. */
273 inf_ttrace_mask_page_protections (pid_t pid
, int prot
)
275 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
276 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
279 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
281 struct inf_ttrace_page
*page
;
283 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
286 if (ttrace (TT_PROC_SET_MPROTECT
, pid
, 0,
287 page
->addr
, pagesize
, page
->prot
& ~prot
) == -1)
288 perror_with_name (("ttrace"));
295 /* Write-protect the pages in the dictionary for process PID. */
298 inf_ttrace_enable_page_protections (pid_t pid
)
300 inf_ttrace_mask_page_protections (pid
, PROT_WRITE
);
303 /* Restore the protection of the pages in the dictionary for process
307 inf_ttrace_disable_page_protections (pid_t pid
)
309 inf_ttrace_mask_page_protections (pid
, 0);
312 /* Insert a "hardware" watchpoint for LEN bytes at address ADDR of
316 inf_ttrace_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
318 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
319 pid_t pid
= ptid_get_pid (inferior_ptid
);
324 gdb_assert (type
== hw_write
);
326 page_addr
= (addr
/ pagesize
) * pagesize
;
327 num_pages
= (len
+ pagesize
- 1) / pagesize
;
329 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
330 inf_ttrace_insert_page (pid
, page_addr
);
335 /* Remove a "hardware" watchpoint for LEN bytes at address ADDR of
339 inf_ttrace_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
341 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
342 pid_t pid
= ptid_get_pid (inferior_ptid
);
347 gdb_assert (type
== hw_write
);
349 page_addr
= (addr
/ pagesize
) * pagesize
;
350 num_pages
= (len
+ pagesize
- 1) / pagesize
;
352 for (page
= 0; page
< num_pages
; page
++, page_addr
+= pagesize
)
353 inf_ttrace_remove_page (pid
, page_addr
);
359 inf_ttrace_can_use_hw_breakpoint (int type
, int len
, int ot
)
361 return (type
== bp_hardware_watchpoint
);
365 inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
370 /* Return non-zero if the current inferior was (potentially) stopped
371 by hitting a "hardware" watchpoint. */
374 inf_ttrace_stopped_by_watchpoint (void)
376 pid_t pid
= ptid_get_pid (inferior_ptid
);
377 lwpid_t lwpid
= ptid_get_lwp (inferior_ptid
);
380 if (inf_ttrace_page_dict
.count
> 0)
382 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
383 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
384 perror_with_name (("ttrace"));
386 if (tts
.tts_event
== TTEVT_SIGNAL
387 && tts
.tts_u
.tts_signal
.tts_signo
== SIGBUS
)
389 const int pagesize
= inf_ttrace_page_dict
.pagesize
;
390 void *addr
= tts
.tts_u
.tts_signal
.tts_siginfo
.si_addr
;
391 CORE_ADDR page_addr
= ((uintptr_t)addr
/ pagesize
) * pagesize
;
393 if (inf_ttrace_get_page (pid
, page_addr
))
402 /* When tracking a vfork(2), we cannot detach from the parent until
403 after the child has called exec(3) or has exited. If we are still
404 attached to the parent, this variable will be set to the process ID
405 of the parent. Otherwise it will be set to zero. */
406 static pid_t inf_ttrace_vfork_ppid
= -1;
409 inf_ttrace_follow_fork (struct target_ops
*ops
, int follow_child
)
412 lwpid_t lwpid
, flwpid
;
415 /* FIXME: kettenis/20050720: This stuff should really be passed as
416 an argument by our caller. */
419 struct target_waitstatus status
;
421 get_last_target_status (&ptid
, &status
);
422 gdb_assert (status
.kind
== TARGET_WAITKIND_FORKED
423 || status
.kind
== TARGET_WAITKIND_VFORKED
);
425 pid
= ptid_get_pid (ptid
);
426 lwpid
= ptid_get_lwp (ptid
);
429 /* Get all important details that core GDB doesn't (and shouldn't)
431 if (ttrace (TT_LWP_GET_STATE
, pid
, lwpid
,
432 (uintptr_t)&tts
, sizeof tts
, 0) == -1)
433 perror_with_name (("ttrace"));
435 gdb_assert (tts
.tts_event
== TTEVT_FORK
|| tts
.tts_event
== TTEVT_VFORK
);
437 if (tts
.tts_u
.tts_fork
.tts_isparent
)
440 lwpid
= tts
.tts_lwpid
;
441 fpid
= tts
.tts_u
.tts_fork
.tts_fpid
;
442 flwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
446 pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
447 lwpid
= tts
.tts_u
.tts_fork
.tts_flwpid
;
449 flwpid
= tts
.tts_lwpid
;
454 inferior_ptid
= ptid_build (fpid
, flwpid
, 0);
455 detach_breakpoints (pid
);
457 target_terminal_ours ();
458 fprintf_unfiltered (gdb_stdlog
, _("\
459 Attaching after fork to child process %ld.\n"), (long)fpid
);
463 inferior_ptid
= ptid_build (pid
, lwpid
, 0);
464 detach_breakpoints (fpid
);
466 target_terminal_ours ();
467 fprintf_unfiltered (gdb_stdlog
, _("\
468 Detaching after fork from child process %ld.\n"), (long)fpid
);
471 if (tts
.tts_event
== TTEVT_VFORK
)
473 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
477 /* We can't detach from the parent yet. */
478 inf_ttrace_vfork_ppid
= pid
;
480 reattach_breakpoints (fpid
);
484 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
485 perror_with_name (("ttrace"));
487 /* Wait till we get the TTEVT_VFORK event in the parent.
488 This indicates that the child has called exec(3) or has
489 exited and that the parent is ready to be traced again. */
490 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
491 perror_with_name (("ttrace_wait"));
492 gdb_assert (tts
.tts_event
== TTEVT_VFORK
);
493 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
495 reattach_breakpoints (pid
);
500 gdb_assert (tts
.tts_u
.tts_fork
.tts_isparent
);
504 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, 0, 0) == -1)
505 perror_with_name (("ttrace"));
509 if (ttrace (TT_PROC_DETACH
, fpid
, 0, 0, 0, 0) == -1)
510 perror_with_name (("ttrace"));
516 /* The child will start out single-threaded. */
517 inf_ttrace_num_lwps
= 0;
518 inf_ttrace_num_lwps_in_syscall
= 0;
520 /* Reset breakpoints in the child as appropriate. */
521 follow_inferior_reset_breakpoints ();
528 /* File descriptors for pipes used as semaphores during initial
529 startup of an inferior. */
530 static int inf_ttrace_pfd1
[2];
531 static int inf_ttrace_pfd2
[2];
534 do_cleanup_pfds (void *dummy
)
536 close (inf_ttrace_pfd1
[0]);
537 close (inf_ttrace_pfd1
[1]);
538 close (inf_ttrace_pfd2
[0]);
539 close (inf_ttrace_pfd2
[1]);
543 inf_ttrace_prepare (void)
545 if (pipe (inf_ttrace_pfd1
) == -1)
546 perror_with_name (("pipe"));
548 if (pipe (inf_ttrace_pfd2
) == -1)
550 close (inf_ttrace_pfd1
[0]);
551 close (inf_ttrace_pfd2
[0]);
552 perror_with_name (("pipe"));
556 /* Prepare to be traced. */
561 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
564 /* "Trace me, Dr. Memory!" */
565 if (ttrace (TT_PROC_SETTRC
, 0, 0, 0, TT_VERSION
, 0) == -1)
566 perror_with_name (("ttrace"));
568 /* Tell our parent that we are ready to be traced. */
569 if (write (inf_ttrace_pfd1
[1], &c
, sizeof c
) != sizeof c
)
570 perror_with_name (("write"));
572 /* Wait until our parent has set the initial event mask. */
573 if (read (inf_ttrace_pfd2
[0], &c
, sizeof c
) != sizeof c
)
574 perror_with_name (("read"));
576 do_cleanups (old_chain
);
579 /* Start tracing PID. */
582 inf_ttrace_him (int pid
)
584 struct cleanup
*old_chain
= make_cleanup (do_cleanup_pfds
, 0);
588 /* Wait until our child is ready to be traced. */
589 if (read (inf_ttrace_pfd1
[0], &c
, sizeof c
) != sizeof c
)
590 perror_with_name (("read"));
592 /* Set the initial event mask. */
593 memset (&tte
, 0, sizeof (tte
));
594 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
595 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
596 #ifdef TTEVT_BPT_SSTEP
597 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
599 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
600 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
601 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
602 perror_with_name (("ttrace"));
604 /* Tell our child that we have set the initial event mask. */
605 if (write (inf_ttrace_pfd2
[1], &c
, sizeof c
) != sizeof c
)
606 perror_with_name (("write"));
608 do_cleanups (old_chain
);
610 push_target (ttrace_ops_hack
);
612 /* On some targets, there must be some explicit synchronization
613 between the parent and child processes after the debugger forks,
614 and before the child execs the debuggee program. This call
615 basically gives permission for the child to exec. */
617 target_acknowledge_created_inferior (pid
);
619 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
620 be 1 or 2 depending on whether we're starting without or with a
622 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
624 /* On some targets, there must be some explicit actions taken after
625 the inferior has been started up. */
626 target_post_startup_inferior (pid_to_ptid (pid
));
630 inf_ttrace_create_inferior (char *exec_file
, char *allargs
, char **env
,
633 gdb_assert (inf_ttrace_num_lwps
== 0);
634 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
635 gdb_assert (inf_ttrace_page_dict
.count
== 0);
636 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
637 gdb_assert (inf_ttrace_vfork_ppid
== -1);
639 fork_inferior (exec_file
, allargs
, env
, inf_ttrace_me
, inf_ttrace_him
,
640 inf_ttrace_prepare
, NULL
);
644 inf_ttrace_mourn_inferior (void)
646 const int num_buckets
= ARRAY_SIZE (inf_ttrace_page_dict
.buckets
);
649 inf_ttrace_num_lwps
= 0;
650 inf_ttrace_num_lwps_in_syscall
= 0;
652 for (bucket
= 0; bucket
< num_buckets
; bucket
++)
654 struct inf_ttrace_page
*page
;
655 struct inf_ttrace_page
*next
;
657 page
= inf_ttrace_page_dict
.buckets
[bucket
].next
;
665 inf_ttrace_page_dict
.count
= 0;
667 unpush_target (ttrace_ops_hack
);
668 generic_mourn_inferior ();
672 inf_ttrace_attach (char *args
, int from_tty
)
680 error_no_arg (_("process-id to attach"));
683 pid
= strtol (args
, &dummy
, 0);
684 if (pid
== 0 && args
== dummy
)
685 error (_("Illegal process-id: %s."), args
);
687 if (pid
== getpid ()) /* Trying to masturbate? */
688 error (_("I refuse to debug myself!"));
692 exec_file
= get_exec_file (0);
695 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
696 target_pid_to_str (pid_to_ptid (pid
)));
698 printf_unfiltered (_("Attaching to %s\n"),
699 target_pid_to_str (pid_to_ptid (pid
)));
701 gdb_flush (gdb_stdout
);
704 gdb_assert (inf_ttrace_num_lwps
== 0);
705 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
706 gdb_assert (inf_ttrace_vfork_ppid
== -1);
708 if (ttrace (TT_PROC_ATTACH
, pid
, 0, TT_KILL_ON_EXIT
, TT_VERSION
, 0) == -1)
709 perror_with_name (("ttrace"));
712 /* Set the initial event mask. */
713 memset (&tte
, 0, sizeof (tte
));
714 tte
.tte_events
|= TTEVT_EXEC
| TTEVT_EXIT
| TTEVT_FORK
| TTEVT_VFORK
;
715 tte
.tte_events
|= TTEVT_LWP_CREATE
| TTEVT_LWP_EXIT
| TTEVT_LWP_TERMINATE
;
716 #ifdef TTEVT_BPT_SSTEP
717 tte
.tte_events
|= TTEVT_BPT_SSTEP
;
719 tte
.tte_opts
|= TTEO_PROC_INHERIT
;
720 if (ttrace (TT_PROC_SET_EVENT_MASK
, pid
, 0,
721 (uintptr_t)&tte
, sizeof tte
, 0) == -1)
722 perror_with_name (("ttrace"));
724 inferior_ptid
= pid_to_ptid (pid
);
725 push_target (ttrace_ops_hack
);
729 inf_ttrace_detach (char *args
, int from_tty
)
731 pid_t pid
= ptid_get_pid (inferior_ptid
);
736 char *exec_file
= get_exec_file (0);
739 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
740 target_pid_to_str (pid_to_ptid (pid
)));
741 gdb_flush (gdb_stdout
);
746 /* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
747 can pass a signal number here. Does this really work? */
748 if (ttrace (TT_PROC_DETACH
, pid
, 0, 0, sig
, 0) == -1)
749 perror_with_name (("ttrace"));
751 if (inf_ttrace_vfork_ppid
!= -1)
753 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
754 perror_with_name (("ttrace"));
755 inf_ttrace_vfork_ppid
= -1;
758 inf_ttrace_num_lwps
= 0;
759 inf_ttrace_num_lwps_in_syscall
= 0;
761 unpush_target (ttrace_ops_hack
);
762 inferior_ptid
= null_ptid
;
766 inf_ttrace_kill (void)
768 pid_t pid
= ptid_get_pid (inferior_ptid
);
773 if (ttrace (TT_PROC_EXIT
, pid
, 0, 0, 0, 0) == -1)
774 perror_with_name (("ttrace"));
775 /* ??? Is it necessary to call ttrace_wait() here? */
777 if (inf_ttrace_vfork_ppid
!= -1)
779 if (ttrace (TT_PROC_DETACH
, inf_ttrace_vfork_ppid
, 0, 0, 0, 0) == -1)
780 perror_with_name (("ttrace"));
781 inf_ttrace_vfork_ppid
= -1;
784 target_mourn_inferior ();
788 inf_ttrace_resume_callback (struct thread_info
*info
, void *arg
)
790 if (!ptid_equal (info
->ptid
, inferior_ptid
))
792 pid_t pid
= ptid_get_pid (info
->ptid
);
793 lwpid_t lwpid
= ptid_get_lwp (info
->ptid
);
795 if (ttrace (TT_LWP_CONTINUE
, pid
, lwpid
, TT_NOPC
, 0, 0) == -1)
796 perror_with_name (("ttrace"));
803 inf_ttrace_delete_dying_threads_callback (struct thread_info
*info
, void *arg
)
805 if (((struct inf_ttrace_private_thread_info
*)info
->private)->dying
== 1)
806 delete_thread (info
->ptid
);
811 inf_ttrace_resume (ptid_t ptid
, int step
, enum target_signal signal
)
813 pid_t pid
= ptid_get_pid (ptid
);
814 lwpid_t lwpid
= ptid_get_lwp (ptid
);
815 ttreq_t request
= step
? TT_LWP_SINGLE
: TT_LWP_CONTINUE
;
816 int sig
= target_signal_to_host (signal
);
820 pid
= ptid_get_pid (inferior_ptid
);
821 lwpid
= ptid_get_lwp (inferior_ptid
);
824 if (ttrace (request
, pid
, lwpid
, TT_NOPC
, sig
, 0) == -1)
825 perror_with_name (("ttrace"));
827 if (ptid_equal (ptid
, minus_one_ptid
) && inf_ttrace_num_lwps
> 0)
829 /* Let all the other threads run too. */
830 iterate_over_threads (inf_ttrace_resume_callback
, NULL
);
831 iterate_over_threads (inf_ttrace_delete_dying_threads_callback
, NULL
);
836 inf_ttrace_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
838 pid_t pid
= ptid_get_pid (ptid
);
839 lwpid_t lwpid
= ptid_get_lwp (ptid
);
841 struct thread_info
*ti
;
843 /* Until proven otherwise. */
844 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
849 gdb_assert (pid
!= 0 || lwpid
== 0);
856 if (ttrace_wait (pid
, lwpid
, TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
857 perror_with_name (("ttrace_wait"));
859 if (tts
.tts_event
== TTEVT_VFORK
&& tts
.tts_u
.tts_fork
.tts_isparent
)
861 if (inf_ttrace_vfork_ppid
!= -1)
863 gdb_assert (inf_ttrace_vfork_ppid
== tts
.tts_pid
);
865 if (ttrace (TT_PROC_DETACH
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
866 perror_with_name (("ttrace"));
867 inf_ttrace_vfork_ppid
= -1;
870 tts
.tts_event
= TTEVT_NONE
;
874 clear_sigint_trap ();
876 while (tts
.tts_event
== TTEVT_NONE
);
878 /* Now that we've waited, we can re-enable the page protections. */
879 if (inf_ttrace_reenable_page_protections
)
881 gdb_assert (inf_ttrace_num_lwps_in_syscall
== 0);
882 inf_ttrace_enable_page_protections (tts
.tts_pid
);
883 inf_ttrace_reenable_page_protections
= 0;
886 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
888 switch (tts
.tts_event
)
890 #ifdef TTEVT_BPT_SSTEP
891 case TTEVT_BPT_SSTEP
:
892 /* Make it look like a breakpoint. */
893 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
894 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
899 /* FIXME: kettenis/20051029: GDB doesn't really know how to deal
900 with TARGET_WAITKIND_EXECD events yet. So we make it look
901 like a SIGTRAP instead. */
903 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
904 ourstatus
->value
.execd_pathname
=
905 xmalloc (tts
.tts_u
.tts_exec
.tts_pathlen
+ 1);
906 if (ttrace (TT_PROC_GET_PATHNAME
, tts
.tts_pid
, 0,
907 (uintptr_t)ourstatus
->value
.execd_pathname
,
908 tts
.tts_u
.tts_exec
.tts_pathlen
, 0) == -1)
909 perror_with_name (("ttrace"));
910 ourstatus
->value
.execd_pathname
[tts
.tts_u
.tts_exec
.tts_pathlen
] = 0;
912 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
913 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
918 store_waitstatus (ourstatus
, tts
.tts_u
.tts_exit
.tts_exitcode
);
919 inf_ttrace_num_lwps
= 0;
923 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
924 ourstatus
->value
.related_pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
926 /* Make sure the other end of the fork is stopped too. */
927 if (ttrace_wait (tts
.tts_u
.tts_fork
.tts_fpid
,
928 tts
.tts_u
.tts_fork
.tts_flwpid
,
929 TTRACE_WAITOK
, &tts
, sizeof tts
) == -1)
930 perror_with_name (("ttrace_wait"));
932 gdb_assert (tts
.tts_event
== TTEVT_FORK
);
933 if (tts
.tts_u
.tts_fork
.tts_isparent
)
935 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
936 ourstatus
->value
.related_pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
941 gdb_assert (!tts
.tts_u
.tts_fork
.tts_isparent
);
943 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
944 ourstatus
->value
.related_pid
= tts
.tts_u
.tts_fork
.tts_fpid
;
946 /* HACK: To avoid touching the parent during the vfork, switch
948 inferior_ptid
= ptid
;
951 case TTEVT_LWP_CREATE
:
952 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
953 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
954 if (inf_ttrace_num_lwps
== 0)
956 /* Now that we're going to be multi-threaded, add the
957 original thread to the list first. */
958 ti
= add_thread (ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0));
960 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
961 memset (ti
->private, 0,
962 sizeof (struct inf_ttrace_private_thread_info
));
963 inf_ttrace_num_lwps
++;
965 printf_filtered (_("[New %s]\n"), target_pid_to_str (ptid
));
966 ti
= add_thread (ptid
);
968 xmalloc (sizeof (struct inf_ttrace_private_thread_info
));
969 memset (ti
->private, 0,
970 sizeof (struct inf_ttrace_private_thread_info
));
971 inf_ttrace_num_lwps
++;
972 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
976 printf_filtered(_("[%s exited]\n"), target_pid_to_str (ptid
));
977 ti
= find_thread_pid (ptid
);
978 gdb_assert (ti
!= NULL
);
979 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
980 inf_ttrace_num_lwps
--;
981 ttrace (TT_LWP_CONTINUE
, ptid_get_pid (ptid
),
982 ptid_get_lwp (ptid
), TT_NOPC
, 0, 0);
983 /* If we don't return -1 here, core GDB will re-add the thread. */
984 ptid
= minus_one_ptid
;
987 case TTEVT_LWP_TERMINATE
:
988 lwpid
= tts
.tts_u
.tts_thread
.tts_target_lwpid
;
989 ptid
= ptid_build (tts
.tts_pid
, lwpid
, 0);
990 printf_filtered(_("[%s has been terminated]\n"), target_pid_to_str (ptid
));
991 ti
= find_thread_pid (ptid
);
992 gdb_assert (ti
!= NULL
);
993 ((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
= 1;
994 inf_ttrace_num_lwps
--;
995 ptid
= ptid_build (tts
.tts_pid
, tts
.tts_lwpid
, 0);
999 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1000 ourstatus
->value
.sig
=
1001 target_signal_from_host (tts
.tts_u
.tts_signal
.tts_signo
);
1004 case TTEVT_SYSCALL_ENTRY
:
1005 gdb_assert (inf_ttrace_reenable_page_protections
== 0);
1006 inf_ttrace_num_lwps_in_syscall
++;
1007 if (inf_ttrace_num_lwps_in_syscall
== 1)
1009 /* A thread has just entered a system call. Disable any
1010 page protections as the kernel can't deal with them. */
1011 inf_ttrace_disable_page_protections (tts
.tts_pid
);
1013 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1014 ourstatus
->value
.syscall_id
= tts
.tts_scno
;
1017 case TTEVT_SYSCALL_RETURN
:
1018 if (inf_ttrace_num_lwps_in_syscall
> 0)
1020 /* If the last thread has just left the system call, this
1021 would be a logical place to re-enable the page
1022 protections, but that doesn't work. We can't re-enable
1023 them until we've done another wait. */
1024 inf_ttrace_reenable_page_protections
=
1025 (inf_ttrace_num_lwps_in_syscall
== 1);
1026 inf_ttrace_num_lwps_in_syscall
--;
1028 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1029 ourstatus
->value
.syscall_id
= tts
.tts_scno
;
1033 gdb_assert (!"Unexpected ttrace event");
1037 /* Make sure all threads within the process are stopped. */
1038 if (ttrace (TT_PROC_STOP
, tts
.tts_pid
, 0, 0, 0, 0) == -1)
1039 perror_with_name (("ttrace"));
1041 /* HACK: Twiddle INFERIOR_PTID such that the initial thread of a
1042 process isn't recognized as a new thread. */
1043 if (ptid_get_lwp (inferior_ptid
) == 0)
1044 inferior_ptid
= ptid
;
1049 /* Transfer LEN bytes from ADDR in the inferior's memory into READBUF,
1050 and transfer LEN bytes from WRITEBUF into the inferior's memory at
1051 ADDR. Either READBUF or WRITEBUF may be null, in which case the
1052 corresponding transfer doesn't happen. Return the number of bytes
1053 actually transferred (which may be zero if an error occurs). */
1056 inf_ttrace_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
1057 void *readbuf
, const void *writebuf
)
1059 pid_t pid
= ptid_get_pid (inferior_ptid
);
1061 /* HP-UX treats text space and data space differently. GDB however,
1062 doesn't really know the difference. Therefore we try both. Try
1063 text space before data space though because when we're writing
1064 into text space the instruction cache might need to be flushed. */
1067 && ttrace (TT_PROC_RDTEXT
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1
1068 && ttrace (TT_PROC_RDDATA
, pid
, 0, addr
, len
, (uintptr_t)readbuf
) == -1)
1072 && ttrace (TT_PROC_WRTEXT
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1
1073 && ttrace (TT_PROC_WRDATA
, pid
, 0, addr
, len
, (uintptr_t)writebuf
) == -1)
1080 inf_ttrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1081 const char *annex
, gdb_byte
*readbuf
,
1082 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1086 case TARGET_OBJECT_MEMORY
:
1087 return inf_ttrace_xfer_memory (offset
, len
, readbuf
, writebuf
);
1089 case TARGET_OBJECT_UNWIND_TABLE
:
1092 case TARGET_OBJECT_AUXV
:
1095 case TARGET_OBJECT_WCOOKIE
:
1103 /* Print status information about what we're accessing. */
1106 inf_ttrace_files_info (struct target_ops
*ignore
)
1108 printf_filtered (_("\tUsing the running image of %s %s.\n"),
1109 attach_flag
? "attached" : "child",
1110 target_pid_to_str (inferior_ptid
));
1114 inf_ttrace_thread_alive (ptid_t ptid
)
1116 struct thread_info
*ti
;
1117 ti
= find_thread_pid (ptid
);
1118 return !(((struct inf_ttrace_private_thread_info
*)ti
->private)->dying
);
1122 inf_ttrace_pid_to_str (ptid_t ptid
)
1124 if (inf_ttrace_num_lwps
> 0)
1126 pid_t pid
= ptid_get_pid (ptid
);
1127 lwpid_t lwpid
= ptid_get_lwp (ptid
);
1128 static char buf
[128];
1130 xsnprintf (buf
, sizeof buf
, "process %ld, lwp %ld",
1131 (long)pid
, (long)lwpid
);
1135 return normal_pid_to_str (ptid
);
1140 inf_ttrace_target (void)
1142 struct target_ops
*t
= inf_child_target ();
1144 t
->to_attach
= inf_ttrace_attach
;
1145 t
->to_detach
= inf_ttrace_detach
;
1146 t
->to_resume
= inf_ttrace_resume
;
1147 t
->to_wait
= inf_ttrace_wait
;
1148 t
->to_files_info
= inf_ttrace_files_info
;
1149 t
->to_can_use_hw_breakpoint
= inf_ttrace_can_use_hw_breakpoint
;
1150 t
->to_insert_watchpoint
= inf_ttrace_insert_watchpoint
;
1151 t
->to_remove_watchpoint
= inf_ttrace_remove_watchpoint
;
1152 t
->to_stopped_by_watchpoint
= inf_ttrace_stopped_by_watchpoint
;
1153 t
->to_region_ok_for_hw_watchpoint
=
1154 inf_ttrace_region_ok_for_hw_watchpoint
;
1155 t
->to_kill
= inf_ttrace_kill
;
1156 t
->to_create_inferior
= inf_ttrace_create_inferior
;
1157 t
->to_follow_fork
= inf_ttrace_follow_fork
;
1158 t
->to_mourn_inferior
= inf_ttrace_mourn_inferior
;
1159 t
->to_thread_alive
= inf_ttrace_thread_alive
;
1160 t
->to_pid_to_str
= inf_ttrace_pid_to_str
;
1161 t
->to_xfer_partial
= inf_ttrace_xfer_partial
;
1163 ttrace_ops_hack
= t
;
1169 /* Prevent warning from -Wmissing-prototypes. */
1170 void _initialize_hppa_hpux_nat (void);
1173 _initialize_inf_ttrace (void)
1176 inf_ttrace_page_dict
.pagesize
= getpagesize();